code.delx.au - gnu-emacs/blob - lisp/emerge.el

   1 ;;; emerge.el --- merge diffs under Emacs control
   2
   3 ;;; The author has placed this file in the public domain.
   4
   5 ;; Author: Dale R. Worley <drw@math.mit.edu>
   6 ;; Version: 5fsf
   7 ;; Keywords: unix, tools
   8
   9 ;; This software was created by Dale R. Worley and is
  10 ;; distributed free of charge.  It is placed in the public domain and
  11 ;; permission is granted to anyone to use, duplicate, modify and redistribute
  12 ;; it provided that this notice is attached.
  13
  14 ;; Dale R. Worley provides absolutely NO WARRANTY OF ANY KIND
  15 ;; with respect to this software.  The entire risk as to the quality and
  16 ;; performance of this software is with the user.  IN NO EVENT WILL DALE
  17 ;; R. WORLEY BE LIABLE TO ANYONE FOR ANY DAMAGES ARISING OUT THE
  18 ;; USE OF THIS SOFTWARE, INCLUDING, WITHOUT LIMITATION, DAMAGES RESULTING FROM
  19 ;; LOST DATA OR LOST PROFITS, OR FOR ANY SPECIAL, INCIDENTAL OR CONSEQUENTIAL
  20 ;; DAMAGES.
  21
  22 ;;; Code:
  23
  24 ;;;###autoload
  25 (defvar menu-bar-emerge-menu (make-sparse-keymap "menu-bar-emerge-map"))
  26 ;;;###autoload
  27 (fset 'menu-bar-emerge-menu (symbol-value 'menu-bar-emerge-menu))
  28
  29 ;;;###autoload
  30 (define-key menu-bar-emerge-menu [emerge-merge-directories]
  31   '("Merge Directories ..." . emerge-merge-directories))
  32 ;;;###autoload
  33 (define-key menu-bar-emerge-menu [emerge-revisions-with-ancestor]
  34   '("Revisions with Ancestor ..." . emerge-revisions-with-ancestor))
  35 ;;;###autoload
  36 (define-key menu-bar-emerge-menu [emerge-revisions]
  37   '("Revisions ..." . emerge-revisions))
  38 ;;;###autoload
  39 (define-key menu-bar-emerge-menu [emerge-files-with-ancestor]
  40   '("Files with Ancestor ..." . emerge-files-with-ancestor))
  41 ;;;###autoload
  42 (define-key menu-bar-emerge-menu [emerge-files]
  43   '("Files ..." . emerge-files))
  44 ;;;###autoload
  45 (define-key menu-bar-emerge-menu [emerge-buffers-with-ancestor]
  46   '("Buffers with Ancestor ..." . emerge-buffers-with-ancestor))
  47 ;;;###autoload
  48 (define-key menu-bar-emerge-menu [emerge-buffers]
  49   '("Buffers ..." . emerge-buffers))
  50
  51 ;;; Macros
  52
  53 (defmacro emerge-eval-in-buffer (buffer &rest forms)
  54   "Macro to switch to BUFFER, evaluate FORMS, returns to original buffer.
  55 Differs from `save-excursion' in that it doesn't save the point and mark."
  56   (` (let ((StartBuffer (current-buffer)))
  57     (unwind-protect
  58         (progn
  59           (set-buffer (, buffer))
  60           (,@ forms))
  61       (set-buffer StartBuffer)))))
  62
  63 (defmacro emerge-defvar-local (var value doc)
  64   "Defines SYMBOL as an advertised variable.
  65 Performs a defvar, then executes `make-variable-buffer-local' on
  66 the variable.  Also sets the `preserved' property, so that
  67 `kill-all-local-variables' (called by major-mode setting commands)
  68 won't destroy Emerge control variables."
  69   (` (progn
  70        (defvar (, var) (, value) (, doc))
  71        (make-variable-buffer-local '(, var))
  72        (put '(, var) 'preserved t))))
  73
  74 ;; Add entries to minor-mode-alist so that emerge modes show correctly
  75 (defvar emerge-minor-modes-list
  76   '((emerge-mode " Emerge")
  77     (emerge-fast-mode " F")
  78     (emerge-edit-mode " E")
  79     (emerge-auto-advance " A")
  80     (emerge-skip-prefers " S")))
  81 (if (not (assq 'emerge-mode minor-mode-alist))
  82     (setq minor-mode-alist (append emerge-minor-modes-list
  83                                    minor-mode-alist)))
  84
  85 ;; We need to define this function so describe-mode can describe Emerge mode.
  86 (defun emerge-mode ()
  87   "Emerge mode is used by the Emerge file-merging package.
  88 It is entered only through one of the functions:
  89         `emerge-files'
  90         `emerge-files-with-ancestor'
  91         `emerge-buffers'
  92         `emerge-buffers-with-ancestor'
  93         `emerge-files-command'
  94         `emerge-files-with-ancestor-command'
  95         `emerge-files-remote'
  96         `emerge-files-with-ancestor-remote'
  97
  98 Commands:
  99 \\{emerge-basic-keymap}
 100 Commands must be prefixed by \\<emerge-fast-keymap>\\[emerge-basic-keymap] in `edit' mode,
 101 but can be invoked directly in `fast' mode.")
 102
 103 (defvar emerge-version "5fsf"
 104   "The version of Emerge.")
 105
 106 (defun emerge-version ()
 107   "Return string describing the version of Emerge.
 108 When called interactively, displays the version."
 109   (interactive)
 110   (if (interactive-p)
 111       (message "Emerge version %s" (emerge-version))
 112     emerge-version))
 113
 114 ;;; Emerge configuration variables
 115
 116 ;; Commands that produce difference files
 117 ;; All that can be configured is the name of the programs to execute
 118 ;; (emerge-diff-program and emerge-diff3-program) and the options
 119 ;; to be provided (emerge-diff-options).  The order in which the file names
 120 ;; are given is fixed.
 121 ;; The file names are always expanded (see expand-file-name) before being
 122 ;; passed to diff, thus they need not be invoked under a shell that
 123 ;; understands `~'.
 124 ;; The code which processes the diff/diff3 output depends on all the
 125 ;; finicky details of their output, including the somewhat strange
 126 ;; way they number lines of a file.
 127 (defvar emerge-diff-program "diff"
 128   "*Name of the program which compares two files.")
 129 (defvar emerge-diff3-program "diff3"
 130   "*Name of the program which compares three files.
 131 Its arguments are the ancestor file and the two variant files.")
 132 (defvar emerge-diff-options ""
 133   "*Options to pass to `emerge-diff-program' and `emerge-diff3-program'.")
 134 (defvar emerge-match-diff-line (let ((x "\\([0-9]+\\)\\(\\|,\\([0-9]+\\)\\)"))
 135                                  (concat "^" x "\\([acd]\\)" x "$"))
 136   "*Pattern to match lines produced by diff that describe differences.
 137 This is as opposed to lines from the source files.")
 138 (defvar emerge-diff-ok-lines-regexp
 139   "^\\([0-9,]+[acd][0-9,]+$\\|[<>] \\|---\\)"
 140   "*Regexp that matches normal output lines from `emerge-diff-program'.
 141 Lines that do not match are assumed to be error messages.")
 142 (defvar emerge-diff3-ok-lines-regexp
 143   "^\\([1-3]:\\|====\\|  \\)"
 144   "*Regexp that matches normal output lines from `emerge-diff3-program'.
 145 Lines that do not match are assumed to be error messages.")
 146
 147 (defvar emerge-rcs-ci-program "ci"
 148   "*Name of the program that checks in RCS revisions.")
 149 (defvar emerge-rcs-co-program "co"
 150   "*Name of the program that checks out RCS revisions.")
 151
 152 (defvar emerge-process-local-variables nil
 153   "*Non-nil if Emerge should process local-variables lists in merge buffers.
 154 \(You can explicitly request processing the local-variables
 155 by executing `(hack-local-variables)'.)")
 156 (defvar emerge-execute-line-deletions nil
 157   "*If non-nil: `emerge-execute-line' makes no output if an input was deleted.
 158 It concludes that an input version has been deleted when an ancestor entry
 159 is present, only one A or B entry is present, and an output entry is present.
 160 If nil: In such circumstances, the A or B file that is present will be
 161 copied to the designated output file.")
 162
 163 (defvar emerge-before-flag "vvvvvvvvvvvvvvvvvvvv\n"
 164   "*Flag placed above the highlighted block of code.  Must end with newline.
 165 Must be set before Emerge is loaded, or  emerge-new-flags  must be run
 166 after setting.")
 167 (defvar emerge-after-flag "^^^^^^^^^^^^^^^^^^^^\n"
 168   "*Flag placed below the highlighted block of code.  Must end with newline.
 169 Must be set before Emerge is loaded, or  emerge-new-flags  must be run
 170 after setting.")
 171
 172 ;; Hook variables
 173
 174 (defvar emerge-startup-hook nil
 175   "*Hook to run in the merge buffer after the merge has been set up.")
 176 (defvar emerge-select-hook nil
 177   "*Hook to run after a difference has been selected.
 178 The variable `n' holds the (internal) number of the difference.")
 179 (defvar emerge-unselect-hook nil
 180   "*Hook to run after a difference has been unselected.
 181 The variable `n' holds the (internal) number of the difference.")
 182
 183 ;; Variables to control the default directories of the arguments to
 184 ;; Emerge commands.
 185
 186 (defvar emerge-default-last-directories nil
 187   "*If nil, default dir for filenames in emerge is `default-directory'.
 188 If non-nil, filenames complete in the directory of the last argument of the
 189 same type to an `emerge-files...' command.")
 190
 191 (defvar emerge-last-dir-A nil
 192   "Last directory for the first file of an `emerge-files...' command.")
 193 (defvar emerge-last-dir-B nil
 194   "Last directory for the second file of an `emerge-files...' command.")
 195 (defvar emerge-last-dir-ancestor nil
 196   "Last directory for the ancestor file of an `emerge-files...' command.")
 197 (defvar emerge-last-dir-output nil
 198   "Last directory for the output file of an `emerge-files...' command.")
 199 (defvar emerge-last-revision-A nil
 200   "Last RCS revision used for first file of an `emerge-revisions...' command.")
 201 (defvar emerge-last-revision-B nil
 202   "Last RCS revision used for second file of an `emerge-revisions...' command.")
 203 (defvar emerge-last-revision-ancestor nil
 204   "Last RCS revision used for ancestor file of an `emerge-revisions...' command.")
 205
 206 (defvar emerge-before-flag-length)
 207 (defvar emerge-before-flag-lines)
 208 (defvar emerge-before-flag-match)
 209 (defvar emerge-after-flag-length)
 210 (defvar emerge-after-flag-lines)
 211 (defvar emerge-after-flag-match)
 212 (defvar emerge-diff-buffer)
 213 (defvar emerge-diff-error-buffer)
 214 (defvar emerge-prefix-argument)
 215 (defvar emerge-file-out)
 216 (defvar emerge-exit-func)
 217 (defvar emerge-globalized-difference-list)
 218 (defvar emerge-globalized-number-of-differences)
 219
 220 ;; The flags used to mark differences in the buffers.
 221
 222 ;; These function definitions need to be up here, because they are used
 223 ;; during loading.
 224 (defun emerge-new-flags ()
 225   "Function to be called after `emerge-{before,after}-flag'.
 226 This is called after these functions are changed to compute values that
 227 depend on the flags."
 228   (setq emerge-before-flag-length (length emerge-before-flag))
 229   (setq emerge-before-flag-lines
 230         (emerge-count-matches-string emerge-before-flag "\n"))
 231   (setq emerge-before-flag-match (regexp-quote emerge-before-flag))
 232   (setq emerge-after-flag-length (length emerge-after-flag))
 233   (setq emerge-after-flag-lines
 234         (emerge-count-matches-string emerge-after-flag "\n"))
 235   (setq emerge-after-flag-match (regexp-quote emerge-after-flag)))
 236
 237 (defun emerge-count-matches-string (string regexp)
 238   "Return the number of matches in STRING for REGEXP."
 239   (let ((i 0)
 240         (count 0))
 241     (while (string-match regexp string i)
 242       (setq count (1+ count))
 243       (setq i (match-end 0)))
 244     count))
 245
 246 ;; Calculate dependent variables
 247 (emerge-new-flags)
 248
 249 (defvar emerge-min-visible-lines 3
 250   "*Number of lines that we want to show above and below the flags when we are
 251 displaying a difference.")
 252
 253 (defvar emerge-temp-file-prefix
 254   (let ((env (getenv "TMPDIR"))
 255         d)
 256     (setq d (if (and env (> (length env) 0))
 257                 env
 258               "/tmp"))
 259     (if (= (aref d (1- (length d))) ?/)
 260         (setq d (substring d 0 -1)))
 261     (concat d "/emerge"))
 262   "*Prefix to put on Emerge temporary file names.
 263 Do not start with `~/' or `~user-name/'.")
 264
 265 (defvar emerge-temp-file-mode 384       ; u=rw only
 266   "*Mode for Emerge temporary files.")
 267
 268 (defvar emerge-combine-versions-template
 269   "#ifdef NEW\n%b#else /* NEW */\n%a#endif /* NEW */\n"
 270   "*Template for `emerge-combine-versions' to combine the two versions.
 271 The template is inserted as a string, with the following interpolations:
 272         %a      the A version of the difference
 273         %b      the B version of the difference
 274         %%      the character `%'
 275 Don't forget to end the template with a newline.
 276 Note that this variable can be made local to a particular merge buffer by
 277 giving a prefix argument to `emerge-set-combine-versions-template'.")
 278
 279 ;; Build keymaps
 280
 281 (defvar emerge-basic-keymap nil
 282   "Keymap of Emerge commands.
 283 Directly available in `fast' mode;
 284 must be prefixed by \\<emerge-fast-keymap>\\[emerge-basic-keymap] in `edit' mode.")
 285
 286 (defvar emerge-fast-keymap nil
 287   "Local keymap used in Emerge `fast' mode.
 288 Makes Emerge commands directly available.")
 289
 290 (defvar emerge-options-menu
 291   (make-sparse-keymap "Options"))
 292
 293 (defvar emerge-merge-menu
 294   (make-sparse-keymap "Merge"))
 295
 296 (defvar emerge-move-menu
 297   (make-sparse-keymap "Move"))
 298
 299 (defvar emerge-command-prefix "\C-c\C-c"
 300   "*Command prefix for Emerge commands in `edit' mode.
 301 Must be set before Emerge is loaded.")
 302
 303 ;; This function sets up the fixed keymaps.  It is executed when the first
 304 ;; Emerge is done to allow the user maximum time to set up the global keymap.
 305 (defun emerge-setup-fixed-keymaps ()
 306   ;; Set up the basic keymap
 307   (setq emerge-basic-keymap (make-keymap))
 308   (suppress-keymap emerge-basic-keymap) ; this sets 0..9 to digit-argument and
 309                                         ; - to negative-argument
 310   (define-key emerge-basic-keymap "p" 'emerge-previous-difference)
 311   (define-key emerge-basic-keymap "n" 'emerge-next-difference)
 312   (define-key emerge-basic-keymap "a" 'emerge-select-A)
 313   (define-key emerge-basic-keymap "b" 'emerge-select-B)
 314   (define-key emerge-basic-keymap "j" 'emerge-jump-to-difference)
 315   (define-key emerge-basic-keymap "." 'emerge-find-difference)
 316   (define-key emerge-basic-keymap "q" 'emerge-quit)
 317   (define-key emerge-basic-keymap "\C-]" 'emerge-abort)
 318   (define-key emerge-basic-keymap "f" 'emerge-fast-mode)
 319   (define-key emerge-basic-keymap "e" 'emerge-edit-mode)
 320   (define-key emerge-basic-keymap "s" nil)
 321   (define-key emerge-basic-keymap "sa" 'emerge-auto-advance)
 322   (define-key emerge-basic-keymap "ss" 'emerge-skip-prefers)
 323   (define-key emerge-basic-keymap "l" 'emerge-recenter)
 324   (define-key emerge-basic-keymap "d" nil)
 325   (define-key emerge-basic-keymap "da" 'emerge-default-A)
 326   (define-key emerge-basic-keymap "db" 'emerge-default-B)
 327   (define-key emerge-basic-keymap "c" nil)
 328   (define-key emerge-basic-keymap "ca" 'emerge-copy-as-kill-A)
 329   (define-key emerge-basic-keymap "cb" 'emerge-copy-as-kill-B)
 330   (define-key emerge-basic-keymap "i" nil)
 331   (define-key emerge-basic-keymap "ia" 'emerge-insert-A)
 332   (define-key emerge-basic-keymap "ib" 'emerge-insert-B)
 333   (define-key emerge-basic-keymap "m" 'emerge-mark-difference)
 334   (define-key emerge-basic-keymap "v" 'emerge-scroll-up)
 335   (define-key emerge-basic-keymap "^" 'emerge-scroll-down)
 336   (define-key emerge-basic-keymap "<" 'emerge-scroll-left)
 337   (define-key emerge-basic-keymap ">" 'emerge-scroll-right)
 338   (define-key emerge-basic-keymap "|" 'emerge-scroll-reset)
 339   (define-key emerge-basic-keymap "x" nil)
 340   (define-key emerge-basic-keymap "x1" 'emerge-one-line-window)
 341   (define-key emerge-basic-keymap "xc" 'emerge-combine-versions)
 342   (define-key emerge-basic-keymap "xC" 'emerge-combine-versions-register)
 343   (define-key emerge-basic-keymap "xf" 'emerge-file-names)
 344   (define-key emerge-basic-keymap "xj" 'emerge-join-differences)
 345   (define-key emerge-basic-keymap "xl" 'emerge-line-numbers)
 346   (define-key emerge-basic-keymap "xm" 'emerge-set-merge-mode)
 347   (define-key emerge-basic-keymap "xs" 'emerge-split-difference)
 348   (define-key emerge-basic-keymap "xt" 'emerge-trim-difference)
 349   (define-key emerge-basic-keymap "xx" 'emerge-set-combine-versions-template)
 350   ;; Allow emerge-basic-keymap to be referenced indirectly
 351   (fset 'emerge-basic-keymap emerge-basic-keymap)
 352   ;; Set up the fast mode keymap
 353   (setq emerge-fast-keymap (copy-keymap emerge-basic-keymap))
 354   ;; Allow prefixed commands to work in fast mode
 355   (define-key emerge-fast-keymap emerge-command-prefix 'emerge-basic-keymap)
 356   ;; Allow emerge-fast-keymap to be referenced indirectly
 357   (fset 'emerge-fast-keymap emerge-fast-keymap)
 358   ;; Suppress write-file and save-buffer
 359   (substitute-key-definition 'write-file 'emerge-query-write-file
 360                              emerge-fast-keymap (current-global-map))
 361   (substitute-key-definition 'save-buffer 'emerge-query-save-buffer
 362                              emerge-fast-keymap (current-global-map))
 363
 364   (define-key emerge-basic-keymap [menu-bar] (make-sparse-keymap))
 365
 366   (define-key emerge-fast-keymap [menu-bar options]
 367     (cons "Options" emerge-options-menu))
 368   (define-key emerge-fast-keymap [menu-bar merge]
 369     (cons "Merge" emerge-merge-menu))
 370   (define-key emerge-fast-keymap [menu-bar move]
 371     (cons "Move" emerge-move-menu))
 372
 373   (define-key emerge-move-menu [emerge-scroll-reset]
 374     '("Scroll Reset" . emerge-scroll-reset))
 375   (define-key emerge-move-menu [emerge-scroll-right]
 376     '("Scroll Right" . emerge-scroll-right))
 377   (define-key emerge-move-menu [emerge-scroll-left]
 378     '("Scroll Left" . emerge-scroll-left))
 379   (define-key emerge-move-menu [emerge-scroll-down]
 380     '("Scroll Down" . emerge-scroll-down))
 381   (define-key emerge-move-menu [emerge-scroll-up]
 382     '("Scroll Up" . emerge-scroll-up))
 383   (define-key emerge-move-menu [emerge-recenter]
 384     '("Recenter" . emerge-recenter))
 385   (define-key emerge-move-menu [emerge-mark-difference]
 386     '("Mark Difference" . emerge-mark-difference))
 387   (define-key emerge-move-menu [emerge-jump-to-difference]
 388     '("Jump To Difference" . emerge-jump-to-difference))
 389   (define-key emerge-move-menu [emerge-find-difference]
 390     '("Find Difference" . emerge-find-difference))
 391   (define-key emerge-move-menu [emerge-previous-difference]
 392     '("Previous Difference" . emerge-previous-difference))
 393   (define-key emerge-move-menu [emerge-next-difference]
 394     '("Next Difference" . emerge-next-difference))
 395
 396
 397   (define-key emerge-options-menu [emerge-one-line-window]
 398     '("One Line Window" . emerge-one-line-window))
 399   (define-key emerge-options-menu [emerge-set-merge-mode]
 400     '("Set Merge Mode" . emerge-set-merge-mode))
 401   (define-key emerge-options-menu [emerge-set-combine-template]
 402     '("Set Combine Template..." . emerge-set-combine-template))
 403   (define-key emerge-options-menu [emerge-default-B]
 404     '("Default B" . emerge-default-B))
 405   (define-key emerge-options-menu [emerge-default-A]
 406     '("Default A" . emerge-default-A))
 407   (define-key emerge-options-menu [emerge-skip-prefers]
 408     '("Skip Prefers" . emerge-skip-prefers))
 409   (define-key emerge-options-menu [emerge-auto-advance]
 410     '("Auto Advance" . emerge-auto-advance))
 411   (define-key emerge-options-menu [emerge-edit-mode]
 412     '("Edit Mode" . emerge-edit-mode))
 413   (define-key emerge-options-menu [emerge-fast-mode]
 414     '("Fast Mode" . emerge-fast-mode))
 415
 416   (define-key emerge-merge-menu [emerge-abort] '("Abort" . emerge-abort))
 417   (define-key emerge-merge-menu [emerge-quit] '("Quit" . emerge-quit))
 418   (define-key emerge-merge-menu [emerge-split-difference]
 419     '("Split Difference" . emerge-split-difference))
 420   (define-key emerge-merge-menu [emerge-join-differences]
 421     '("Join Differences" . emerge-join-differences))
 422   (define-key emerge-merge-menu [emerge-trim-difference]
 423     '("Trim Difference" . emerge-trim-difference))
 424   (define-key emerge-merge-menu [emerge-combine-versions]
 425     '("Combine Versions" . emerge-combine-versions))
 426   (define-key emerge-merge-menu [emerge-copy-as-kill-B]
 427     '("Copy B as Kill" . emerge-copy-as-kill-B))
 428   (define-key emerge-merge-menu [emerge-copy-as-kill-A]
 429     '("Copy A as Kill" . emerge-copy-as-kill-A))
 430   (define-key emerge-merge-menu [emerge-insert-B]
 431     '("Insert B" . emerge-insert-B))
 432   (define-key emerge-merge-menu [emerge-insert-A]
 433     '("Insert A" . emerge-insert-A))
 434   (define-key emerge-merge-menu [emerge-select-B]
 435     '("Select B" . emerge-select-B))
 436   (define-key emerge-merge-menu [emerge-select-A]
 437     '("Select A" . emerge-select-A)))
 438
 439
 440 ;; Variables which control each merge.  They are local to the merge buffer.
 441
 442 ;; Mode variables
 443 (emerge-defvar-local emerge-mode nil
 444   "Indicator for emerge-mode.")
 445 (emerge-defvar-local emerge-fast-mode nil
 446   "Indicator for emerge-mode fast submode.")
 447 (emerge-defvar-local emerge-edit-mode nil
 448   "Indicator for emerge-mode edit submode.")
 449 (emerge-defvar-local emerge-A-buffer nil
 450   "The buffer in which the A variant is stored.")
 451 (emerge-defvar-local emerge-B-buffer nil
 452   "The buffer in which the B variant is stored.")
 453 (emerge-defvar-local emerge-merge-buffer nil
 454   "The buffer in which the merged file is manipulated.")
 455 (emerge-defvar-local emerge-ancestor-buffer nil
 456   "The buffer in which the ancestor variant is stored,
 457 or nil if there is none.")
 458
 459 (defconst emerge-saved-variables
 460   '((buffer-modified-p set-buffer-modified-p)
 461     buffer-read-only
 462     buffer-auto-save-file-name)
 463   "Variables and properties of a buffer which are saved, modified and restored
 464 during a merge.")
 465 (defconst emerge-merging-values '(nil t nil)
 466   "Values to be assigned to emerge-saved-variables during a merge.")
 467
 468 (emerge-defvar-local emerge-A-buffer-values nil
 469   "Remembers emerge-saved-variables for emerge-A-buffer.")
 470 (emerge-defvar-local emerge-B-buffer-values nil
 471   "Remembers emerge-saved-variables for emerge-B-buffer.")
 472
 473 (emerge-defvar-local emerge-difference-list nil
 474   "Vector of differences between the variants, and markers in the buffers to
 475 show where they are.  Each difference is represented by a vector of seven
 476 elements.  The first two are markers to the beginning and end of the difference
 477 section in the A buffer, the second two are markers for the B buffer, the third
 478 two are markers for the merge buffer, and the last element is the \"state\" of
 479 that difference in the merge buffer.
 480   A section of a buffer is described by two markers, one to the beginning of
 481 the first line of the section, and one to the beginning of the first line
 482 after the section.  (If the section is empty, both markers point to the same
 483 point.)  If the section is part of the selected difference, then the markers
 484 are moved into the flags, so the user can edit the section without disturbing
 485 the markers.
 486   The \"states\" are:
 487         A               the merge buffer currently contains the A variant
 488         B               the merge buffer currently contains the B variant
 489         default-A       the merge buffer contains the A variant by default,
 490                         but this difference hasn't been selected yet, so
 491                         change-default commands can alter it
 492         default-B       the merge buffer contains the B variant by default,
 493                         but this difference hasn't been selected yet, so
 494                         change-default commands can alter it
 495         prefer-A        in a three-file merge, the A variant is the preferred
 496                         choice
 497         prefer-B        in a three-file merge, the B variant is the preferred
 498                         choice")
 499 (emerge-defvar-local emerge-current-difference -1
 500   "The difference that is currently selected.")
 501 (emerge-defvar-local emerge-number-of-differences nil
 502   "Number of differences found.")
 503 (emerge-defvar-local emerge-edit-keymap nil
 504   "The local keymap for the merge buffer, with the emerge commands defined in
 505 it.  Used to save the local keymap during fast mode, when the local keymap is
 506 replaced by emerge-fast-keymap.")
 507 (emerge-defvar-local emerge-old-keymap nil
 508   "The original local keymap for the merge buffer.")
 509 (emerge-defvar-local emerge-auto-advance nil
 510   "*If non-nil, emerge-select-A and emerge-select-B automatically advance to
 511 the next difference.")
 512 (emerge-defvar-local emerge-skip-prefers nil
 513   "*If non-nil, differences for which there is a preference are automatically
 514 skipped.")
 515 (emerge-defvar-local emerge-quit-hook nil
 516   "Hooks to run in the merge buffer after the merge has been finished.
 517 `emerge-prefix-argument' will hold the prefix argument of the `emerge-quit'
 518 command.
 519 This is *not* a user option, since Emerge uses it for its own processing.")
 520 (emerge-defvar-local emerge-output-description nil
 521   "Describes output destination of emerge, for `emerge-file-names'.")
 522
 523 ;;; Setup functions for two-file mode.
 524
 525 (defun emerge-files-internal (file-A file-B &optional startup-hooks quit-hooks
 526                                      output-file)
 527   (if (not (file-readable-p file-A))
 528       (error "File `%s' does not exist or is not readable" file-A))
 529   (if (not (file-readable-p file-B))
 530       (error "File `%s' does not exist or is not readable" file-B))
 531   (let ((buffer-A (find-file-noselect file-A))
 532         (buffer-B (find-file-noselect file-B)))
 533     ;; Record the directories of the files
 534     (setq emerge-last-dir-A (file-name-directory file-A))
 535     (setq emerge-last-dir-B (file-name-directory file-B))
 536     (if output-file
 537         (setq emerge-last-dir-output (file-name-directory output-file)))
 538     ;; Make sure the entire files are seen, and they reflect what is on disk
 539     (emerge-eval-in-buffer
 540      buffer-A
 541      (widen)
 542      (let ((temp (file-local-copy file-A)))
 543        (if temp
 544            (setq file-A temp
 545                  startup-hooks
 546                  (cons (` (lambda () (delete-file (, file-A))))
 547                        startup-hooks))
 548          ;; Verify that the file matches the buffer
 549          (emerge-verify-file-buffer))))
 550     (emerge-eval-in-buffer
 551      buffer-B
 552      (widen)
 553      (let ((temp (file-local-copy file-B)))
 554        (if temp
 555            (setq file-B temp
 556                  startup-hooks
 557                  (cons (` (lambda () (delete-file (, file-B))))
 558                        startup-hooks))
 559          ;; Verify that the file matches the buffer
 560          (emerge-verify-file-buffer))))
 561     (emerge-setup buffer-A file-A buffer-B file-B startup-hooks quit-hooks
 562                   output-file)))
 563
 564 ;; Start up Emerge on two files
 565 (defun emerge-setup (buffer-A file-A buffer-B file-B startup-hooks quit-hooks
 566                               output-file)
 567   (setq file-A (expand-file-name file-A))
 568   (setq file-B (expand-file-name file-B))
 569   (setq output-file (and output-file (expand-file-name output-file)))
 570   (let* ((merge-buffer-name (emerge-unique-buffer-name "*merge" "*"))
 571          ;; create the merge buffer from buffer A, so it inherits buffer A's
 572          ;; default directory, etc.
 573          (merge-buffer (emerge-eval-in-buffer
 574                         buffer-A
 575                         (get-buffer-create merge-buffer-name))))
 576     (emerge-eval-in-buffer
 577      merge-buffer
 578      (emerge-copy-modes buffer-A)
 579      (setq buffer-read-only nil)
 580      (auto-save-mode 1)
 581      (setq emerge-mode t)
 582      (setq emerge-A-buffer buffer-A)
 583      (setq emerge-B-buffer buffer-B)
 584      (setq emerge-ancestor-buffer nil)
 585      (setq emerge-merge-buffer merge-buffer)
 586      (setq emerge-output-description
 587            (if output-file
 588                (concat "Output to file: " output-file)
 589              (concat "Output to buffer: " (buffer-name merge-buffer))))
 590      (insert-buffer emerge-A-buffer)
 591      (emerge-set-keys)
 592      (setq emerge-difference-list (emerge-make-diff-list file-A file-B))
 593      (setq emerge-number-of-differences (length emerge-difference-list))
 594      (setq emerge-current-difference -1)
 595      (setq emerge-quit-hook quit-hooks)
 596      (emerge-remember-buffer-characteristics)
 597      (emerge-handle-local-variables))
 598     (emerge-setup-windows buffer-A buffer-B merge-buffer t)
 599     (emerge-eval-in-buffer merge-buffer
 600                            (run-hooks 'startup-hooks 'emerge-startup-hook)
 601                            (setq buffer-read-only t))))
 602
 603 ;; Generate the Emerge difference list between two files
 604 (defun emerge-make-diff-list (file-A file-B)
 605   (setq emerge-diff-buffer (get-buffer-create "*emerge-diff*"))
 606   (emerge-eval-in-buffer
 607    emerge-diff-buffer
 608    (erase-buffer)
 609    (shell-command
 610     (format "%s %s %s %s"
 611             emerge-diff-program emerge-diff-options
 612             (emerge-protect-metachars file-A)
 613             (emerge-protect-metachars file-B))
 614     t))
 615   (emerge-prepare-error-list emerge-diff-ok-lines-regexp)
 616   (emerge-convert-diffs-to-markers
 617    emerge-A-buffer emerge-B-buffer emerge-merge-buffer
 618    (emerge-extract-diffs emerge-diff-buffer)))
 619
 620 (defun emerge-extract-diffs (diff-buffer)
 621   (let (list)
 622     (emerge-eval-in-buffer
 623      diff-buffer
 624      (goto-char (point-min))
 625      (while (re-search-forward emerge-match-diff-line nil t)
 626        (let* ((a-begin (string-to-int (buffer-substring (match-beginning 1)
 627                                                         (match-end 1))))
 628               (a-end  (let ((b (match-beginning 3))
 629                             (e (match-end 3)))
 630                         (if b
 631                             (string-to-int (buffer-substring b e))
 632                           a-begin)))
 633               (diff-type (buffer-substring (match-beginning 4) (match-end 4)))
 634               (b-begin (string-to-int (buffer-substring (match-beginning 5)
 635                                                         (match-end 5))))
 636               (b-end (let ((b (match-beginning 7))
 637                            (e (match-end 7)))
 638                        (if b
 639                            (string-to-int (buffer-substring b e))
 640                          b-begin))))
 641          ;; fix the beginning and end numbers, because diff is somewhat
 642          ;; strange about how it numbers lines
 643          (if (string-equal diff-type "a")
 644              (progn
 645                (setq b-end (1+ b-end))
 646                (setq a-begin (1+ a-begin))
 647                (setq a-end a-begin))
 648            (if (string-equal diff-type "d")
 649                (progn
 650                  (setq a-end (1+ a-end))
 651                  (setq b-begin (1+ b-begin))
 652                  (setq b-end b-begin))
 653              ;; (string-equal diff-type "c")
 654              (progn
 655                (setq a-end (1+ a-end))
 656                (setq b-end (1+ b-end)))))
 657          (setq list (cons (vector a-begin a-end
 658                                   b-begin b-end
 659                                   'default-A)
 660                           list)))))
 661     (nreverse list)))
 662
 663 ;; Set up buffer of diff/diff3 error messages.
 664 (defun emerge-prepare-error-list (ok-regexp)
 665   (setq emerge-diff-error-buffer (get-buffer-create "*emerge-diff-errors*"))
 666   (emerge-eval-in-buffer
 667    emerge-diff-error-buffer
 668    (erase-buffer)
 669    (insert-buffer emerge-diff-buffer)
 670    (delete-matching-lines ok-regexp)))
 671
 672 ;;; Top-level and setup functions for three-file mode.
 673
 674 (defun emerge-files-with-ancestor-internal (file-A file-B file-ancestor
 675                                             &optional startup-hooks quit-hooks
 676                                             output-file)
 677   (if (not (file-readable-p file-A))
 678       (error "File `%s' does not exist or is not readable" file-A))
 679   (if (not (file-readable-p file-B))
 680       (error "File `%s' does not exist or is not readable" file-B))
 681   (if (not (file-readable-p file-ancestor))
 682       (error "File `%s' does not exist or is not readable" file-ancestor))
 683   (let ((buffer-A (find-file-noselect file-A))
 684         (buffer-B (find-file-noselect file-B))
 685         (buffer-ancestor (find-file-noselect file-ancestor)))
 686     ;; Record the directories of the files
 687     (setq emerge-last-dir-A (file-name-directory file-A))
 688     (setq emerge-last-dir-B (file-name-directory file-B))
 689     (setq emerge-last-dir-ancestor (file-name-directory file-ancestor))
 690     (if output-file
 691         (setq emerge-last-dir-output (file-name-directory output-file)))
 692     ;; Make sure the entire files are seen, and they reflect what is on disk
 693     (emerge-eval-in-buffer
 694      buffer-A
 695      (widen)
 696      (let ((temp (file-local-copy file-A)))
 697        (if temp
 698            (setq file-A temp
 699                  startup-hooks
 700                  (cons (` (lambda () (delete-file (, file-A))))
 701                        startup-hooks))
 702          ;; Verify that the file matches the buffer
 703          (emerge-verify-file-buffer))))
 704     (emerge-eval-in-buffer
 705      buffer-B
 706      (widen)
 707      (let ((temp (file-local-copy file-B)))
 708        (if temp
 709            (setq file-B temp
 710                  startup-hooks
 711                  (cons (` (lambda () (delete-file (, file-B))))
 712                        startup-hooks))
 713          ;; Verify that the file matches the buffer
 714          (emerge-verify-file-buffer))))
 715     (emerge-eval-in-buffer
 716      buffer-ancestor
 717      (widen)
 718      (let ((temp (file-local-copy file-ancestor)))
 719        (if temp
 720            (setq file-ancestor temp
 721                  startup-hooks
 722                  (cons (` (lambda () (delete-file (, file-ancestor))))
 723                        startup-hooks))
 724          ;; Verify that the file matches the buffer
 725          (emerge-verify-file-buffer))))
 726     (emerge-setup-with-ancestor buffer-A file-A buffer-B file-B
 727                                 buffer-ancestor file-ancestor
 728                                 startup-hooks quit-hooks output-file)))
 729
 730 ;; Start up Emerge on two files with an ancestor
 731 (defun emerge-setup-with-ancestor (buffer-A file-A buffer-B file-B
 732                                             buffer-ancestor file-ancestor
 733                                             &optional startup-hooks quit-hooks
 734                                             output-file)
 735   (setq file-A (expand-file-name file-A))
 736   (setq file-B (expand-file-name file-B))
 737   (setq file-ancestor (expand-file-name file-ancestor))
 738   (setq output-file (and output-file (expand-file-name output-file)))
 739   (let* ((merge-buffer-name (emerge-unique-buffer-name "*merge" "*"))
 740          ;; create the merge buffer from buffer A, so it inherits buffer A's
 741          ;; default directory, etc.
 742          (merge-buffer (emerge-eval-in-buffer
 743                         buffer-A
 744                         (get-buffer-create merge-buffer-name))))
 745     (emerge-eval-in-buffer
 746      merge-buffer
 747      (emerge-copy-modes buffer-A)
 748      (setq buffer-read-only nil)
 749      (auto-save-mode 1)
 750      (setq emerge-mode t)
 751      (setq emerge-A-buffer buffer-A)
 752      (setq emerge-B-buffer buffer-B)
 753      (setq emerge-ancestor-buffer buffer-ancestor)
 754      (setq emerge-merge-buffer merge-buffer)
 755      (setq emerge-output-description
 756            (if output-file
 757                (concat "Output to file: " output-file)
 758              (concat "Output to buffer: " (buffer-name merge-buffer))))
 759      (insert-buffer emerge-A-buffer)
 760      (emerge-set-keys)
 761      (setq emerge-difference-list
 762            (emerge-make-diff3-list file-A file-B file-ancestor))
 763      (setq emerge-number-of-differences (length emerge-difference-list))
 764      (setq emerge-current-difference -1)
 765      (setq emerge-quit-hook quit-hooks)
 766      (emerge-remember-buffer-characteristics)
 767      (emerge-select-prefer-Bs)
 768      (emerge-handle-local-variables))
 769     (emerge-setup-windows buffer-A buffer-B merge-buffer t)
 770     (emerge-eval-in-buffer merge-buffer
 771                            (run-hooks 'startup-hooks 'emerge-startup-hook)
 772                            (setq buffer-read-only t))))
 773
 774 ;; Generate the Emerge difference list between two files with an ancestor
 775 (defun emerge-make-diff3-list (file-A file-B file-ancestor)
 776   (setq emerge-diff-buffer (get-buffer-create "*emerge-diff*"))
 777   (emerge-eval-in-buffer
 778    emerge-diff-buffer
 779    (erase-buffer)
 780    (shell-command
 781     (format "%s %s %s %s %s"
 782             emerge-diff3-program emerge-diff-options
 783             (emerge-protect-metachars file-A)
 784             (emerge-protect-metachars file-ancestor)
 785             (emerge-protect-metachars file-B))
 786     t))
 787   (emerge-prepare-error-list emerge-diff3-ok-lines-regexp)
 788   (emerge-convert-diffs-to-markers
 789    emerge-A-buffer emerge-B-buffer emerge-merge-buffer
 790    (emerge-extract-diffs3 emerge-diff-buffer)))
 791
 792 (defun emerge-extract-diffs3 (diff-buffer)
 793   (let (list)
 794     (emerge-eval-in-buffer
 795      diff-buffer
 796      (while (re-search-forward "^====\\(.?\\)$" nil t)
 797        ;; leave point after matched line
 798        (beginning-of-line 2)
 799        (let ((agreement (buffer-substring (match-beginning 1) (match-end 1))))
 800          ;; if the A and B files are the same, ignore the difference
 801          (if (not (string-equal agreement "2"))
 802              (setq list
 803                    (cons
 804                     (let (group-1 group-3 pos)
 805                       (setq pos (point))
 806                       (setq group-1 (emerge-get-diff3-group "1"))
 807                       (goto-char pos)
 808                       (setq group-3 (emerge-get-diff3-group "3"))
 809                       (vector (car group-1) (car (cdr group-1))
 810                               (car group-3) (car (cdr group-3))
 811                               (cond ((string-equal agreement "1") 'prefer-A)
 812                                     ((string-equal agreement "3") 'prefer-B)
 813                                     (t 'default-A))))
 814                     list))))))
 815     (nreverse list)))
 816
 817 (defun emerge-get-diff3-group (file)
 818   ;; This save-excursion allows emerge-get-diff3-group to be called for the
 819   ;; various groups of lines (1, 2, 3) in any order, and for the lines to
 820   ;; appear in any order.  The reason this is necessary is that Gnu diff3
 821   ;; can produce the groups in the order 1, 2, 3 or 1, 3, 2.
 822   (save-excursion
 823     (re-search-forward
 824      (concat "^" file ":\\([0-9]+\\)\\(,\\([0-9]+\\)\\)?\\([ac]\\)$"))
 825     (beginning-of-line 2)
 826     ;; treatment depends on whether it is an "a" group or a "c" group
 827     (if (string-equal (buffer-substring (match-beginning 4) (match-end 4)) "c")
 828         ;; it is a "c" group
 829         (if (match-beginning 2)
 830             ;; it has two numbers
 831             (list (string-to-int
 832                    (buffer-substring (match-beginning 1) (match-end 1)))
 833                   (1+ (string-to-int
 834                        (buffer-substring (match-beginning 3) (match-end 3)))))
 835           ;; it has one number
 836           (let ((x (string-to-int
 837                     (buffer-substring (match-beginning 1) (match-end 1)))))
 838             (list x (1+ x))))
 839       ;; it is an "a" group
 840       (let ((x (1+ (string-to-int
 841                     (buffer-substring (match-beginning 1) (match-end 1))))))
 842         (list x x)))))
 843
 844 ;;; Functions to start Emerge on files
 845
 846 ;;;###autoload
 847 (defun emerge-files (arg file-A file-B file-out &optional startup-hooks
 848                      quit-hooks)
 849   "Run Emerge on two files."
 850   (interactive
 851    (let (f)
 852      (list current-prefix-arg
 853            (setq f (emerge-read-file-name "File A to merge" emerge-last-dir-A
 854                                           nil nil))
 855            (emerge-read-file-name "File B to merge" emerge-last-dir-B nil f)
 856            (and current-prefix-arg
 857                 (emerge-read-file-name "Output file" emerge-last-dir-output
 858                                        f f)))))
 859   (emerge-files-internal
 860    file-A file-B startup-hooks
 861    (if file-out
 862        (cons (` (lambda () (emerge-files-exit (, file-out))))
 863              quit-hooks)
 864      quit-hooks)
 865    file-out))
 866
 867 ;;;###autoload
 868 (defun emerge-files-with-ancestor (arg file-A file-B file-ancestor file-out
 869                                    &optional startup-hooks quit-hooks)
 870   "Run Emerge on two files, giving another file as the ancestor."
 871   (interactive
 872    (let (f)
 873      (list current-prefix-arg
 874            (setq f (emerge-read-file-name "File A to merge" emerge-last-dir-A
 875                                           nil nil))
 876            (emerge-read-file-name "File B to merge" emerge-last-dir-B nil f)
 877            (emerge-read-file-name "Ancestor file" emerge-last-dir-ancestor
 878                                   nil f)
 879            (and current-prefix-arg
 880                 (emerge-read-file-name "Output file" emerge-last-dir-output
 881                                        f f)))))
 882   (emerge-files-with-ancestor-internal
 883    file-A file-B file-ancestor startup-hooks
 884    (if file-out
 885        (cons (` (lambda () (emerge-files-exit (, file-out))))
 886              quit-hooks)
 887      quit-hooks)
 888    file-out))
 889
 890 ;; Write the merge buffer out in place of the file the A buffer is visiting.
 891 (defun emerge-files-exit (file-out)
 892   ;; if merge was successful was given, save to disk
 893   (if (not emerge-prefix-argument)
 894       (emerge-write-and-delete file-out)))
 895
 896 ;;; Functions to start Emerge on buffers
 897
 898 ;;;###autoload
 899 (defun emerge-buffers (buffer-A buffer-B &optional startup-hooks quit-hooks)
 900   "Run Emerge on two buffers."
 901   (interactive "bBuffer A to merge: \nbBuffer B to merge: ")
 902   (let ((emerge-file-A (emerge-make-temp-file "A"))
 903         (emerge-file-B (emerge-make-temp-file "B")))
 904     (emerge-eval-in-buffer
 905      buffer-A
 906      (write-region (point-min) (point-max) emerge-file-A nil 'no-message))
 907     (emerge-eval-in-buffer
 908      buffer-B
 909      (write-region (point-min) (point-max) emerge-file-B nil 'no-message))
 910     (emerge-setup (get-buffer buffer-A) emerge-file-A
 911                   (get-buffer buffer-B) emerge-file-B
 912                   (cons (` (lambda ()
 913                              (delete-file (, emerge-file-A))
 914                              (delete-file (, emerge-file-B))))
 915                         startup-hooks)
 916                   quit-hooks
 917                   nil)))
 918
 919 ;;;###autoload
 920 (defun emerge-buffers-with-ancestor (buffer-A buffer-B buffer-ancestor
 921                                               &optional startup-hooks
 922                                               quit-hooks)
 923   "Run Emerge on two buffers, giving another buffer as the ancestor."
 924   (interactive
 925    "bBuffer A to merge: \nbBuffer B to merge: \nbAncestor buffer: ")
 926   (let ((emerge-file-A (emerge-make-temp-file "A"))
 927         (emerge-file-B (emerge-make-temp-file "B"))
 928         (emerge-file-ancestor (emerge-make-temp-file "anc")))
 929     (emerge-eval-in-buffer
 930      buffer-A
 931      (write-region (point-min) (point-max) emerge-file-A nil 'no-message))
 932     (emerge-eval-in-buffer
 933      buffer-B
 934      (write-region (point-min) (point-max) emerge-file-B nil 'no-message))
 935     (emerge-eval-in-buffer
 936      buffer-ancestor
 937      (write-region (point-min) (point-max) emerge-file-ancestor nil
 938                    'no-message))
 939     (emerge-setup-with-ancestor (get-buffer buffer-A) emerge-file-A
 940                                 (get-buffer buffer-B) emerge-file-B
 941                                 (get-buffer buffer-ancestor)
 942                                 emerge-file-ancestor
 943                                 (cons (` (lambda ()
 944                                            (delete-file (, emerge-file-A))
 945                                            (delete-file (, emerge-file-B))
 946                                            (delete-file
 947                                             (, emerge-file-ancestor))))
 948                                       startup-hooks)
 949                                 quit-hooks
 950                                 nil)))
 951
 952 ;;; Functions to start Emerge from the command line
 953
 954 ;;;###autoload
 955 (defun emerge-files-command ()
 956   (let ((file-a (nth 0 command-line-args-left))
 957         (file-b (nth 1 command-line-args-left))
 958         (file-out (nth 2 command-line-args-left)))
 959     (setq command-line-args-left (nthcdr 3 command-line-args-left))
 960     (emerge-files-internal
 961      file-a file-b nil
 962      (list (` (lambda () (emerge-command-exit (, file-out))))))))
 963
 964 ;;;###autoload
 965 (defun emerge-files-with-ancestor-command ()
 966   (let (file-a file-b file-anc file-out)
 967     ;; check for a -a flag, for filemerge compatibility
 968     (if (string= (car command-line-args-left) "-a")
 969         ;; arguments are "-a ancestor file-a file-b file-out"
 970         (progn
 971           (setq file-a (nth 2 command-line-args-left))
 972           (setq file-b (nth 3 command-line-args-left))
 973           (setq file-anc (nth 1 command-line-args-left))
 974           (setq file-out (nth 4 command-line-args-left))
 975           (setq command-line-args-left (nthcdr 5 command-line-args-left)))
 976       ;; arguments are "file-a file-b ancestor file-out"
 977       (setq file-a (nth 0 command-line-args-left))
 978       (setq file-b (nth 1 command-line-args-left))
 979       (setq file-anc (nth 2 command-line-args-left))
 980       (setq file-out (nth 3 command-line-args-left))
 981       (setq command-line-args-left (nthcdr 4 command-line-args-left)))
 982     (emerge-files-with-ancestor-internal
 983      file-a file-b file-anc nil
 984      (list (` (lambda () (emerge-command-exit (, file-out))))))))
 985
 986 (defun emerge-command-exit (file-out)
 987   (emerge-write-and-delete file-out)
 988   (kill-emacs (if emerge-prefix-argument 1 0)))
 989
 990 ;;; Functions to start Emerge via remote request
 991
 992 ;;;###autoload
 993 (defun emerge-files-remote (file-a file-b file-out)
 994   (setq emerge-file-out file-out)
 995   (emerge-files-internal
 996    file-a file-b nil
 997    (list (` (lambda () (emerge-remote-exit (, file-out) '(, emerge-exit-func)))))
 998    file-out)
 999   (throw 'client-wait nil))
1000
1001 ;;;###autoload
1002 (defun emerge-files-with-ancestor-remote (file-a file-b file-anc file-out)
1003   (setq emerge-file-out file-out)
1004   (emerge-files-with-ancestor-internal
1005    file-a file-b file-anc nil
1006    (list (` (lambda () (emerge-remote-exit (, file-out) '(, emerge-exit-func)))))
1007    file-out)
1008   (throw 'client-wait nil))
1009
1010 (defun emerge-remote-exit (file-out emerge-exit-func)
1011   (emerge-write-and-delete file-out)
1012   (kill-buffer emerge-merge-buffer)
1013   (funcall emerge-exit-func (if emerge-prefix-argument 1 0)))
1014
1015 ;;; Functions to start Emerge on RCS versions
1016
1017 ;;;###autoload
1018 (defun emerge-revisions (arg file revision-A revision-B
1019                          &optional startup-hooks quit-hooks)
1020   "Emerge two RCS revisions of a file."
1021   (interactive
1022    (list current-prefix-arg
1023          (read-file-name "File to merge: " nil nil 'confirm)
1024          (read-string "Revision A to merge: " emerge-last-revision-A)
1025          (read-string "Revision B to merge: " emerge-last-revision-B)))
1026   (setq emerge-last-revision-A revision-A
1027         emerge-last-revision-B revision-B)
1028   (emerge-revisions-internal
1029    file revision-A revision-B startup-hooks
1030    (if arg
1031        (cons (` (lambda ()
1032                   (shell-command
1033                    (, (format "%s %s" emerge-rcs-ci-program file)))))
1034              quit-hooks)
1035      quit-hooks)))
1036
1037 ;;;###autoload
1038 (defun emerge-revisions-with-ancestor (arg file revision-A
1039                                            revision-B ancestor
1040                                            &optional
1041                                            startup-hooks quit-hooks)
1042   "Emerge two RCS revisions of a file, with another revision as ancestor."
1043   (interactive
1044    (list current-prefix-arg
1045          (read-file-name "File to merge: " nil nil 'confirm)
1046          (read-string "Revision A to merge: " emerge-last-revision-A)
1047          (read-string "Revision B to merge: " emerge-last-revision-B)
1048          (read-string "Ancestor: " emerge-last-revision-ancestor)))
1049   (setq emerge-last-revision-A revision-A
1050         emerge-last-revision-B revision-B
1051         emerge-last-revision-ancestor ancestor)
1052   (emerge-revision-with-ancestor-internal
1053    file revision-A revision-B ancestor startup-hooks
1054    (if arg
1055        (let ((cmd ))
1056          (cons (` (lambda ()
1057                     (shell-command
1058                      (, (format "%s %s" emerge-rcs-ci-program file)))))
1059                quit-hooks))
1060      quit-hooks)))
1061
1062 (defun emerge-revisions-internal (file revision-A revision-B &optional
1063                                       startup-hooks quit-hooks output-file)
1064   (let ((buffer-A (get-buffer-create (format "%s,%s" file revision-A)))
1065         (buffer-B (get-buffer-create (format "%s,%s" file revision-B)))
1066         (emerge-file-A (emerge-make-temp-file "A"))
1067         (emerge-file-B (emerge-make-temp-file "B")))
1068     ;; Get the revisions into buffers
1069     (emerge-eval-in-buffer
1070      buffer-A
1071      (erase-buffer)
1072      (shell-command
1073       (format "%s -q -p%s %s" emerge-rcs-co-program revision-A file)
1074       t)
1075      (write-region (point-min) (point-max) emerge-file-A nil 'no-message)
1076      (set-buffer-modified-p nil))
1077     (emerge-eval-in-buffer
1078      buffer-B
1079      (erase-buffer)
1080      (shell-command
1081       (format "%s -q -p%s %s" emerge-rcs-co-program revision-B file)
1082       t)
1083      (write-region (point-min) (point-max) emerge-file-B nil 'no-message)
1084      (set-buffer-modified-p nil))
1085     ;; Do the merge
1086     (emerge-setup buffer-A emerge-file-A
1087                   buffer-B emerge-file-B
1088                   (cons (` (lambda ()
1089                              (delete-file (, emerge-file-A))
1090                              (delete-file (, emerge-file-B))))
1091                         startup-hooks)
1092                   (cons (` (lambda () (emerge-files-exit (, file))))
1093                         quit-hooks)
1094                   nil)))
1095
1096 (defun emerge-revision-with-ancestor-internal (file revision-A revision-B
1097                                                     ancestor
1098                                                     &optional startup-hooks
1099                                                     quit-hooks output-file)
1100   (let ((buffer-A (get-buffer-create (format "%s,%s" file revision-A)))
1101         (buffer-B (get-buffer-create (format "%s,%s" file revision-B)))
1102         (buffer-ancestor (get-buffer-create (format "%s,%s" file ancestor)))
1103         (emerge-file-A (emerge-make-temp-file "A"))
1104         (emerge-file-B (emerge-make-temp-file "B"))
1105         (emerge-ancestor (emerge-make-temp-file "ancestor")))
1106     ;; Get the revisions into buffers
1107     (emerge-eval-in-buffer
1108      buffer-A
1109      (erase-buffer)
1110      (shell-command
1111       (format "%s -q -p%s %s" emerge-rcs-co-program
1112               revision-A file)
1113       t)
1114      (write-region (point-min) (point-max) emerge-file-A nil 'no-message)
1115      (set-buffer-modified-p nil))
1116     (emerge-eval-in-buffer
1117      buffer-B
1118      (erase-buffer)
1119      (shell-command
1120       (format "%s -q -p%s %s" emerge-rcs-co-program revision-B file)
1121       t)
1122      (write-region (point-min) (point-max) emerge-file-B nil 'no-message)
1123      (set-buffer-modified-p nil))
1124     (emerge-eval-in-buffer
1125      buffer-ancestor
1126      (erase-buffer)
1127      (shell-command
1128       (format "%s -q -p%s %s" emerge-rcs-co-program ancestor file)
1129       t)
1130      (write-region (point-min) (point-max) emerge-ancestor nil 'no-message)
1131      (set-buffer-modified-p nil))
1132     ;; Do the merge
1133     (emerge-setup-with-ancestor
1134      buffer-A emerge-file-A buffer-B emerge-file-B
1135      buffer-ancestor emerge-ancestor
1136      (cons (` (lambda ()
1137                 (delete-file (, emerge-file-A))
1138                 (delete-file (, emerge-file-B))
1139                 (delete-file (, emerge-ancestor))))
1140            startup-hooks)
1141      (cons (` (lambda () (emerge-files-exit (, file))))
1142            quit-hooks)
1143      output-file)))
1144
1145 ;;; Function to start Emerge based on a line in a file
1146
1147 (defun emerge-execute-line ()
1148   "Run Emerge using files named in current text line.
1149 Looks in that line for whitespace-separated entries of these forms:
1150         a=file1
1151         b=file2
1152         ancestor=file3
1153         output=file4
1154 to specify the files to use in Emerge.
1155
1156 In addition, if only one of `a=file' or `b=file' is present, and `output=file'
1157 is present:
1158 If `emerge-execute-line-deletions' is non-nil and `ancestor=file' is present,
1159 it is assumed that the file in question has been deleted, and it is
1160 not copied to the output file.
1161 Otherwise, the A or B file present is copied to the output file."
1162   (interactive)
1163   (let (file-A file-B file-ancestor file-out
1164                (case-fold-search t))
1165     ;; Stop if at end of buffer (even though we might be in a line, if
1166     ;; the line does not end with newline)
1167     (if (eobp)
1168         (error "At end of buffer"))
1169     ;; Go to the beginning of the line
1170     (beginning-of-line)
1171     ;; Skip any initial whitespace
1172     (if (looking-at "[ \t]*")
1173         (goto-char (match-end 0)))
1174     ;; Process the entire line
1175     (while (not (eolp))
1176       ;; Get the next entry
1177       (if (looking-at "\\([a-z]+\\)=\\([^ \t\n]+\\)[ \t]*")
1178           ;; Break apart the tab (before =) and the filename (after =)
1179           (let ((tag (downcase
1180                       (buffer-substring (match-beginning 1) (match-end 1))))
1181                 (file (buffer-substring (match-beginning 2) (match-end 2))))
1182             ;; Move point after the entry
1183             (goto-char (match-end 0))
1184             ;; Store the filename in the right variable
1185             (cond
1186              ((string-equal tag "a")
1187               (if file-A
1188                   (error "This line has two `A' entries"))
1189               (setq file-A file))
1190              ((string-equal tag "b")
1191               (if file-B
1192                   (error "This line has two `B' entries"))
1193               (setq file-B file))
1194              ((or (string-equal tag "anc") (string-equal tag "ancestor"))
1195               (if file-ancestor
1196                   (error "This line has two `ancestor' entries"))
1197               (setq file-ancestor file))
1198              ((or (string-equal tag "out") (string-equal tag "output"))
1199               (if file-out
1200                   (error "This line has two `output' entries"))
1201               (setq file-out file))
1202              (t
1203               (error "Unrecognized entry"))))
1204         ;; If the match on the entry pattern failed
1205         (error "Unparsable entry")))
1206     ;; Make sure that file-A and file-B are present
1207     (if (not (or (and file-A file-B) file-out))
1208         (error "Must have both `A' and `B' entries"))
1209     (if (not (or file-A file-B))
1210         (error "Must have `A' or `B' entry"))
1211     ;; Go to the beginning of the next line, so next execution will use
1212     ;; next line in buffer.
1213     (beginning-of-line 2)
1214     ;; Execute the correct command
1215     (cond
1216      ;; Merge of two files with ancestor
1217      ((and file-A file-B file-ancestor)
1218       (message "Merging %s and %s..." file-A file-B)
1219       (emerge-files-with-ancestor (not (not file-out)) file-A file-B
1220                                   file-ancestor file-out
1221                                   nil
1222                                   ;; When done, return to this buffer.
1223                                   (list
1224                                    (` (lambda ()
1225                                         (switch-to-buffer (, (current-buffer)))
1226                                         (message "Merge done."))))))
1227      ;; Merge of two files without ancestor
1228      ((and file-A file-B)
1229       (message "Merging %s and %s..." file-A file-B)
1230       (emerge-files (not (not file-out)) file-A file-B file-out
1231                     nil
1232                     ;; When done, return to this buffer.
1233                     (list
1234                      (` (lambda ()
1235                           (switch-to-buffer (, (current-buffer)))
1236                           (message "Merge done."))))))
1237      ;; There is an output file (or there would have been an error above),
1238      ;; but only one input file.
1239      ;; The file appears to have been deleted in one version; do nothing.
1240      ((and file-ancestor emerge-execute-line-deletions)
1241       (message "No action."))
1242      ;; The file should be copied from the version that contains it
1243      (t (let ((input-file (or file-A file-B)))
1244           (message "Copying...")
1245           (copy-file input-file file-out)
1246           (message "%s copied to %s." input-file file-out))))))
1247
1248 ;;; Sample function for creating information for emerge-execute-line
1249
1250 (defvar emerge-merge-directories-filename-regexp "[^.]"
1251   "Regexp describing files to be processed by `emerge-merge-directories'.")
1252
1253 ;;;###autoload
1254 (defun emerge-merge-directories (a-dir b-dir ancestor-dir output-dir)
1255   (interactive
1256    (list
1257     (read-file-name "A directory: " nil nil 'confirm)
1258     (read-file-name "B directory: " nil nil 'confirm)
1259     (read-file-name "Ancestor directory (null for none): " nil nil 'confirm)
1260     (read-file-name "Output directory (null for none): " nil nil 'confirm)))
1261   ;; Check that we're not on a line
1262   (if (not (and (bolp) (eolp)))
1263       (error "There is text on this line"))
1264   ;; Turn null strings into nil to indicate directories not used.
1265   (if (and ancestor-dir (string-equal ancestor-dir ""))
1266       (setq ancestor-dir nil))
1267   (if (and output-dir (string-equal output-dir ""))
1268       (setq output-dir nil))
1269   ;; Canonicalize the directory names
1270   (setq a-dir (expand-file-name a-dir))
1271   (if (not (string-equal (substring a-dir -1) "/"))
1272       (setq a-dir (concat a-dir "/")))
1273   (setq b-dir (expand-file-name b-dir))
1274   (if (not (string-equal (substring b-dir -1) "/"))
1275       (setq b-dir (concat b-dir "/")))
1276   (if ancestor-dir
1277       (progn
1278         (setq ancestor-dir (expand-file-name ancestor-dir))
1279         (if (not (string-equal (substring ancestor-dir -1) "/"))
1280             (setq ancestor-dir (concat ancestor-dir "/")))))
1281   (if output-dir
1282       (progn
1283         (setq output-dir (expand-file-name output-dir))
1284         (if (not (string-equal (substring output-dir -1) "/"))
1285             (setq output-dir (concat output-dir "/")))))
1286   ;; Set the mark to where we start
1287   (push-mark)
1288   ;; Find out what files are in the directories.
1289   (let* ((a-dir-files
1290           (directory-files a-dir nil emerge-merge-directories-filename-regexp))
1291          (b-dir-files
1292           (directory-files b-dir nil emerge-merge-directories-filename-regexp))
1293          (ancestor-dir-files
1294           (and ancestor-dir
1295                (directory-files ancestor-dir nil
1296                                 emerge-merge-directories-filename-regexp)))
1297          (all-files (sort (nconc (copy-sequence a-dir-files)
1298                                  (copy-sequence b-dir-files)
1299                                  (copy-sequence ancestor-dir-files))
1300                           (function string-lessp))))
1301     ;; Remove duplicates from all-files.
1302     (let ((p all-files))
1303       (while p
1304         (if (and (cdr p) (string-equal (car p) (car (cdr p))))
1305             (setcdr p (cdr (cdr p)))
1306           (setq p (cdr p)))))
1307     ;; Generate the control lines for the various files.
1308     (while all-files
1309       (let ((f (car all-files)))
1310         (setq all-files (cdr all-files))
1311         (if (and a-dir-files (string-equal (car a-dir-files) f))
1312             (progn
1313               (insert "A=" a-dir f "\t")
1314               (setq a-dir-files (cdr a-dir-files))))
1315         (if (and b-dir-files (string-equal (car b-dir-files) f))
1316             (progn
1317               (insert "B=" b-dir f "\t")
1318               (setq b-dir-files (cdr b-dir-files))))
1319         (if (and ancestor-dir-files (string-equal (car ancestor-dir-files) f))
1320             (progn
1321               (insert "ancestor=" ancestor-dir f "\t")
1322               (setq ancestor-dir-files (cdr ancestor-dir-files))))
1323         (if output-dir
1324             (insert "output=" output-dir f "\t"))
1325         (backward-delete-char 1)
1326         (insert "\n")))))
1327
1328 ;;; Common setup routines
1329
1330 ;; Set up the window configuration.  If POS is given, set the points to
1331 ;; the beginnings of the buffers.
1332 (defun emerge-setup-windows (buffer-A buffer-B merge-buffer &optional pos)
1333   ;; Make sure we are not in the minibuffer window when we try to delete
1334   ;; all other windows.
1335   (if (eq (selected-window) (minibuffer-window))
1336       (other-window 1))
1337   (delete-other-windows)
1338   (switch-to-buffer merge-buffer)
1339   (emerge-refresh-mode-line)
1340   (split-window-vertically)
1341   (split-window-horizontally)
1342   (switch-to-buffer buffer-A)
1343   (if pos
1344       (goto-char (point-min)))
1345   (other-window 1)
1346   (switch-to-buffer buffer-B)
1347   (if pos
1348       (goto-char (point-min)))
1349   (other-window 1)
1350   (if pos
1351       (goto-char (point-min)))
1352   ;; If diff/diff3 reports errors, display them rather than the merge buffer.
1353   (if (/= 0 (emerge-eval-in-buffer emerge-diff-error-buffer (buffer-size)))
1354       (progn
1355         (ding)
1356         (message "Errors found in diff/diff3 output.  Merge buffer is %s."
1357                  (buffer-name emerge-merge-buffer))
1358         (switch-to-buffer emerge-diff-error-buffer))))
1359
1360 ;; Set up the keymap in the merge buffer
1361 (defun emerge-set-keys ()
1362   ;; Set up fixed keymaps if necessary
1363   (if (not emerge-basic-keymap)
1364       (emerge-setup-fixed-keymaps))
1365   ;; Save the old local map
1366   (setq emerge-old-keymap (current-local-map))
1367   ;; Construct the edit keymap
1368   (setq emerge-edit-keymap (if emerge-old-keymap
1369                                (copy-keymap emerge-old-keymap)
1370                              (make-sparse-keymap)))
1371   ;; Install the Emerge commands
1372   (emerge-force-define-key emerge-edit-keymap emerge-command-prefix
1373                            'emerge-basic-keymap)
1374   (define-key emerge-edit-keymap [menu-bar] (make-sparse-keymap))
1375
1376   ;; Create the additional menu bar items.
1377   (define-key emerge-edit-keymap [menu-bar options]
1378     (cons "Options" emerge-options-menu))
1379   (define-key emerge-edit-keymap [menu-bar merge]
1380     (cons "Merge" emerge-merge-menu))
1381   (define-key emerge-edit-keymap [menu-bar move]
1382     (cons "Move" emerge-move-menu))
1383
1384   ;; Suppress write-file and save-buffer
1385   (substitute-key-definition 'write-file
1386                              'emerge-query-write-file
1387                              emerge-edit-keymap)
1388   (substitute-key-definition 'save-buffer
1389                              'emerge-query-save-buffer
1390                              emerge-edit-keymap)
1391   (substitute-key-definition 'write-file 'emerge-query-write-file
1392                              emerge-edit-keymap (current-global-map))
1393   (substitute-key-definition 'save-buffer 'emerge-query-save-buffer
1394                              emerge-edit-keymap (current-global-map))
1395   (use-local-map emerge-fast-keymap)
1396   (setq emerge-edit-mode nil)
1397   (setq emerge-fast-mode t))
1398
1399 (defun emerge-remember-buffer-characteristics ()
1400   "Record certain properties of the buffers being merged.
1401 Must be called in the merge buffer.  Remembers read-only, modified,
1402 auto-save, and saves them in buffer local variables.  Sets the buffers
1403 read-only and turns off `auto-save-mode'.
1404 These characteristics are restored by `emerge-restore-buffer-characteristics'."
1405   ;; force auto-save, because we will turn off auto-saving in buffers for the
1406   ;; duration
1407   (do-auto-save)
1408   ;; remember and alter buffer characteristics
1409   (setq emerge-A-buffer-values
1410         (emerge-eval-in-buffer
1411          emerge-A-buffer
1412          (prog1
1413              (emerge-save-variables emerge-saved-variables)
1414            (emerge-restore-variables emerge-saved-variables
1415                                      emerge-merging-values))))
1416   (setq emerge-B-buffer-values
1417         (emerge-eval-in-buffer
1418          emerge-B-buffer
1419          (prog1
1420              (emerge-save-variables emerge-saved-variables)
1421            (emerge-restore-variables emerge-saved-variables
1422                                      emerge-merging-values)))))
1423
1424 (defun emerge-restore-buffer-characteristics ()
1425   "Restores characteristics saved by `emerge-remember-buffer-characteristics'."
1426   (let ((A-values emerge-A-buffer-values)
1427         (B-values emerge-B-buffer-values))
1428     (emerge-eval-in-buffer emerge-A-buffer
1429                            (emerge-restore-variables emerge-saved-variables
1430                                                      A-values))
1431     (emerge-eval-in-buffer emerge-B-buffer
1432                            (emerge-restore-variables emerge-saved-variables
1433                                                      B-values))))
1434
1435 ;; Move to line DESIRED-LINE assuming we are at line CURRENT-LINE.
1436 ;; Return DESIRED-LINE.
1437 (defun emerge-goto-line (desired-line current-line)
1438   (forward-line (- desired-line current-line))
1439   current-line)
1440
1441 (defun emerge-convert-diffs-to-markers (A-buffer
1442                                         B-buffer
1443                                         merge-buffer
1444                                         lineno-list)
1445   (let* (marker-list
1446          (A-point-min (emerge-eval-in-buffer A-buffer (point-min)))
1447          (offset (1- A-point-min))
1448          (A-hidden-lines (emerge-eval-in-buffer
1449                           A-buffer
1450                           (save-restriction
1451                             (widen)
1452                             (count-lines 1 A-point-min))))
1453          (B-point-min (emerge-eval-in-buffer B-buffer (point-min)))
1454          (B-hidden-lines (emerge-eval-in-buffer
1455                           B-buffer
1456                           (save-restriction
1457                             (widen)
1458                             (count-lines 1 B-point-min))))
1459          ;; Record current line number in each buffer
1460          ;; so we don't have to count from the beginning.
1461          (a-line A-hidden-lines)
1462          (b-line B-hidden-lines))
1463     (emerge-eval-in-buffer A-buffer (goto-char (point-min)))
1464     (emerge-eval-in-buffer B-buffer (goto-char (point-min)))
1465     (while lineno-list
1466       (let* ((list-element (car lineno-list))
1467              a-begin-marker
1468              a-end-marker
1469              b-begin-marker
1470              b-end-marker
1471              merge-begin-marker
1472              merge-end-marker
1473              (a-begin (aref list-element 0))
1474              (a-end (aref list-element 1))
1475              (b-begin (aref list-element 2))
1476              (b-end (aref list-element 3))
1477              (state (aref list-element 4)))
1478         ;; place markers at the appropriate places in the buffers
1479         (emerge-eval-in-buffer
1480          A-buffer
1481          (setq a-line (emerge-goto-line (+ a-begin A-hidden-lines) a-line))
1482          (setq a-begin-marker (point-marker))
1483          (setq a-line (emerge-goto-line (+ a-end A-hidden-lines) a-line))
1484          (setq a-end-marker (point-marker)))
1485         (emerge-eval-in-buffer
1486          B-buffer
1487          (setq b-line (emerge-goto-line (+ b-begin B-hidden-lines) b-line))
1488          (setq b-begin-marker (point-marker))
1489          (setq b-line (emerge-goto-line (+ b-end B-hidden-lines) b-line))
1490          (setq b-end-marker (point-marker)))
1491         (setq merge-begin-marker (set-marker
1492                                   (make-marker)
1493                                   (- (marker-position a-begin-marker)
1494                                      offset)
1495                                   merge-buffer))
1496         (setq merge-end-marker (set-marker
1497                                 (make-marker)
1498                                 (- (marker-position a-end-marker)
1499                                    offset)
1500                                 merge-buffer))
1501         ;; record all the markers for this difference
1502         (setq marker-list (cons (vector a-begin-marker a-end-marker
1503                                         b-begin-marker b-end-marker
1504                                         merge-begin-marker merge-end-marker
1505                                         state)
1506                                 marker-list)))
1507       (setq lineno-list (cdr lineno-list)))
1508     ;; convert the list of difference information into a vector for
1509     ;; fast access
1510     (setq emerge-difference-list (apply 'vector (nreverse marker-list)))))
1511
1512 ;; If we have an ancestor, select all B variants that we prefer
1513 (defun emerge-select-prefer-Bs ()
1514   (let ((n 0))
1515     (while (< n emerge-number-of-differences)
1516       (if (eq (aref (aref emerge-difference-list n) 6) 'prefer-B)
1517           (progn
1518             (emerge-unselect-and-select-difference n t)
1519             (emerge-select-B)
1520             (aset (aref emerge-difference-list n) 6 'prefer-B)))
1521       (setq n (1+ n))))
1522   (emerge-unselect-and-select-difference -1))
1523
1524 ;; Process the local-variables list at the end of the merged file, if
1525 ;; requested.
1526 (defun emerge-handle-local-variables ()
1527   (if emerge-process-local-variables
1528       (condition-case err
1529           (hack-local-variables)
1530         (error (message "Local-variables error in merge buffer: %s"
1531                         (prin1-to-string err))))))
1532
1533 ;;; Common exit routines
1534
1535 (defun emerge-write-and-delete (file-out)
1536   ;; clear screen format
1537   (delete-other-windows)
1538   ;; delete A, B, and ancestor buffers, if they haven't been changed
1539   (if (not (buffer-modified-p emerge-A-buffer))
1540       (kill-buffer emerge-A-buffer))
1541   (if (not (buffer-modified-p emerge-B-buffer))
1542       (kill-buffer emerge-B-buffer))
1543   (if (and emerge-ancestor-buffer
1544            (not (buffer-modified-p emerge-ancestor-buffer)))
1545       (kill-buffer emerge-ancestor-buffer))
1546   ;; Write merge buffer to file
1547   (and file-out
1548        (write-file file-out)))
1549
1550 ;;; Commands
1551
1552 (defun emerge-recenter (&optional arg)
1553   "Bring the highlighted region of all three merge buffers into view.
1554 This brings the buffers into view if they are in windows.
1555 With an argument, reestablish the default three-window display."
1556   (interactive "P")
1557   ;; If there is an argument, rebuild the window structure
1558   (if arg
1559       (emerge-setup-windows emerge-A-buffer emerge-B-buffer
1560                             emerge-merge-buffer))
1561   ;; Redisplay whatever buffers are showing, if there is a selected difference
1562   (if (and (>= emerge-current-difference 0)
1563            (< emerge-current-difference emerge-number-of-differences))
1564       (let* ((merge-buffer emerge-merge-buffer)
1565              (buffer-A emerge-A-buffer)
1566              (buffer-B emerge-B-buffer)
1567              (window-A (get-buffer-window buffer-A))
1568              (window-B (get-buffer-window buffer-B))
1569              (merge-window (get-buffer-window merge-buffer))
1570              (diff-vector
1571               (aref emerge-difference-list emerge-current-difference)))
1572         (if window-A (progn
1573                        (select-window window-A)
1574                        (emerge-position-region
1575                         (- (aref diff-vector 0)
1576                            (1- emerge-before-flag-length))
1577                         (+ (aref diff-vector 1)
1578                            (1- emerge-after-flag-length))
1579                         (1+ (aref diff-vector 0)))))
1580         (if window-B (progn
1581                        (select-window window-B)
1582                        (emerge-position-region
1583                         (- (aref diff-vector 2)
1584                            (1- emerge-before-flag-length))
1585                         (+ (aref diff-vector 3)
1586                            (1- emerge-after-flag-length))
1587                         (1+ (aref diff-vector 2)))))
1588         (if merge-window (progn
1589                            (select-window merge-window)
1590                            (emerge-position-region
1591                             (- (aref diff-vector 4)
1592                                (1- emerge-before-flag-length))
1593                             (+ (aref diff-vector 5)
1594                                (1- emerge-after-flag-length))
1595                             (1+ (aref diff-vector 4))))))))
1596
1597 ;;; Window scrolling operations
1598 ;; These operations are designed to scroll all three windows the same amount,
1599 ;; so as to keep the text in them aligned.
1600
1601 ;; Perform some operation on all three windows (if they are showing).
1602 ;; Catches all errors on the operation in the A and B windows, but not
1603 ;; in the merge window.  Usually, errors come from scrolling off the
1604 ;; beginning or end of the buffer, and this gives a nice error message:
1605 ;; End of buffer is reported in the merge buffer, but if the scroll was
1606 ;; possible in the A or B windows, it is performed there before the error
1607 ;; is reported.
1608 (defun emerge-operate-on-windows (operation arg)
1609   (let* ((merge-buffer emerge-merge-buffer)
1610          (buffer-A emerge-A-buffer)
1611          (buffer-B emerge-B-buffer)
1612          (window-A (get-buffer-window buffer-A))
1613          (window-B (get-buffer-window buffer-B))
1614          (merge-window (get-buffer-window merge-buffer)))
1615     (if window-A (progn
1616                    (select-window window-A)
1617                    (condition-case nil
1618                        (funcall operation arg)
1619                      (error))))
1620     (if window-B (progn
1621                    (select-window window-B)
1622                    (condition-case nil
1623                        (funcall operation arg)
1624                      (error))))
1625     (if merge-window (progn
1626                        (select-window merge-window)
1627                        (funcall operation arg)))))
1628
1629 (defun emerge-scroll-up (&optional arg)
1630   "Scroll up all three merge buffers, if they are in windows.
1631 With argument N, scroll N lines; otherwise scroll by nearly
1632 the height of the merge window.
1633 `C-u -' alone as argument scrolls half the height of the merge window."
1634   (interactive "P")
1635   (emerge-operate-on-windows
1636    'scroll-up
1637    ;; calculate argument to scroll-up
1638    ;; if there is an explicit argument
1639    (if (and arg (not (equal arg '-)))
1640        ;; use it
1641        (prefix-numeric-value arg)
1642      ;; if not, see if we can determine a default amount (the window height)
1643      (let ((merge-window (get-buffer-window emerge-merge-buffer)))
1644        (if (null merge-window)
1645            ;; no window, use nil
1646            nil
1647          (let ((default-amount
1648                  (- (window-height merge-window) 1 next-screen-context-lines)))
1649            ;; the window was found
1650            (if arg
1651                ;; C-u as argument means half of default amount
1652                (/ default-amount 2)
1653              ;; no argument means default amount
1654              default-amount)))))))
1655
1656 (defun emerge-scroll-down (&optional arg)
1657   "Scroll down all three merge buffers, if they are in windows.
1658 With argument N, scroll N lines; otherwise scroll by nearly
1659 the height of the merge window.
1660 `C-u -' alone as argument scrolls half the height of the merge window."
1661   (interactive "P")
1662   (emerge-operate-on-windows
1663    'scroll-down
1664    ;; calculate argument to scroll-down
1665    ;; if there is an explicit argument
1666    (if (and arg (not (equal arg '-)))
1667        ;; use it
1668        (prefix-numeric-value arg)
1669      ;; if not, see if we can determine a default amount (the window height)
1670      (let ((merge-window (get-buffer-window emerge-merge-buffer)))
1671        (if (null merge-window)
1672            ;; no window, use nil
1673            nil
1674          (let ((default-amount
1675                  (- (window-height merge-window) 1 next-screen-context-lines)))
1676            ;; the window was found
1677            (if arg
1678                ;; C-u as argument means half of default amount
1679                (/ default-amount 2)
1680              ;; no argument means default amount
1681              default-amount)))))))
1682
1683 (defun emerge-scroll-left (&optional arg)
1684   "Scroll left all three merge buffers, if they are in windows.
1685 If an argument is given, that is how many columns are scrolled, else nearly
1686 the width of the A and B windows.  `C-u -' alone as argument scrolls half the
1687 width of the A and B windows."
1688   (interactive "P")
1689   (emerge-operate-on-windows
1690    'scroll-left
1691    ;; calculate argument to scroll-left
1692    ;; if there is an explicit argument
1693    (if (and arg (not (equal arg '-)))
1694        ;; use it
1695        (prefix-numeric-value arg)
1696      ;; if not, see if we can determine a default amount
1697      ;; (half the window width)
1698      (let ((merge-window (get-buffer-window emerge-merge-buffer)))
1699        (if (null merge-window)
1700            ;; no window, use nil
1701            nil
1702          (let ((default-amount
1703                  (- (/ (window-width merge-window) 2) 3)))
1704            ;; the window was found
1705            (if arg
1706                ;; C-u as argument means half of default amount
1707                (/ default-amount 2)
1708              ;; no argument means default amount
1709              default-amount)))))))
1710
1711 (defun emerge-scroll-right (&optional arg)
1712   "Scroll right all three merge buffers, if they are in windows.
1713 If an argument is given, that is how many columns are scrolled, else nearly
1714 the width of the A and B windows.  `C-u -' alone as argument scrolls half the
1715 width of the A and B windows."
1716   (interactive "P")
1717   (emerge-operate-on-windows
1718    'scroll-right
1719    ;; calculate argument to scroll-right
1720    ;; if there is an explicit argument
1721    (if (and arg (not (equal arg '-)))
1722        ;; use it
1723        (prefix-numeric-value arg)
1724      ;; if not, see if we can determine a default amount
1725      ;; (half the window width)
1726      (let ((merge-window (get-buffer-window emerge-merge-buffer)))
1727        (if (null merge-window)
1728            ;; no window, use nil
1729            nil
1730          (let ((default-amount
1731                  (- (/ (window-width merge-window) 2) 3)))
1732            ;; the window was found
1733            (if arg
1734                ;; C-u as argument means half of default amount
1735                (/ default-amount 2)
1736              ;; no argument means default amount
1737              default-amount)))))))
1738
1739 (defun emerge-scroll-reset ()
1740   "Reset horizontal scrolling in Emerge.
1741 This resets the horizontal scrolling of all three merge buffers
1742 to the left margin, if they are in windows."
1743   (interactive)
1744   (emerge-operate-on-windows
1745    (function (lambda (x) (set-window-hscroll (selected-window) 0)))
1746    nil))
1747
1748 ;; Attempt to show the region nicely.
1749 ;; If there are min-lines lines above and below the region, then don't do
1750 ;; anything.
1751 ;; If not, recenter the region to make it so.
1752 ;; If that isn't possible, remove context lines balancedly from top and botton
1753 ;; so the entire region shows.
1754 ;; If that isn't possible, show the top of the region.
1755 ;; BEG must be at the beginning of a line.
1756 (defun emerge-position-region (beg end pos)
1757   ;; First test whether the entire region is visible with
1758   ;; emerge-min-visible-lines above and below it
1759   (if (not (and (<= (progn
1760                       (move-to-window-line emerge-min-visible-lines)
1761                       (point))
1762                     beg)
1763                 (<= end (progn
1764                           (move-to-window-line
1765                            (- (1+ emerge-min-visible-lines)))
1766                           (point)))))
1767       ;; We failed that test, see if it fits at all
1768       ;; Meanwhile positioning it correctly in case it doesn't fit
1769       (progn
1770         (set-window-start (selected-window) beg)
1771         (if (pos-visible-in-window-p end)
1772             ;; Determine the number of lines that the region occupies
1773             (let ((lines 0))
1774               (while (> end (progn
1775                               (move-to-window-line lines)
1776                               (point)))
1777                 (setq lines (1+ lines)))
1778               ;; And position the beginning on the right line
1779               (goto-char beg)
1780               (recenter (/ (1+ (- (1- (window-height (selected-window)))
1781                                   lines))
1782                            2))))))
1783   (goto-char pos))
1784
1785 (defun emerge-next-difference ()
1786   "Advance to the next difference."
1787   (interactive)
1788   (if (< emerge-current-difference emerge-number-of-differences)
1789       (let ((n (1+ emerge-current-difference)))
1790         (while (and emerge-skip-prefers
1791                     (< n emerge-number-of-differences)
1792                     (memq (aref (aref emerge-difference-list n) 6)
1793                           '(prefer-A prefer-B)))
1794           (setq n (1+ n)))
1795         (let ((buffer-read-only nil))
1796           (emerge-unselect-and-select-difference n)))
1797     (error "At end")))
1798
1799 (defun emerge-previous-difference ()
1800   "Go to the previous difference."
1801   (interactive)
1802   (if (> emerge-current-difference -1)
1803       (let ((n (1- emerge-current-difference)))
1804         (while (and emerge-skip-prefers
1805                     (> n -1)
1806                     (memq (aref (aref emerge-difference-list n) 6)
1807                           '(prefer-A prefer-B)))
1808           (setq n (1- n)))
1809         (let ((buffer-read-only nil))
1810           (emerge-unselect-and-select-difference n)))
1811     (error "At beginning")))
1812
1813 (defun emerge-jump-to-difference (difference-number)
1814   "Go to the N-th difference."
1815   (interactive "p")
1816   (let ((buffer-read-only nil))
1817     (setq difference-number (1- difference-number))
1818     (if (and (>= difference-number -1)
1819              (< difference-number (1+ emerge-number-of-differences)))
1820         (emerge-unselect-and-select-difference difference-number)
1821       (error "Bad difference number"))))
1822
1823 (defun emerge-abort ()
1824   "Abort the Emerge session."
1825   (interactive)
1826   (emerge-quit t))
1827
1828 (defun emerge-quit (arg)
1829   "Finish the Emerge session and exit Emerge.
1830 Prefix argument means to abort rather than successfully finish.
1831 The difference depends on how the merge was started,
1832 but usually means to not write over one of the original files, or to signal
1833 to some process which invoked Emerge a failure code.
1834
1835 Unselects the selected difference, if any, restores the read-only and modified
1836 flags of the merged file buffers, restores the local keymap of the merge
1837 buffer, and sets off various emerge flags.  Using Emerge commands in this
1838 buffer after this will cause serious problems."
1839   (interactive "P")
1840   (if (prog1
1841           (y-or-n-p
1842            (if (not arg)
1843                "Do you really want to successfully finish this merge? "
1844              "Do you really want to abort this merge? "))
1845         (message ""))
1846       (emerge-really-quit arg)))
1847
1848 ;; Perform the quit operations.
1849 (defun emerge-really-quit (arg)
1850   (setq buffer-read-only nil)
1851   (emerge-unselect-and-select-difference -1)
1852   (emerge-restore-buffer-characteristics)
1853   ;; null out the difference markers so they don't slow down future editing
1854   ;; operations
1855   (mapcar (function (lambda (d)
1856                       (set-marker (aref d 0) nil)
1857                       (set-marker (aref d 1) nil)
1858                       (set-marker (aref d 2) nil)
1859                       (set-marker (aref d 3) nil)
1860                       (set-marker (aref d 4) nil)
1861                       (set-marker (aref d 5) nil)))
1862           emerge-difference-list)
1863   ;; allow them to be garbage collected
1864   (setq emerge-difference-list nil)
1865   ;; restore the local map
1866   (use-local-map emerge-old-keymap)
1867   ;; turn off all the emerge modes
1868   (setq emerge-mode nil)
1869   (setq emerge-fast-mode nil)
1870   (setq emerge-edit-mode nil)
1871   (setq emerge-auto-advance nil)
1872   (setq emerge-skip-prefers nil)
1873   ;; restore mode line
1874   (kill-local-variable 'mode-line-buffer-identification)
1875   (let ((emerge-prefix-argument arg))
1876     (run-hooks 'emerge-quit-hook)))
1877
1878 (defun emerge-select-A (&optional force)
1879   "Select the A variant of this difference.
1880 Refuses to function if this difference has been edited, i.e., if it
1881 is neither the A nor the B variant.
1882 A prefix argument forces the variant to be selected
1883 even if the difference has been edited."
1884   (interactive "P")
1885   (let ((operate
1886          (function (lambda ()
1887                      (emerge-select-A-edit merge-begin merge-end A-begin A-end)
1888                      (if emerge-auto-advance
1889                          (emerge-next-difference)))))
1890         (operate-no-change
1891          (function (lambda ()
1892                      (if emerge-auto-advance
1893                          (emerge-next-difference))))))
1894     (emerge-select-version force operate-no-change operate operate)))
1895
1896 ;; Actually select the A variant
1897 (defun emerge-select-A-edit (merge-begin merge-end A-begin A-end)
1898   (emerge-eval-in-buffer
1899    emerge-merge-buffer
1900    (delete-region merge-begin merge-end)
1901    (goto-char merge-begin)
1902    (insert-buffer-substring emerge-A-buffer A-begin A-end)
1903    (goto-char merge-begin)
1904    (aset diff-vector 6 'A)
1905    (emerge-refresh-mode-line)))
1906
1907 (defun emerge-select-B (&optional force)
1908   "Select the B variant of this difference.
1909 Refuses to function if this difference has been edited, i.e., if it
1910 is neither the A nor the B variant.
1911 A prefix argument forces the variant to be selected
1912 even if the difference has been edited."
1913   (interactive "P")
1914   (let ((operate
1915          (function (lambda ()
1916                      (emerge-select-B-edit merge-begin merge-end B-begin B-end)
1917                      (if emerge-auto-advance
1918                          (emerge-next-difference)))))
1919         (operate-no-change
1920          (function (lambda ()
1921                      (if emerge-auto-advance
1922                          (emerge-next-difference))))))
1923     (emerge-select-version force operate operate-no-change operate)))
1924
1925 ;; Actually select the B variant
1926 (defun emerge-select-B-edit (merge-begin merge-end B-begin B-end)
1927   (emerge-eval-in-buffer
1928    emerge-merge-buffer
1929    (delete-region merge-begin merge-end)
1930    (goto-char merge-begin)
1931    (insert-buffer-substring emerge-B-buffer B-begin B-end)
1932    (goto-char merge-begin)
1933    (aset diff-vector 6 'B)
1934    (emerge-refresh-mode-line)))
1935
1936 (defun emerge-default-A ()
1937   "Make the A variant the default from here down.
1938 This selects the A variant for all differences from here down in the buffer
1939 which are still defaulted, i.e., which the user has not selected and for
1940 which there is no preference."
1941   (interactive)
1942   (let ((buffer-read-only nil))
1943     (let ((selected-difference emerge-current-difference)
1944           (n (max emerge-current-difference 0)))
1945       (while (< n emerge-number-of-differences)
1946         (let ((diff-vector (aref emerge-difference-list n)))
1947           (if (eq (aref diff-vector 6) 'default-B)
1948               (progn
1949                 (emerge-unselect-and-select-difference n t)
1950                 (emerge-select-A)
1951                 (aset diff-vector 6 'default-A))))
1952         (setq n (1+ n))
1953         (if (zerop (% n 10))
1954             (message "Setting default to A...%d" n)))
1955       (emerge-unselect-and-select-difference selected-difference)))
1956   (message "Default choice is now A"))
1957
1958 (defun emerge-default-B ()
1959   "Make the B variant the default from here down.
1960 This selects the B variant for all differences from here down in the buffer
1961 which are still defaulted, i.e., which the user has not selected and for
1962 which there is no preference."
1963   (interactive)
1964   (let ((buffer-read-only nil))
1965     (let ((selected-difference emerge-current-difference)
1966           (n (max emerge-current-difference 0)))
1967       (while (< n emerge-number-of-differences)
1968         (let ((diff-vector (aref emerge-difference-list n)))
1969           (if (eq (aref diff-vector 6) 'default-A)
1970               (progn
1971                 (emerge-unselect-and-select-difference n t)
1972                 (emerge-select-B)
1973                 (aset diff-vector 6 'default-B))))
1974         (setq n (1+ n))
1975         (if (zerop (% n 10))
1976             (message "Setting default to B...%d" n)))
1977       (emerge-unselect-and-select-difference selected-difference)))
1978   (message "Default choice is now B"))
1979
1980 (defun emerge-fast-mode ()
1981   "Set fast mode, for Emerge.
1982 In this mode ordinary Emacs commands are disabled, and Emerge commands
1983 need not be prefixed with \\<emerge-fast-keymap>\\[emerge-basic-keymap]."
1984   (interactive)
1985   (setq buffer-read-only t)
1986   (use-local-map emerge-fast-keymap)
1987   (setq emerge-mode t)
1988   (setq emerge-fast-mode t)
1989   (setq emerge-edit-mode nil)
1990   (message "Fast mode set")
1991   ;; force mode line redisplay
1992   (set-buffer-modified-p (buffer-modified-p)))
1993
1994 (defun emerge-edit-mode ()
1995   "Set edit mode, for Emerge.
1996 In this mode ordinary Emacs commands are available, and Emerge commands
1997 must be prefixed with \\<emerge-fast-keymap>\\[emerge-basic-keymap]."
1998   (interactive)
1999   (setq buffer-read-only nil)
2000   (use-local-map emerge-edit-keymap)
2001   (setq emerge-mode t)
2002   (setq emerge-fast-mode nil)
2003   (setq emerge-edit-mode t)
2004   (message "Edit mode set")
2005   ;; force mode line redisplay
2006   (set-buffer-modified-p (buffer-modified-p)))
2007
2008 (defun emerge-auto-advance (arg)
2009   "Toggle Auto-Advance mode, for Emerge.
2010 This mode causes `emerge-select-A' and `emerge-select-B' to automatically
2011 advance to the next difference.
2012 With a positive argument, turn on Auto-Advance mode.
2013 With a negative argument, turn off Auto-Advance mode."
2014   (interactive "P")
2015   (setq emerge-auto-advance (if (null arg)
2016                                 (not emerge-auto-advance)
2017                               (> (prefix-numeric-value arg) 0)))
2018   (message (if emerge-skip-prefers
2019                "Auto-advance set"
2020              "Auto-advance cleared"))
2021   ;; force mode line redisplay
2022   (set-buffer-modified-p (buffer-modified-p)))
2023
2024 (defun emerge-skip-prefers (arg)
2025   "Toggle Skip-Prefers mode, for Emerge.
2026 This mode causes `emerge-next-difference' and `emerge-previous-difference'
2027 to automatically skip over differences for which there is a preference.
2028 With a positive argument, turn on Skip-Prefers mode.
2029 With a negative argument, turn off Skip-Prefers mode."
2030   (interactive "P")
2031   (setq emerge-skip-prefers (if (null arg)
2032                                 (not emerge-skip-prefers)
2033                               (> (prefix-numeric-value arg) 0)))
2034   (message (if emerge-skip-prefers
2035                "Skip-prefers set"
2036              "Skip-prefers cleared"))
2037   ;; force mode line redisplay
2038   (set-buffer-modified-p (buffer-modified-p)))
2039
2040 (defun emerge-copy-as-kill-A ()
2041   "Put the A variant of this difference in the kill ring."
2042   (interactive)
2043   (emerge-validate-difference)
2044   (let* ((diff-vector
2045           (aref emerge-difference-list emerge-current-difference))
2046          (A-begin (1+ (aref diff-vector 0)))
2047          (A-end (1- (aref diff-vector 1)))
2048          ;; so further kills don't append
2049          this-command)
2050     (save-excursion
2051       (set-buffer emerge-A-buffer)
2052       (copy-region-as-kill A-begin A-end))))
2053
2054 (defun emerge-copy-as-kill-B ()
2055   "Put the B variant of this difference in the kill ring."
2056   (interactive)
2057   (emerge-validate-difference)
2058   (let* ((diff-vector
2059           (aref emerge-difference-list emerge-current-difference))
2060          (B-begin (1+ (aref diff-vector 2)))
2061          (B-end (1- (aref diff-vector 3)))
2062          ;; so further kills don't append
2063          this-command)
2064     (save-excursion
2065       (set-buffer emerge-B-buffer)
2066       (copy-region-as-kill B-begin B-end))))
2067
2068 (defun emerge-insert-A (arg)
2069   "Insert the A variant of this difference at the point.
2070 Leaves point after text, mark before.
2071 With prefix argument, puts point before, mark after."
2072   (interactive "P")
2073   (emerge-validate-difference)
2074   (let* ((diff-vector
2075           (aref emerge-difference-list emerge-current-difference))
2076          (A-begin (1+ (aref diff-vector 0)))
2077          (A-end (1- (aref diff-vector 1)))
2078          (opoint (point))
2079          (buffer-read-only nil))
2080     (insert-buffer-substring emerge-A-buffer A-begin A-end)
2081     (if (not arg)
2082         (set-mark opoint)
2083       (set-mark (point))
2084       (goto-char opoint))))
2085
2086 (defun emerge-insert-B (arg)
2087   "Insert the B variant of this difference at the point.
2088 Leaves point after text, mark before.
2089 With prefix argument, puts point before, mark after."
2090   (interactive "P")
2091   (emerge-validate-difference)
2092   (let* ((diff-vector
2093           (aref emerge-difference-list emerge-current-difference))
2094          (B-begin (1+ (aref diff-vector 2)))
2095          (B-end (1- (aref diff-vector 3)))
2096          (opoint (point))
2097          (buffer-read-only nil))
2098     (insert-buffer-substring emerge-B-buffer B-begin B-end)
2099     (if (not arg)
2100         (set-mark opoint)
2101       (set-mark (point))
2102       (goto-char opoint))))
2103
2104 (defun emerge-mark-difference (arg)
2105   "Leaves the point before this difference and the mark after it.
2106 With prefix argument, puts mark before, point after."
2107   (interactive "P")
2108   (emerge-validate-difference)
2109   (let* ((diff-vector
2110           (aref emerge-difference-list emerge-current-difference))
2111          (merge-begin (1+ (aref diff-vector 4)))
2112          (merge-end (1- (aref diff-vector 5))))
2113     (if (not arg)
2114         (progn
2115           (goto-char merge-begin)
2116           (set-mark merge-end))
2117       (goto-char merge-end)
2118       (set-mark merge-begin))))
2119
2120 (defun emerge-file-names ()
2121   "Show the names of the buffers or files being operated on by Emerge.
2122 Use C-u l to reset the windows afterward."
2123   (interactive)
2124   (delete-other-windows)
2125   (let ((temp-buffer-show-function
2126          (function (lambda (buf)
2127                      (split-window-vertically)
2128                      (switch-to-buffer buf)
2129                      (other-window 1)))))
2130     (with-output-to-temp-buffer "*Help*"
2131       (emerge-eval-in-buffer emerge-A-buffer
2132                              (if buffer-file-name
2133                                  (progn
2134                                    (princ "File A is: ")
2135                                    (princ buffer-file-name))
2136                                (progn
2137                                  (princ "Buffer A is: ")
2138                                  (princ (buffer-name))))
2139                              (princ "\n"))
2140       (emerge-eval-in-buffer emerge-B-buffer
2141                              (if buffer-file-name
2142                                  (progn
2143                                    (princ "File B is: ")
2144                                    (princ buffer-file-name))
2145                                (progn
2146                                  (princ "Buffer B is: ")
2147                                  (princ (buffer-name))))
2148                              (princ "\n"))
2149       (if emerge-ancestor-buffer
2150             (emerge-eval-in-buffer emerge-ancestor-buffer
2151                                    (if buffer-file-name
2152                                        (progn
2153                                          (princ "Ancestor file is: ")
2154                                          (princ buffer-file-name))
2155                                      (progn
2156                                        (princ "Ancestor buffer is: ")
2157                                        (princ (buffer-name))))
2158                                    (princ "\n")))
2159       (princ emerge-output-description))))
2160
2161 (defun emerge-join-differences (arg)
2162   "Join the selected difference with the following one.
2163 With a prefix argument, join with the preceding one."
2164   (interactive "P")
2165   (let ((n emerge-current-difference))
2166     ;; adjust n to be first difference to join
2167     (if arg
2168         (setq n (1- n)))
2169     ;; n and n+1 are the differences to join
2170     ;; check that they are both differences
2171     (if (or (< n 0) (>= n (1- emerge-number-of-differences)))
2172         (error "Incorrect differences to join"))
2173     ;; remove the flags
2174     (emerge-unselect-difference emerge-current-difference)
2175     ;; decrement total number of differences
2176     (setq emerge-number-of-differences (1- emerge-number-of-differences))
2177     ;; build new differences vector
2178     (let ((i 0)
2179           (new-differences (make-vector emerge-number-of-differences nil)))
2180       (while (< i emerge-number-of-differences)
2181         (aset new-differences i
2182               (cond
2183                ((< i n) (aref emerge-difference-list i))
2184                ((> i n) (aref emerge-difference-list (1+ i)))
2185                (t (let ((prev (aref emerge-difference-list i))
2186                         (next (aref emerge-difference-list (1+ i))))
2187                     (vector (aref prev 0)
2188                             (aref next 1)
2189                             (aref prev 2)
2190                             (aref next 3)
2191                             (aref prev 4)
2192                             (aref next 5)
2193                             (let ((ps (aref prev 6))
2194                                   (ns (aref next 6)))
2195                               (cond
2196                                ((eq ps ns)
2197                                 ps)
2198                                ((and (or (eq ps 'B) (eq ps 'prefer-B))
2199                                      (or (eq ns 'B) (eq ns 'prefer-B)))
2200                                 'B)
2201                                (t 'A))))))))
2202         (setq i (1+ i)))
2203       (setq emerge-difference-list new-differences))
2204     ;; set the current difference correctly
2205     (setq emerge-current-difference n)
2206     ;; fix the mode line
2207     (emerge-refresh-mode-line)
2208     ;; reinsert the flags
2209     (emerge-select-difference emerge-current-difference)
2210     (emerge-recenter)))
2211
2212 (defun emerge-split-difference ()
2213   "Split the current difference where the points are in the three windows."
2214   (interactive)
2215   (let ((n emerge-current-difference))
2216     ;; check that this is a valid difference
2217     (emerge-validate-difference)
2218     ;; get the point values and old difference
2219     (let ((A-point (emerge-eval-in-buffer emerge-A-buffer
2220                                           (point-marker)))
2221           (B-point (emerge-eval-in-buffer emerge-B-buffer
2222                                           (point-marker)))
2223           (merge-point (point-marker))
2224           (old-diff (aref emerge-difference-list n)))
2225       ;; check location of the points, give error if they aren't in the
2226       ;; differences
2227       (if (or (< A-point (aref old-diff 0))
2228               (> A-point (aref old-diff 1)))
2229           (error "Point outside of difference in A buffer"))
2230       (if (or (< B-point (aref old-diff 2))
2231               (> B-point (aref old-diff 3)))
2232           (error "Point outside of difference in B buffer"))
2233       (if (or (< merge-point (aref old-diff 4))
2234               (> merge-point (aref old-diff 5)))
2235           (error "Point outside of difference in merge buffer"))
2236       ;; remove the flags
2237       (emerge-unselect-difference emerge-current-difference)
2238       ;; increment total number of differences
2239       (setq emerge-number-of-differences (1+ emerge-number-of-differences))
2240       ;; build new differences vector
2241       (let ((i 0)
2242             (new-differences (make-vector emerge-number-of-differences nil)))
2243         (while (< i emerge-number-of-differences)
2244           (aset new-differences i
2245                 (cond
2246                  ((< i n)
2247                   (aref emerge-difference-list i))
2248                  ((> i (1+ n))
2249                   (aref emerge-difference-list (1- i)))
2250                  ((= i n)
2251                   (vector (aref old-diff 0)
2252                           A-point
2253                           (aref old-diff 2)
2254                           B-point
2255                           (aref old-diff 4)
2256                           merge-point
2257                           (aref old-diff 6)))
2258                  (t
2259                   (vector (copy-marker A-point)
2260                           (aref old-diff 1)
2261                           (copy-marker B-point)
2262                           (aref old-diff 3)
2263                           (copy-marker merge-point)
2264                           (aref old-diff 5)
2265                           (aref old-diff 6)))))
2266           (setq i (1+ i)))
2267         (setq emerge-difference-list new-differences))
2268       ;; set the current difference correctly
2269       (setq emerge-current-difference n)
2270       ;; fix the mode line
2271       (emerge-refresh-mode-line)
2272       ;; reinsert the flags
2273       (emerge-select-difference emerge-current-difference)
2274       (emerge-recenter))))
2275
2276 (defun emerge-trim-difference ()
2277   "Trim lines off top and bottom of difference that are the same.
2278 If lines are the same in both the A and the B versions, strip them off.
2279 \(This can happen when the A and B versions have common lines that the
2280 ancestor version does not share.)"
2281   (interactive)
2282   ;; make sure we are in a real difference
2283   (emerge-validate-difference)
2284   ;; remove the flags
2285   (emerge-unselect-difference emerge-current-difference)
2286   (let* ((diff (aref emerge-difference-list emerge-current-difference))
2287          (top-a (marker-position (aref diff 0)))
2288          (bottom-a (marker-position (aref diff 1)))
2289          (top-b (marker-position (aref diff 2)))
2290          (bottom-b (marker-position (aref diff 3)))
2291          (top-m (marker-position (aref diff 4)))
2292          (bottom-m (marker-position (aref diff 5)))
2293          size success sa sb sm)
2294     ;; move down the tops of the difference regions as much as possible
2295     ;; Try advancing comparing 1000 chars at a time.
2296     ;; When that fails, go 500 chars at a time, and so on.
2297     (setq size 1000)
2298     (while (> size 0)
2299       (setq success t)
2300       (while success
2301         (setq size (min size (- bottom-a top-a) (- bottom-b top-b)
2302                         (- bottom-m top-m)))
2303         (setq sa (emerge-eval-in-buffer emerge-A-buffer
2304                                         (buffer-substring top-a
2305                                                           (+ size top-a))))
2306         (setq sb (emerge-eval-in-buffer emerge-B-buffer
2307                                         (buffer-substring top-b
2308                                                           (+ size top-b))))
2309         (setq sm (buffer-substring top-m (+ size top-m)))
2310         (setq success (and (> size 0) (equal sa sb) (equal sb sm)))
2311         (if success
2312             (setq top-a (+ top-a size)
2313                   top-b (+ top-b size)
2314                   top-m (+ top-m size))))
2315       (setq size (/ size 2)))
2316     ;; move up the bottoms of the difference regions as much as possible
2317     ;; Try advancing comparing 1000 chars at a time.
2318     ;; When that fails, go 500 chars at a time, and so on.
2319     (setq size 1000)
2320     (while (> size 0)
2321       (setq success t)
2322       (while success
2323         (setq size (min size (- bottom-a top-a) (- bottom-b top-b)
2324                         (- bottom-m top-m)))
2325         (setq sa (emerge-eval-in-buffer emerge-A-buffer
2326                                         (buffer-substring (- bottom-a size)
2327                                                           bottom-a)))
2328         (setq sb (emerge-eval-in-buffer emerge-B-buffer
2329                                         (buffer-substring (- bottom-b size)
2330                                                           bottom-b)))
2331         (setq sm (buffer-substring (- bottom-m size) bottom-m))
2332         (setq success (and (> size 0) (equal sa sb) (equal sb sm)))
2333         (if success
2334             (setq bottom-a (- bottom-a size)
2335                   bottom-b (- bottom-b size)
2336                   bottom-m (- bottom-m size))))
2337       (setq size (/ size 2)))
2338     ;; {top,bottom}-{a,b,m} are now set at the new beginnings and ends
2339     ;; of the difference regions.  Move them to the beginning of lines, as
2340     ;; appropriate.
2341     (emerge-eval-in-buffer emerge-A-buffer
2342                            (goto-char top-a)
2343                            (beginning-of-line)
2344                            (aset diff 0 (point-marker))
2345                            (goto-char bottom-a)
2346                            (beginning-of-line 2)
2347                            (aset diff 1 (point-marker)))
2348     (emerge-eval-in-buffer emerge-B-buffer
2349                            (goto-char top-b)
2350                            (beginning-of-line)
2351                            (aset diff 2 (point-marker))
2352                            (goto-char bottom-b)
2353                            (beginning-of-line 2)
2354                            (aset diff 3 (point-marker)))
2355     (goto-char top-m)
2356     (beginning-of-line)
2357     (aset diff 4 (point-marker))
2358     (goto-char bottom-m)
2359     (beginning-of-line 2)
2360     (aset diff 5 (point-marker))
2361     ;; put the flags back in, recenter the display
2362     (emerge-select-difference emerge-current-difference)
2363     (emerge-recenter)))
2364
2365 (defun emerge-find-difference (arg)
2366   "Find the difference containing the current position of the point.
2367 If there is no containing difference and the prefix argument is positive,
2368 it finds the nearest following difference.  A negative prefix argument finds
2369 the nearest previous difference."
2370   (interactive "P")
2371   (cond ((eq (current-buffer) emerge-A-buffer)
2372          (emerge-find-difference-A arg))
2373         ((eq (current-buffer) emerge-B-buffer)
2374          (emerge-find-difference-B arg))
2375         (t (emerge-find-difference-merge arg))))
2376
2377 (defun emerge-find-difference-merge (arg)
2378   "Find the difference containing point, in the merge buffer.
2379 If there is no containing difference and the prefix argument is positive,
2380 it finds the nearest following difference.  A negative prefix argument finds
2381 the nearest previous difference."
2382   (interactive "P")
2383   ;; search for the point in the merge buffer, using the markers
2384   ;; for the beginning and end of the differences in the merge buffer
2385   (emerge-find-difference1 arg (point) 4 5))
2386
2387 (defun emerge-find-difference-A (arg)
2388   "Find the difference containing point, in the A buffer.
2389 This command must be executed in the merge buffer.
2390 If there is no containing difference and the prefix argument is positive,
2391 it finds the nearest following difference.  A negative prefix argument finds
2392 the nearest previous difference."
2393   (interactive "P")
2394   ;; search for the point in the A buffer, using the markers
2395   ;; for the beginning and end of the differences in the A buffer
2396   (emerge-find-difference1 arg
2397                            (emerge-eval-in-buffer emerge-A-buffer (point))
2398                            0 1))
2399
2400 (defun emerge-find-difference-B (arg)
2401   "Find the difference containing point, in the B buffer.
2402 This command must be executed in the merge buffer.
2403 If there is no containing difference and the prefix argument is positive,
2404 it finds the nearest following difference.  A negative prefix argument finds
2405 the nearest previous difference."
2406   (interactive "P")
2407   ;; search for the point in the B buffer, using the markers
2408   ;; for the beginning and end of the differences in the B buffer
2409   (emerge-find-difference1 arg
2410                            (emerge-eval-in-buffer emerge-B-buffer (point))
2411                            2 3))
2412
2413 (defun emerge-find-difference1 (arg location begin end)
2414   (let* ((index
2415           ;; find first difference containing or after the current position
2416           (catch 'search
2417             (let ((n 0))
2418               (while (< n emerge-number-of-differences)
2419                 (let ((diff-vector (aref emerge-difference-list n)))
2420                   (if (<= location (marker-position (aref diff-vector end)))
2421                       (throw 'search n)))
2422                 (setq n (1+ n))))
2423             emerge-number-of-differences))
2424          (contains
2425           ;; whether the found difference contains the current position
2426           (and (< index emerge-number-of-differences)
2427                (<= (marker-position (aref (aref emerge-difference-list index)
2428                                           begin))
2429                    location)))
2430          (arg-value
2431           ;; numeric value of prefix argument
2432           (prefix-numeric-value arg)))
2433     (emerge-unselect-and-select-difference
2434      (cond
2435       ;; if the point is in a difference, select it
2436       (contains index)
2437       ;; if the arg is nil and the point is not in a difference, error
2438       ((null arg) (error "No difference contains point"))
2439       ;; if the arg is positive, select the following difference
2440       ((> arg-value 0)
2441        (if (< index emerge-number-of-differences)
2442            index
2443          (error "No difference contains or follows point")))
2444       ;; if the arg is negative, select the preceding difference
2445       (t
2446        (if (> index 0)
2447            (1- index)
2448          (error "No difference contains or precedes point")))))))
2449
2450 (defun emerge-line-numbers ()
2451   "Display the current line numbers.
2452 This function displays the line numbers of the points in the A, B, and
2453 merge buffers."
2454   (interactive)
2455   (let* ((valid-diff
2456          (and (>= emerge-current-difference 0)
2457               (< emerge-current-difference emerge-number-of-differences)))
2458         (diff (and valid-diff
2459                    (aref emerge-difference-list emerge-current-difference)))
2460         (merge-line (emerge-line-number-in-buf 4 5))
2461         (A-line (emerge-eval-in-buffer emerge-A-buffer
2462                                        (emerge-line-number-in-buf 0 1)))
2463         (B-line (emerge-eval-in-buffer emerge-B-buffer
2464                                        (emerge-line-number-in-buf 2 3))))
2465     (message "At lines: merge = %d, A = %d, B = %d"
2466              merge-line A-line B-line)))
2467
2468 (defun emerge-line-number-in-buf (begin-marker end-marker)
2469   (let (temp)
2470     (setq temp (save-excursion
2471                  (beginning-of-line)
2472                  (1+ (count-lines 1 (point)))))
2473     (if valid-diff
2474         (progn
2475           (if (> (point) (aref diff begin-marker))
2476               (setq temp (- temp emerge-before-flag-lines)))
2477           (if (> (point) (aref diff end-marker))
2478               (setq temp (- temp emerge-after-flag-lines)))))
2479     temp))
2480
2481 (defun emerge-set-combine-template (string &optional localize)
2482   "Set `emerge-combine-versions-template' to STRING.
2483 This value controls how `emerge-combine-versions' combines the two versions.
2484 With prefix argument, `emerge-combine-versions-template' is made local to this
2485 merge buffer.  Localization is permanent for any particular merge buffer."
2486   (interactive "s\nP")
2487   (if localize
2488       (make-local-variable 'emerge-combine-versions-template))
2489   (setq emerge-combine-versions-template string)
2490   (message
2491    (if (assq 'emerge-combine-versions-template (buffer-local-variables))
2492        "emerge-set-combine-versions-template set locally"
2493      "emerge-set-combine-versions-template set")))
2494
2495 (defun emerge-set-combine-versions-template (start end &optional localize)
2496   "Copy region into `emerge-combine-versions-template'.
2497 This controls how `emerge-combine-versions' will combine the two versions.
2498 With prefix argument, `emerge-combine-versions-template' is made local to this
2499 merge buffer.  Localization is permanent for any particular merge buffer."
2500   (interactive "r\nP")
2501   (if localize
2502       (make-local-variable 'emerge-combine-versions-template))
2503   (setq emerge-combine-versions-template (buffer-substring start end))
2504   (message
2505    (if (assq 'emerge-combine-versions-template (buffer-local-variables))
2506        "emerge-set-combine-versions-template set locally."
2507      "emerge-set-combine-versions-template set.")))
2508
2509 (defun emerge-combine-versions (&optional force)
2510   "Combine versions using the template in `emerge-combine-versions-template'.
2511 Refuses to function if this difference has been edited, i.e., if it is
2512 neither the A nor the B variant.
2513 An argument forces the variant to be selected even if the difference has
2514 been edited."
2515   (interactive "P")
2516   (emerge-combine-versions-internal emerge-combine-versions-template force))
2517
2518 (defun emerge-combine-versions-register (char &optional force)
2519   "Combine the two versions using the template in register REG.
2520 See documentation of the variable `emerge-combine-versions-template'
2521 for how the template is interpreted.
2522 Refuses to function if this difference has been edited, i.e., if it is
2523 neither the A nor the B variant.
2524 An argument forces the variant to be selected even if the difference has
2525 been edited."
2526   (interactive "cRegister containing template: \nP")
2527   (let ((template (get-register char)))
2528     (if (not (stringp template))
2529         (error "Register does not contain text"))
2530     (emerge-combine-versions-internal template force)))
2531
2532 (defun emerge-combine-versions-internal (template force)
2533   (let ((operate
2534          (function (lambda ()
2535                      (emerge-combine-versions-edit merge-begin merge-end
2536                                                    A-begin A-end B-begin B-end)
2537                      (if emerge-auto-advance
2538                          (emerge-next-difference))))))
2539     (emerge-select-version force operate operate operate)))
2540
2541 (defun emerge-combine-versions-edit (merge-begin merge-end
2542                                      A-begin A-end B-begin B-end)
2543   (emerge-eval-in-buffer
2544    emerge-merge-buffer
2545    (delete-region merge-begin merge-end)
2546    (goto-char merge-begin)
2547    (let ((i 0))
2548      (while (< i (length template))
2549        (let ((c (aref template i)))
2550          (if (= c ?%)
2551              (progn
2552                (setq i (1+ i))
2553                (setq c
2554                      (condition-case nil
2555                          (aref template i)
2556                        (error ?%)))
2557                (cond ((= c ?a)
2558                       (insert-buffer-substring emerge-A-buffer A-begin A-end))
2559                      ((= c ?b)
2560                       (insert-buffer-substring emerge-B-buffer B-begin B-end))
2561                      ((= c ?%)
2562                       (insert ?%))
2563                      (t
2564                       (insert c))))
2565            (insert c)))
2566        (setq i (1+ i))))
2567    (goto-char merge-begin)
2568    (aset diff-vector 6 'combined)
2569    (emerge-refresh-mode-line)))
2570
2571 (defun emerge-set-merge-mode (mode)
2572   "Set the major mode in a merge buffer.
2573 Overrides any change that the mode might make to the mode line or local
2574 keymap.  Leaves merge in fast mode."
2575   (interactive
2576    (list (intern (completing-read "New major mode for merge buffer: "
2577                                   obarray 'commandp t nil))))
2578   (funcall mode)
2579   (emerge-refresh-mode-line)
2580   (if emerge-fast-mode
2581       (emerge-fast-mode)
2582     (emerge-edit-mode)))
2583
2584 (defun emerge-one-line-window ()
2585   (interactive)
2586   (let ((window-min-height 1))
2587     (shrink-window (- (window-height) 2))))
2588
2589 ;;; Support routines
2590
2591 ;; Select a difference by placing the visual flags around the appropriate
2592 ;; group of lines in the A, B, and merge buffers
2593 (defun emerge-select-difference (n)
2594   (let ((emerge-globalized-difference-list emerge-difference-list)
2595         (emerge-globalized-number-of-differences emerge-number-of-differences))
2596     (emerge-place-flags-in-buffer emerge-A-buffer n 0 1)
2597     (emerge-place-flags-in-buffer emerge-B-buffer n 2 3)
2598     (emerge-place-flags-in-buffer nil n 4 5))
2599   (run-hooks 'emerge-select-hook))
2600
2601 (defun emerge-place-flags-in-buffer (buffer difference before-index
2602                                             after-index)
2603   (if buffer
2604       (emerge-eval-in-buffer
2605        buffer
2606        (emerge-place-flags-in-buffer1 difference before-index after-index))
2607     (emerge-place-flags-in-buffer1 difference before-index after-index)))
2608
2609 (defun emerge-place-flags-in-buffer1 (difference before-index after-index)
2610   (let ((buffer-read-only nil))
2611     ;; insert the flag before the difference
2612     (let ((before (aref (aref emerge-globalized-difference-list difference)
2613                         before-index))
2614           here)
2615       (goto-char before)
2616       ;; insert the flag itself
2617       (insert-before-markers emerge-before-flag)
2618       (setq here (point))
2619       ;; Put the marker(s) referring to this position 1 character before the
2620       ;; end of the flag, so it won't be damaged by the user.
2621       ;; This gets a bit tricky, as there could be a number of markers
2622       ;; that have to be moved.
2623       (set-marker before (1- before))
2624       (let ((n (1- difference)) after-marker before-marker diff-list)
2625         (while (and
2626                 (>= n 0)
2627                 (progn
2628                   (setq diff-list (aref emerge-globalized-difference-list n)
2629                         after-marker (aref diff-list after-index))
2630                   (= after-marker here)))
2631           (set-marker after-marker (1- after-marker))
2632           (setq before-marker (aref diff-list before-index))
2633           (if (= before-marker here)
2634               (setq before-marker (1- before-marker)))
2635           (setq n (1- n)))))
2636     ;; insert the flag after the difference
2637     (let* ((after (aref (aref emerge-globalized-difference-list difference)
2638                         after-index))
2639            (here (marker-position after)))
2640       (goto-char here)
2641       ;; insert the flag itself
2642       (insert emerge-after-flag)
2643       ;; Put the marker(s) referring to this position 1 character after the
2644       ;; beginning of the flag, so it won't be damaged by the user.
2645       ;; This gets a bit tricky, as there could be a number of markers
2646       ;; that have to be moved.
2647       (set-marker after (1+ after))
2648       (let ((n (1+ difference)) before-marker after-marker diff-list)
2649         (while (and
2650                 (< n emerge-globalized-number-of-differences)
2651                 (progn
2652                   (setq diff-list (aref emerge-globalized-difference-list n)
2653                         before-marker (aref diff-list before-index))
2654                   (= before-marker here)))
2655           (set-marker before-marker (1+ before-marker))
2656           (setq after-marker (aref diff-list after-index))
2657           (if (= after-marker here)
2658               (setq after-marker (1+ after-marker)))
2659           (setq n (1+ n)))))))
2660
2661 ;; Unselect a difference by removing the visual flags in the buffers.
2662 (defun emerge-unselect-difference (n)
2663   (let ((diff-vector (aref emerge-difference-list n)))
2664     (emerge-remove-flags-in-buffer emerge-A-buffer
2665                                    (aref diff-vector 0) (aref diff-vector 1))
2666     (emerge-remove-flags-in-buffer emerge-B-buffer
2667                                    (aref diff-vector 2) (aref diff-vector 3))
2668     (emerge-remove-flags-in-buffer emerge-merge-buffer
2669                                    (aref diff-vector 4) (aref diff-vector 5)))
2670   (run-hooks 'emerge-unselect-hook))
2671
2672 (defun emerge-remove-flags-in-buffer (buffer before after)
2673   (emerge-eval-in-buffer
2674    buffer
2675    (let ((buffer-read-only nil))
2676      ;; remove the flags, if they're there
2677      (goto-char (- before (1- emerge-before-flag-length)))
2678      (if (looking-at emerge-before-flag-match)
2679          (delete-char emerge-before-flag-length)
2680        ;; the flag isn't there
2681        (ding)
2682        (message "Trouble removing flag"))
2683      (goto-char (1- after))
2684      (if (looking-at emerge-after-flag-match)
2685          (delete-char emerge-after-flag-length)
2686        ;; the flag isn't there
2687        (ding)
2688        (message "Trouble removing flag")))))
2689
2690 ;; Select a difference, removing any flags that exist now.
2691 (defun emerge-unselect-and-select-difference (n &optional suppress-display)
2692   (if (and (>= emerge-current-difference 0)
2693            (< emerge-current-difference emerge-number-of-differences))
2694       (emerge-unselect-difference emerge-current-difference))
2695   (if (and (>= n 0) (< n emerge-number-of-differences))
2696       (progn
2697         (emerge-select-difference n)
2698         (let* ((diff-vector (aref emerge-difference-list n))
2699                (selection-type (aref diff-vector 6)))
2700           (if (eq selection-type 'default-A)
2701               (aset diff-vector 6 'A)
2702             (if (eq selection-type 'default-B)
2703                 (aset diff-vector 6 'B))))))
2704   (setq emerge-current-difference n)
2705   (if (not suppress-display)
2706       (progn
2707         (emerge-recenter)
2708         (emerge-refresh-mode-line))))
2709
2710 ;; Perform tests to see whether user should be allowed to select a version
2711 ;; of this difference:
2712 ;;   a valid difference has been selected; and
2713 ;;   the difference text in the merge buffer is:
2714 ;;     the A version (execute a-version), or
2715 ;;     the B version (execute b-version), or
2716 ;;     empty (execute neither-version), or
2717 ;;     argument FORCE is true (execute neither-version)
2718 ;; Otherwise, signal an error.
2719 (defun emerge-select-version (force a-version b-version neither-version)
2720   (emerge-validate-difference)
2721   (let ((buffer-read-only nil))
2722     (let* ((diff-vector
2723             (aref emerge-difference-list emerge-current-difference))
2724            (A-begin (1+ (aref diff-vector 0)))
2725            (A-end (1- (aref diff-vector 1)))
2726            (B-begin (1+ (aref diff-vector 2)))
2727            (B-end (1- (aref diff-vector 3)))
2728            (merge-begin (1+ (aref diff-vector 4)))
2729            (merge-end (1- (aref diff-vector 5))))
2730       (if (emerge-compare-buffers emerge-A-buffer A-begin A-end
2731                                   emerge-merge-buffer merge-begin
2732                                   merge-end)
2733           (funcall a-version)
2734         (if (emerge-compare-buffers emerge-B-buffer B-begin B-end
2735                                     emerge-merge-buffer merge-begin
2736                                     merge-end)
2737             (funcall b-version)
2738           (if (or force (= merge-begin merge-end))
2739               (funcall neither-version)
2740             (error "This difference region has been edited")))))))
2741
2742 ;; Read a file name, handling all of the various defaulting rules.
2743
2744 (defun emerge-read-file-name (prompt alternative-default-dir default-file
2745                               A-file)
2746   ;; `prompt' should not have trailing ": ", so that it can be modified
2747   ;; according to context.
2748   ;; If alternative-default-dir is non-nil, it should be used as the default
2749   ;; directory instead if default-directory, if emerge-default-last-directories
2750   ;; is set.
2751   ;; If default-file is set, it should be used as the default value.
2752   ;; If A-file is set, and its directory is different from
2753   ;; alternative-default-dir, and if emerge-default-last-directories is set,
2754   ;; the default file should be the last part of A-file in the default
2755   ;; directory.  (Overriding default-file.)
2756   (cond
2757    ;; If this is not the A-file argument (shown by non-nil A-file), and
2758    ;; if emerge-default-last-directories is set, and
2759    ;; the default directory exists but is not the same as the directory of the
2760    ;; A-file,
2761    ;; then make the default file have the same name as the A-file, but in
2762    ;; the default directory.
2763    ((and emerge-default-last-directories
2764          A-file
2765          alternative-default-dir
2766          (not (string-equal alternative-default-dir
2767                             (file-name-directory A-file))))
2768     (read-file-name (format "%s (default %s): "
2769                             prompt (file-name-nondirectory A-file))
2770                     alternative-default-dir
2771                     (concat alternative-default-dir
2772                             (file-name-nondirectory A-file))
2773                     'confirm))
2774    ;; If there is a default file, use it.
2775    (default-file
2776      (read-file-name (format "%s (default %s): " prompt default-file)
2777                      ;; If emerge-default-last-directories is set, use the
2778                      ;; directory from the same argument of the last call of
2779                      ;; Emerge as the default for this argument.
2780                      (and emerge-default-last-directories
2781                           alternative-default-dir)
2782                      default-file 'confirm))
2783    (t
2784     (read-file-name (concat prompt ": ")
2785                     ;; If emerge-default-last-directories is set, use the
2786                     ;; directory from the same argument of the last call of
2787                     ;; Emerge as the default for this argument.
2788                     (and emerge-default-last-directories
2789                          alternative-default-dir)
2790                     nil 'confirm))))
2791
2792 ;; Revise the mode line to display which difference we have selected
2793
2794 (defun emerge-refresh-mode-line ()
2795   (setq mode-line-buffer-identification
2796         (list (format "Emerge: %%b   diff %d of %d%s"
2797                       (1+ emerge-current-difference)
2798                       emerge-number-of-differences
2799                       (if (and (>= emerge-current-difference 0)
2800                                (< emerge-current-difference
2801                                   emerge-number-of-differences))
2802                           (cdr (assq (aref (aref emerge-difference-list
2803                                                  emerge-current-difference)
2804                                            6)
2805                                      '((A . " - A")
2806                                        (B . " - B")
2807                                        (prefer-A . " - A*")
2808                                        (prefer-B . " - B*")
2809                                        (combined . " - comb"))))
2810                         ""))))
2811   ;; Force mode-line redisplay
2812   (set-buffer-modified-p (buffer-modified-p)))
2813
2814 ;; compare two regions in two buffers for containing the same text
2815 (defun emerge-compare-buffers (buffer-x x-begin x-end buffer-y y-begin y-end)
2816   ;; first check that the two regions are the same length
2817   (if (not (and (= (- x-end x-begin) (- y-end y-begin))))
2818       nil
2819     (catch 'exit
2820       (while (< x-begin x-end)
2821         ;; bite off and compare no more than 1000 characters at a time
2822         (let* ((compare-length (min (- x-end x-begin) 1000))
2823                (x-string (emerge-eval-in-buffer
2824                           buffer-x
2825                           (buffer-substring x-begin
2826                                             (+ x-begin compare-length))))
2827                (y-string (emerge-eval-in-buffer
2828                           buffer-y
2829                           (buffer-substring y-begin
2830                                             (+ y-begin compare-length)))))
2831           (if (not (string-equal x-string y-string))
2832               (throw 'exit nil)
2833             (setq x-begin (+ x-begin compare-length))
2834             (setq y-begin (+ y-begin compare-length)))))
2835       t)))
2836
2837 ;; Construct a unique buffer name.
2838 ;; The first one tried is prefixsuffix, then prefix<2>suffix,
2839 ;; prefix<3>suffix, etc.
2840 (defun emerge-unique-buffer-name (prefix suffix)
2841   (if (null (get-buffer (concat prefix suffix)))
2842       (concat prefix suffix)
2843     (let ((n 2))
2844       (while (get-buffer (format "%s<%d>%s" prefix n suffix))
2845         (setq n (1+ n)))
2846       (format "%s<%d>%s" prefix n suffix))))
2847
2848 ;; Verify that we have a difference selected.
2849 (defun emerge-validate-difference ()
2850   (if (not (and (>= emerge-current-difference 0)
2851                 (< emerge-current-difference emerge-number-of-differences)))
2852       (error "No difference selected")))
2853
2854 ;;; Functions for saving and restoring a batch of variables
2855
2856 ;; These functions save (get the values of) and restore (set the values of)
2857 ;; a list of variables.  The argument is a list of symbols (the names of
2858 ;; the variables).  A list element can also be a list of two functions,
2859 ;; the first of which (when called with no arguments) gets the value, and
2860 ;; the second (when called with a value as an argment) sets the value.
2861 ;; A "function" is anything that funcall can handle as an argument.
2862
2863 (defun emerge-save-variables (vars)
2864   (mapcar (function (lambda (v) (if (symbolp v)
2865                                     (symbol-value v)
2866                                   (funcall (car v)))))
2867           vars))
2868
2869 (defun emerge-restore-variables (vars values)
2870   (while vars
2871     (let ((var (car vars))
2872           (value (car values)))
2873       (if (symbolp var)
2874           (set var value)
2875         (funcall (car (cdr var)) value)))
2876     (setq vars (cdr vars))
2877     (setq values (cdr values))))
2878
2879 ;; Make a temporary file that only we have access to.
2880 ;; PREFIX is appended to emerge-temp-file-prefix to make the filename prefix.
2881 (defun emerge-make-temp-file (prefix)
2882   (let ((f (make-temp-name (concat emerge-temp-file-prefix prefix))))
2883     ;; create the file
2884     (write-region (point-min) (point-min) f nil 'no-message)
2885     (set-file-modes f emerge-temp-file-mode)
2886     f))
2887
2888 ;;; Functions that query the user before he can write out the current buffer.
2889
2890 (defun emerge-query-write-file ()
2891   "Ask the user whether to write out an incomplete merge.
2892 If answer is yes, call `write-file' to do so.  See `emerge-query-and-call'
2893 for details of the querying process."
2894   (interactive)
2895   (emerge-query-and-call 'write-file))
2896
2897 (defun emerge-query-save-buffer ()
2898   "Ask the user whether to save an incomplete merge.
2899 If answer is yes, call `save-buffer' to do so.  See `emerge-query-and-call'
2900 for details of the querying process."
2901   (interactive)
2902   (emerge-query-and-call 'save-buffer))
2903
2904 (defun emerge-query-and-call (command)
2905   "Ask the user whether to save or write out the incomplete merge.
2906 If answer is yes, call COMMAND interactively.  During the call, the flags
2907 around the current difference are removed."
2908   (if (yes-or-no-p "Do you really write to write out this unfinished merge? ")
2909       ;; He really wants to do it -- unselect the difference for the duration
2910       (progn
2911         (if (and (>= emerge-current-difference 0)
2912                  (< emerge-current-difference emerge-number-of-differences))
2913             (emerge-unselect-difference emerge-current-difference))
2914         ;; call-interactively takes the value of current-prefix-arg as the
2915         ;; prefix argument value to be passed to the command.  Thus, we have
2916         ;; to do nothing special to make sure the prefix argument is
2917         ;; transmitted to the command.
2918         (call-interactively command)
2919         (if (and (>= emerge-current-difference 0)
2920                  (< emerge-current-difference emerge-number-of-differences))
2921             (progn
2922               (emerge-select-difference emerge-current-difference)
2923               (emerge-recenter))))
2924     ;; He's being smart and not doing it
2925     (message "Not written")))
2926
2927 ;; Make sure the current buffer (for a file) has the same contents as the
2928 ;; file on disk, and attempt to remedy the situation if not.
2929 ;; Signal an error if we can't make them the same, or the user doesn't want
2930 ;; to do what is necessary to make them the same.
2931 (defun emerge-verify-file-buffer ()
2932   ;; First check if the file has been modified since the buffer visited it.
2933   (if (verify-visited-file-modtime (current-buffer))
2934       (if (buffer-modified-p)
2935           ;; If buffer is not obsolete and is modified, offer to save
2936           (if (yes-or-no-p (format "Save file %s? " buffer-file-name))
2937               (save-buffer)
2938             (error "Buffer out of sync for file %s" buffer-file-name))
2939         ;; If buffer is not obsolete and is not modified, do nothing
2940         nil)
2941     (if (buffer-modified-p)
2942         ;; If buffer is obsolete and is modified, give error
2943         (error "Buffer out of sync for file %s" buffer-file-name)
2944       ;; If buffer is obsolete and is not modified, offer to revert
2945       (if (yes-or-no-p (format "Revert file %s? " buffer-file-name))
2946               (revert-buffer t t)
2947         (error "Buffer out of sync for file %s" buffer-file-name)))))
2948 \f
2949 ;; Utilities that might have value outside of Emerge.
2950
2951 ;; Set up the mode in the current buffer to duplicate the mode in another
2952 ;; buffer.
2953 (defun emerge-copy-modes (buffer)
2954   ;; Set the major mode
2955   (funcall (emerge-eval-in-buffer buffer major-mode)))
2956
2957 ;; Define a key, even if a prefix of it is defined
2958 (defun emerge-force-define-key (keymap key definition)
2959   "Like `define-key', but forcibly creates prefix characters as needed.
2960 If some prefix of KEY has a non-prefix definition, it is redefined."
2961   ;; Find out if a prefix of key is defined
2962   (let ((v (lookup-key keymap key)))
2963     ;; If so, undefine it
2964     (if (integerp v)
2965         (define-key keymap (substring key 0 v) nil)))
2966   ;; Now define the key
2967   (define-key keymap key definition))
2968
2969 ;;;;; Improvements to describe-mode, so that it describes minor modes as well
2970 ;;;;; as the major mode
2971 ;;(defun describe-mode (&optional minor)
2972 ;;  "Display documentation of current major mode.
2973 ;;If optional arg MINOR is non-nil (or prefix argument is given if interactive),
2974 ;;display documentation of active minor modes as well.
2975 ;;For this to work correctly for a minor mode, the mode's indicator variable
2976 ;;\(listed in `minor-mode-alist') must also be a function whose documentation
2977 ;;describes the minor mode."
2978 ;;  (interactive)
2979 ;;  (with-output-to-temp-buffer "*Help*"
2980 ;;    (princ mode-name)
2981 ;;    (princ " Mode:\n")
2982 ;;    (princ (documentation major-mode))
2983 ;;    (let ((minor-modes minor-mode-alist)
2984 ;;        (locals (buffer-local-variables)))
2985 ;;      (while minor-modes
2986 ;;      (let* ((minor-mode (car (car minor-modes)))
2987 ;;             (indicator (car (cdr (car minor-modes))))
2988 ;;             (local-binding (assq minor-mode locals)))
2989 ;;        ;; Document a minor mode if it is listed in minor-mode-alist,
2990 ;;        ;; bound locally in this buffer, non-nil, and has a function
2991 ;;        ;; definition.
2992 ;;        (if (and local-binding
2993 ;;                 (cdr local-binding)
2994 ;;                 (fboundp minor-mode))
2995 ;;            (progn
2996 ;;              (princ (format "\n\n\n%s minor mode (indicator%s):\n"
2997 ;;                             minor-mode indicator))
2998 ;;              (princ (documentation minor-mode)))))
2999 ;;      (setq minor-modes (cdr minor-modes))))
3000 ;;    (print-help-return-message)))
3001
3002 ;; This goes with the redefinition of describe-mode.
3003 ;;;; Adjust things so that keyboard macro definitions are documented correctly.
3004 ;;(fset 'defining-kbd-macro (symbol-function 'start-kbd-macro))
3005
3006 ;; substitute-key-definition should work now.
3007 ;;;; Function to shadow a definition in a keymap with definitions in another.
3008 ;;(defun emerge-shadow-key-definition (olddef newdef keymap shadowmap)
3009 ;;  "Shadow OLDDEF with NEWDEF for any keys in KEYMAP with entries in SHADOWMAP.
3010 ;;In other words, SHADOWMAP will now shadow all definitions of OLDDEF in KEYMAP
3011 ;;with NEWDEF.  Does not affect keys that are already defined in SHADOWMAP,
3012 ;;including those whose definition is OLDDEF."
3013 ;;  ;; loop through all keymaps accessible from keymap
3014 ;;  (let ((maps (accessible-keymaps keymap)))
3015 ;;    (while maps
3016 ;;      (let ((prefix (car (car maps)))
3017 ;;          (map (cdr (car maps))))
3018 ;;      ;; examine a keymap
3019 ;;      (if (arrayp map)
3020 ;;          ;; array keymap
3021 ;;          (let ((len (length map))
3022 ;;                (i 0))
3023 ;;            (while (< i len)
3024 ;;              (if (eq (aref map i) olddef)
3025 ;;                  ;; set the shadowing definition
3026 ;;                  (let ((key (concat prefix (char-to-string i))))
3027 ;;                    (emerge-define-key-if-possible shadowmap key newdef)))
3028 ;;              (setq i (1+ i))))
3029 ;;        ;; sparse keymap
3030 ;;        (while map
3031 ;;          (if (eq (cdr-safe (car-safe map)) olddef)
3032 ;;              ;; set the shadowing definition
3033 ;;              (let ((key
3034 ;;                     (concat prefix (char-to-string (car (car map))))))
3035 ;;                    (emerge-define-key-if-possible shadowmap key newdef)))
3036 ;;          (setq map (cdr map)))))
3037 ;;      (setq maps (cdr maps)))))
3038
3039 ;; Define a key if it (or a prefix) is not already defined in the map.
3040 (defun emerge-define-key-if-possible (keymap key definition)
3041   ;; look up the present definition of the key
3042   (let ((present (lookup-key keymap key)))
3043     (if (integerp present)
3044         ;; if it is "too long", look up the valid prefix
3045         (if (not (lookup-key keymap (substring key 0 present)))
3046             ;; if the prefix isn't defined, define it
3047             (define-key keymap key definition))
3048       ;; if there is no present definition, define it
3049       (if (not present)
3050           (define-key keymap key definition)))))
3051
3052 ;; Ordinary substitute-key-definition should do this now.
3053 ;;(defun emerge-recursively-substitute-key-definition (olddef newdef keymap)
3054 ;;  "Like `substitute-key-definition', but act recursively on subkeymaps.
3055 ;;Make sure that subordinate keymaps aren't shared with other keymaps!
3056 ;;\(`copy-keymap' will suffice.)"
3057 ;;  ;; Loop through all keymaps accessible from keymap
3058 ;;  (let ((maps (accessible-keymaps keymap)))
3059 ;;    (while maps
3060 ;;      ;; Substitute in this keymap
3061 ;;      (substitute-key-definition olddef newdef (cdr (car maps)))
3062 ;;      (setq maps (cdr maps)))))
3063
3064 ;; Show the name of the file in the buffer.
3065 (defun emerge-show-file-name ()
3066   "Displays the name of the file loaded into the current buffer.
3067 If the name won't fit on one line, the minibuffer is expanded to hold it,
3068 and the command waits for a keystroke from the user.  If the keystroke is
3069 SPC, it is ignored; if it is anything else, it is processed as a command."
3070   (interactive)
3071   (let ((name (buffer-file-name)))
3072     (or name
3073         (setq name "Buffer has no file name."))
3074     (save-window-excursion
3075       (select-window (minibuffer-window))
3076       (erase-buffer)
3077       (insert name)
3078       (if (not (pos-visible-in-window-p))
3079           (let ((echo-keystrokes 0))
3080             (while (and (not (pos-visible-in-window-p))
3081                         (> (1- (screen-height)) (window-height)))
3082               (enlarge-window 1))
3083             (let ((c (read-event)))
3084               (if (not (eq c 32))
3085                   (setq unread-command-events (list c)))))))))
3086
3087 ;; Improved auto-save file names.
3088 ;; This function fixes many problems with the standard auto-save file names:
3089 ;; Auto-save files for non-file buffers get put in the default directory
3090 ;; for the buffer, whether that makes sense or not.
3091 ;; Auto-save files for file buffers get put in the directory of the file,
3092 ;; regardless of whether we can write into it or not.
3093 ;; Auto-save files for non-file buffers don't use the process id, so if a
3094 ;; user runs more than on Emacs, they can make auto-save files that overwrite
3095 ;; each other.
3096 ;; To use this function, do:
3097 ;;      (fset 'make-auto-save-file-name
3098 ;;            (symbol-function 'emerge-make-auto-save-file-name))
3099 (defun emerge-make-auto-save-file-name ()
3100   "Return file name to use for auto-saves of current buffer.
3101 Does not consider `auto-save-visited-file-name';
3102 that is checked before calling this function.
3103 You can redefine this for customization.
3104 See also `auto-save-file-name-p'."
3105   (if buffer-file-name
3106       ;; if buffer has a file, try the format <file directory>/#<file name>#
3107       (let ((f (concat (file-name-directory buffer-file-name)
3108                        "#"
3109                        (file-name-nondirectory buffer-file-name)
3110                        "#")))
3111         (if (file-writable-p f)
3112             ;; the file is writable, so use it
3113             f
3114           ;; the file isn't writable, so use the format
3115           ;; ~/#&<file name>&<hash of directory>#
3116           (concat (getenv "HOME")
3117                   "/#&"
3118                   (file-name-nondirectory buffer-file-name)
3119                   "&"
3120                   (emerge-hash-string-into-string
3121                    (file-name-directory buffer-file-name))
3122                   "#")))
3123     ;; if buffer has no file, use the format ~/#%<buffer name>%<process id>#
3124     (expand-file-name (concat (getenv "HOME")
3125                               "/#%"
3126                               ;; quote / into \! and \ into \\
3127                               (emerge-unslashify-name (buffer-name))
3128                               "%"
3129                               (make-temp-name "")
3130                               "#"))))
3131
3132 ;; Hash a string into five characters more-or-less suitable for use in a file
3133 ;; name.  (Allowed characters are ! through ~, except /.)
3134 (defun emerge-hash-string-into-string (s)
3135   (let ((bins (vector 0 0 0 0 0))
3136         (i 0))
3137     (while (< i (length s))
3138       (aset bins (% i 5) (% (+ (* (aref bins (% i 5)) 35)
3139                                (aref s i))
3140                             65536))
3141       (setq i (1+ i)))
3142     (mapconcat (function (lambda (b)
3143                            (setq b (+ (% b 93) ?!))
3144                            (if (>= b ?/)
3145                                (setq b (1+ b)))
3146                            (char-to-string b)))
3147                bins "")))
3148
3149 ;; Quote any /s in a string by replacing them with \!.
3150 ;; Also, replace any \s by \\, to make it one-to-one.
3151 (defun emerge-unslashify-name (s)
3152   (let ((limit 0))
3153     (while (string-match "[/\\]" s limit)
3154       (setq s (concat (substring s 0 (match-beginning 0))
3155                       (if (string= (substring s (match-beginning 0)
3156                                               (match-end 0))
3157                                    "/")
3158                           "\\!"
3159                         "\\\\")
3160                       (substring s (match-end 0))))
3161       (setq limit (1+ (match-end 0)))))
3162   s)
3163
3164 ;; Metacharacters that have to be protected from the shell when executing
3165 ;; a diff/diff3 command.
3166 (defvar emerge-metachars "[ \t\n!\"#$&'()*;<=>?[\\^`{|~]"
3167   "Characters that must be quoted with \\ when used in a shell command line.
3168 More precisely, a [...] regexp to match any one such character.")
3169
3170 ;; Quote metacharacters (using \) when executing a diff/diff3 command.
3171 (defun emerge-protect-metachars (s)
3172   (let ((limit 0))
3173     (while (string-match emerge-metachars s limit)
3174       (setq s (concat (substring s 0 (match-beginning 0))
3175                       "\\"
3176                       (substring s (match-beginning 0))))
3177       (setq limit (1+ (match-end 0)))))
3178   s)
3179
3180 (provide 'emerge)
3181
3182 ;;; emerge.el ends here