home *** CD-ROM | disk | FTP | other *** search
/ Geek Gadgets 1 / ADE-1.bin / ade-dist / emacs-19.28-src.tgz / tar.out / fsf / emacs / lisp / emerge.el < prev    next >
Lisp/Scheme  |  1996-09-28  |  121KB  |  3,173 lines

  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 "Emerge"))
  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.   desired-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.      (B-point-min (emerge-eval-in-buffer B-buffer (point-min)))
  1449.      ;; Record current line number in each buffer
  1450.      ;; so we don't have to count from the beginning.
  1451.      (a-line 1)
  1452.      (b-line 1))
  1453.     (emerge-eval-in-buffer A-buffer (goto-char (point-min)))
  1454.     (emerge-eval-in-buffer B-buffer (goto-char (point-min)))
  1455.     (while lineno-list
  1456.       (let* ((list-element (car lineno-list))
  1457.          a-begin-marker
  1458.          a-end-marker
  1459.          b-begin-marker
  1460.          b-end-marker
  1461.          merge-begin-marker
  1462.          merge-end-marker
  1463.          (a-begin (aref list-element 0))
  1464.          (a-end (aref list-element 1))
  1465.          (b-begin (aref list-element 2))
  1466.          (b-end (aref list-element 3))
  1467.          (state (aref list-element 4)))
  1468.     ;; place markers at the appropriate places in the buffers
  1469.     (emerge-eval-in-buffer
  1470.      A-buffer
  1471.      (setq a-line (emerge-goto-line a-begin a-line))
  1472.      (setq a-begin-marker (point-marker))
  1473.      (setq a-line (emerge-goto-line a-end a-line))
  1474.      (setq a-end-marker (point-marker)))
  1475.     (emerge-eval-in-buffer
  1476.      B-buffer
  1477.      (setq b-line (emerge-goto-line b-begin b-line))
  1478.      (setq b-begin-marker (point-marker))
  1479.      (setq b-line (emerge-goto-line b-end b-line))
  1480.      (setq b-end-marker (point-marker)))
  1481.     (setq merge-begin-marker (set-marker
  1482.                   (make-marker)
  1483.                   (- (marker-position a-begin-marker)
  1484.                      offset)
  1485.                   merge-buffer))
  1486.     (setq merge-end-marker (set-marker
  1487.                 (make-marker)
  1488.                 (- (marker-position a-end-marker)
  1489.                    offset)
  1490.                 merge-buffer))
  1491.     ;; record all the markers for this difference
  1492.     (setq marker-list (cons (vector a-begin-marker a-end-marker
  1493.                     b-begin-marker b-end-marker
  1494.                     merge-begin-marker merge-end-marker
  1495.                     state)
  1496.                 marker-list)))
  1497.       (setq lineno-list (cdr lineno-list)))
  1498.     ;; convert the list of difference information into a vector for
  1499.     ;; fast access
  1500.     (setq emerge-difference-list (apply 'vector (nreverse marker-list)))))
  1501.  
  1502. ;; If we have an ancestor, select all B variants that we prefer 
  1503. (defun emerge-select-prefer-Bs ()
  1504.   (let ((n 0))
  1505.     (while (< n emerge-number-of-differences)
  1506.       (if (eq (aref (aref emerge-difference-list n) 6) 'prefer-B)
  1507.       (progn
  1508.         (emerge-unselect-and-select-difference n t)
  1509.         (emerge-select-B)
  1510.         (aset (aref emerge-difference-list n) 6 'prefer-B)))
  1511.       (setq n (1+ n))))
  1512.   (emerge-unselect-and-select-difference -1))
  1513.  
  1514. ;; Process the local-variables list at the end of the merged file, if
  1515. ;; requested.
  1516. (defun emerge-handle-local-variables ()
  1517.   (if emerge-process-local-variables
  1518.       (condition-case err
  1519.       (hack-local-variables)
  1520.     (error (message "Local-variables error in merge buffer: %s"
  1521.             (prin1-to-string err))))))
  1522.  
  1523. ;;; Common exit routines
  1524.  
  1525. (defun emerge-write-and-delete (file-out)
  1526.   ;; clear screen format
  1527.   (delete-other-windows)
  1528.   ;; delete A, B, and ancestor buffers, if they haven't been changed
  1529.   (if (not (buffer-modified-p emerge-A-buffer))
  1530.       (kill-buffer emerge-A-buffer))
  1531.   (if (not (buffer-modified-p emerge-B-buffer))
  1532.       (kill-buffer emerge-B-buffer))
  1533.   (if (and emerge-ancestor-buffer
  1534.        (not (buffer-modified-p emerge-ancestor-buffer)))
  1535.       (kill-buffer emerge-ancestor-buffer))
  1536.   ;; Write merge buffer to file
  1537.   (and file-out
  1538.        (write-file file-out)))
  1539.  
  1540. ;;; Commands
  1541.  
  1542. (defun emerge-recenter (&optional arg)
  1543.   "Bring the highlighted region of all three merge buffers into view.
  1544. This brings the buffers into view if they are in windows.
  1545. With an argument, reestablish the default three-window display."
  1546.   (interactive "P")
  1547.   ;; If there is an argument, rebuild the window structure
  1548.   (if arg
  1549.       (emerge-setup-windows emerge-A-buffer emerge-B-buffer
  1550.                 emerge-merge-buffer))
  1551.   ;; Redisplay whatever buffers are showing, if there is a selected difference
  1552.   (if (and (>= emerge-current-difference 0)
  1553.        (< emerge-current-difference emerge-number-of-differences))
  1554.       (let* ((merge-buffer emerge-merge-buffer)
  1555.          (buffer-A emerge-A-buffer)
  1556.          (buffer-B emerge-B-buffer)
  1557.          (window-A (get-buffer-window buffer-A))
  1558.          (window-B (get-buffer-window buffer-B))
  1559.          (merge-window (get-buffer-window merge-buffer))
  1560.          (diff-vector
  1561.           (aref emerge-difference-list emerge-current-difference)))
  1562.     (if window-A (progn
  1563.                (select-window window-A)
  1564.                (emerge-position-region
  1565.             (- (aref diff-vector 0)
  1566.                (1- emerge-before-flag-length))
  1567.             (+ (aref diff-vector 1)
  1568.                (1- emerge-after-flag-length))
  1569.             (1+ (aref diff-vector 0)))))
  1570.     (if window-B (progn
  1571.                (select-window window-B)
  1572.                (emerge-position-region
  1573.             (- (aref diff-vector 2)
  1574.                (1- emerge-before-flag-length))
  1575.             (+ (aref diff-vector 3)
  1576.                (1- emerge-after-flag-length))
  1577.             (1+ (aref diff-vector 2)))))
  1578.     (if merge-window (progn
  1579.                (select-window merge-window)
  1580.                (emerge-position-region
  1581.                 (- (aref diff-vector 4)
  1582.                    (1- emerge-before-flag-length))
  1583.                 (+ (aref diff-vector 5)
  1584.                    (1- emerge-after-flag-length))
  1585.                 (1+ (aref diff-vector 4))))))))
  1586.  
  1587. ;;; Window scrolling operations
  1588. ;; These operations are designed to scroll all three windows the same amount,
  1589. ;; so as to keep the text in them aligned.
  1590.  
  1591. ;; Perform some operation on all three windows (if they are showing).
  1592. ;; Catches all errors on the operation in the A and B windows, but not
  1593. ;; in the merge window.  Usually, errors come from scrolling off the
  1594. ;; beginning or end of the buffer, and this gives a nice error message:
  1595. ;; End of buffer is reported in the merge buffer, but if the scroll was
  1596. ;; possible in the A or B windows, it is performed there before the error
  1597. ;; is reported.
  1598. (defun emerge-operate-on-windows (operation arg)
  1599.   (let* ((merge-buffer emerge-merge-buffer)
  1600.      (buffer-A emerge-A-buffer)
  1601.      (buffer-B emerge-B-buffer)
  1602.      (window-A (get-buffer-window buffer-A))
  1603.      (window-B (get-buffer-window buffer-B))
  1604.      (merge-window (get-buffer-window merge-buffer)))
  1605.     (if window-A (progn
  1606.            (select-window window-A)
  1607.            (condition-case nil
  1608.                (funcall operation arg)
  1609.              (error))))
  1610.     (if window-B (progn
  1611.            (select-window window-B)
  1612.            (condition-case nil
  1613.                (funcall operation arg)
  1614.              (error))))
  1615.     (if merge-window (progn
  1616.                (select-window merge-window)
  1617.                (funcall operation arg)))))
  1618.  
  1619. (defun emerge-scroll-up (&optional arg)
  1620.   "Scroll up all three merge buffers, if they are in windows.
  1621. With argument N, scroll N lines; otherwise scroll by nearly
  1622. the height of the merge window.
  1623. `C-u -' alone as argument scrolls half the height of the merge window."
  1624.   (interactive "P")
  1625.   (emerge-operate-on-windows
  1626.    'scroll-up 
  1627.    ;; calculate argument to scroll-up
  1628.    ;; if there is an explicit argument
  1629.    (if (and arg (not (equal arg '-)))
  1630.        ;; use it
  1631.        (prefix-numeric-value arg)
  1632.      ;; if not, see if we can determine a default amount (the window height)
  1633.      (let ((merge-window (get-buffer-window emerge-merge-buffer)))
  1634.        (if (null merge-window)
  1635.        ;; no window, use nil
  1636.        nil
  1637.      (let ((default-amount
  1638.          (- (window-height merge-window) 1 next-screen-context-lines)))
  1639.        ;; the window was found
  1640.        (if arg
  1641.            ;; C-u as argument means half of default amount
  1642.            (/ default-amount 2)
  1643.          ;; no argument means default amount
  1644.          default-amount)))))))
  1645.  
  1646. (defun emerge-scroll-down (&optional arg)
  1647.   "Scroll down all three merge buffers, if they are in windows.
  1648. With argument N, scroll N lines; otherwise scroll by nearly
  1649. the height of the merge window.
  1650. `C-u -' alone as argument scrolls half the height of the merge window."
  1651.   (interactive "P")
  1652.   (emerge-operate-on-windows
  1653.    'scroll-down
  1654.    ;; calculate argument to scroll-down
  1655.    ;; if there is an explicit argument
  1656.    (if (and arg (not (equal arg '-)))
  1657.        ;; use it
  1658.        (prefix-numeric-value arg)
  1659.      ;; if not, see if we can determine a default amount (the window height)
  1660.      (let ((merge-window (get-buffer-window emerge-merge-buffer)))
  1661.        (if (null merge-window)
  1662.        ;; no window, use nil
  1663.        nil
  1664.      (let ((default-amount
  1665.          (- (window-height merge-window) 1 next-screen-context-lines)))
  1666.        ;; the window was found
  1667.        (if arg
  1668.            ;; C-u as argument means half of default amount
  1669.            (/ default-amount 2)
  1670.          ;; no argument means default amount
  1671.          default-amount)))))))
  1672.  
  1673. (defun emerge-scroll-left (&optional arg)
  1674.   "Scroll left all three merge buffers, if they are in windows.
  1675. If an argument is given, that is how many columns are scrolled, else nearly
  1676. the width of the A and B windows.  `C-u -' alone as argument scrolls half the
  1677. width of the A and B windows."
  1678.   (interactive "P")
  1679.   (emerge-operate-on-windows
  1680.    'scroll-left
  1681.    ;; calculate argument to scroll-left
  1682.    ;; if there is an explicit argument
  1683.    (if (and arg (not (equal arg '-)))
  1684.        ;; use it
  1685.        (prefix-numeric-value arg)
  1686.      ;; if not, see if we can determine a default amount
  1687.      ;; (half the window width)
  1688.      (let ((merge-window (get-buffer-window emerge-merge-buffer)))
  1689.        (if (null merge-window)
  1690.        ;; no window, use nil
  1691.        nil
  1692.      (let ((default-amount
  1693.          (- (/ (window-width merge-window) 2) 3)))
  1694.        ;; the window was found
  1695.        (if arg
  1696.            ;; C-u as argument means half of default amount
  1697.            (/ default-amount 2)
  1698.          ;; no argument means default amount
  1699.          default-amount)))))))
  1700.  
  1701. (defun emerge-scroll-right (&optional arg)
  1702.   "Scroll right all three merge buffers, if they are in windows.
  1703. If an argument is given, that is how many columns are scrolled, else nearly
  1704. the width of the A and B windows.  `C-u -' alone as argument scrolls half the
  1705. width of the A and B windows."
  1706.   (interactive "P")
  1707.   (emerge-operate-on-windows
  1708.    'scroll-right
  1709.    ;; calculate argument to scroll-right
  1710.    ;; if there is an explicit argument
  1711.    (if (and arg (not (equal arg '-)))
  1712.        ;; use it
  1713.        (prefix-numeric-value arg)
  1714.      ;; if not, see if we can determine a default amount
  1715.      ;; (half the window width)
  1716.      (let ((merge-window (get-buffer-window emerge-merge-buffer)))
  1717.        (if (null merge-window)
  1718.        ;; no window, use nil
  1719.        nil
  1720.      (let ((default-amount
  1721.          (- (/ (window-width merge-window) 2) 3)))
  1722.        ;; the window was found
  1723.        (if arg
  1724.            ;; C-u as argument means half of default amount
  1725.            (/ default-amount 2)
  1726.          ;; no argument means default amount
  1727.          default-amount)))))))
  1728.  
  1729. (defun emerge-scroll-reset ()
  1730.   "Reset horizontal scrolling in Emerge.
  1731. This resets the horizontal scrolling of all three merge buffers
  1732. to the left margin, if they are in windows."
  1733.   (interactive)
  1734.   (emerge-operate-on-windows
  1735.    (function (lambda (x) (set-window-hscroll (selected-window) 0)))
  1736.    nil))
  1737.  
  1738. ;; Attempt to show the region nicely.
  1739. ;; If there are min-lines lines above and below the region, then don't do
  1740. ;; anything.
  1741. ;; If not, recenter the region to make it so.
  1742. ;; If that isn't possible, remove context lines balancedly from top and botton
  1743. ;; so the entire region shows.
  1744. ;; If that isn't possible, show the top of the region.
  1745. ;; BEG must be at the beginning of a line.
  1746. (defun emerge-position-region (beg end pos)
  1747.   ;; First test whether the entire region is visible with
  1748.   ;; emerge-min-visible-lines above and below it
  1749.   (if (not (and (<= (progn
  1750.               (move-to-window-line emerge-min-visible-lines)
  1751.               (point))
  1752.             beg)
  1753.         (<= end (progn
  1754.               (move-to-window-line
  1755.                (- (1+ emerge-min-visible-lines)))
  1756.               (point)))))
  1757.       ;; We failed that test, see if it fits at all
  1758.       ;; Meanwhile positioning it correctly in case it doesn't fit
  1759.       (progn
  1760.     (set-window-start (selected-window) beg)
  1761.     (if (pos-visible-in-window-p end)
  1762.         ;; Determine the number of lines that the region occupies
  1763.         (let ((lines 0))
  1764.           (while (> end (progn
  1765.                   (move-to-window-line lines)
  1766.                   (point)))
  1767.         (setq lines (1+ lines)))
  1768.           ;; And position the beginning on the right line
  1769.           (goto-char beg)
  1770.           (recenter (/ (1+ (- (1- (window-height (selected-window)))
  1771.                   lines))
  1772.                2))))))
  1773.   (goto-char pos))
  1774.  
  1775. (defun emerge-next-difference ()
  1776.   "Advance to the next difference."
  1777.   (interactive)
  1778.   (if (< emerge-current-difference emerge-number-of-differences)
  1779.       (let ((n (1+ emerge-current-difference)))
  1780.     (while (and emerge-skip-prefers
  1781.             (< n emerge-number-of-differences)
  1782.             (memq (aref (aref emerge-difference-list n) 6)
  1783.               '(prefer-A prefer-B)))
  1784.       (setq n (1+ n)))
  1785.     (let ((buffer-read-only nil))
  1786.       (emerge-unselect-and-select-difference n)))
  1787.     (error "At end")))
  1788.  
  1789. (defun emerge-previous-difference ()
  1790.   "Go to the previous difference."
  1791.   (interactive)
  1792.   (if (> emerge-current-difference -1)
  1793.       (let ((n (1- emerge-current-difference)))
  1794.     (while (and emerge-skip-prefers
  1795.             (> n -1)
  1796.             (memq (aref (aref emerge-difference-list n) 6)
  1797.               '(prefer-A prefer-B)))
  1798.       (setq n (1- n)))
  1799.     (let ((buffer-read-only nil))
  1800.       (emerge-unselect-and-select-difference n)))
  1801.     (error "At beginning")))
  1802.  
  1803. (defun emerge-jump-to-difference (difference-number)
  1804.   "Go to the N-th difference."
  1805.   (interactive "p")
  1806.   (let ((buffer-read-only nil))
  1807.     (setq difference-number (1- difference-number))
  1808.     (if (and (>= difference-number -1)
  1809.          (< difference-number (1+ emerge-number-of-differences)))
  1810.     (emerge-unselect-and-select-difference difference-number)
  1811.       (error "Bad difference number"))))
  1812.  
  1813. (defun emerge-abort ()
  1814.   "Abort the Emerge session."
  1815.   (interactive)
  1816.   (emerge-quit t))
  1817.  
  1818. (defun emerge-quit (arg)
  1819.   "Finish the Emerge session and exit Emerge.
  1820. Prefix argument means to abort rather than successfully finish.
  1821. The difference depends on how the merge was started,
  1822. but usually means to not write over one of the original files, or to signal
  1823. to some process which invoked Emerge a failure code.
  1824.  
  1825. Unselects the selected difference, if any, restores the read-only and modified
  1826. flags of the merged file buffers, restores the local keymap of the merge
  1827. buffer, and sets off various emerge flags.  Using Emerge commands in this
  1828. buffer after this will cause serious problems."
  1829.   (interactive "P")
  1830.   (if (prog1
  1831.       (y-or-n-p
  1832.        (if (not arg)
  1833.            "Do you really want to successfully finish this merge? "
  1834.          "Do you really want to abort this merge? "))
  1835.     (message ""))
  1836.       (emerge-really-quit arg)))
  1837.  
  1838. ;; Perform the quit operations.
  1839. (defun emerge-really-quit (arg)
  1840.   (setq buffer-read-only nil)
  1841.   (emerge-unselect-and-select-difference -1)
  1842.   (emerge-restore-buffer-characteristics)
  1843.   ;; null out the difference markers so they don't slow down future editing
  1844.   ;; operations
  1845.   (mapcar (function (lambda (d)
  1846.               (set-marker (aref d 0) nil)
  1847.               (set-marker (aref d 1) nil)
  1848.               (set-marker (aref d 2) nil)
  1849.               (set-marker (aref d 3) nil)
  1850.               (set-marker (aref d 4) nil)
  1851.               (set-marker (aref d 5) nil)))
  1852.       emerge-difference-list)
  1853.   ;; allow them to be garbage collected
  1854.   (setq emerge-difference-list nil)
  1855.   ;; restore the local map
  1856.   (use-local-map emerge-old-keymap)
  1857.   ;; turn off all the emerge modes
  1858.   (setq emerge-mode nil)
  1859.   (setq emerge-fast-mode nil)
  1860.   (setq emerge-edit-mode nil)
  1861.   (setq emerge-auto-advance nil)
  1862.   (setq emerge-skip-prefers nil)
  1863.   ;; restore mode line
  1864.   (kill-local-variable 'mode-line-buffer-identification)
  1865.   (let ((emerge-prefix-argument arg))
  1866.     (run-hooks 'emerge-quit-hook)))
  1867.  
  1868. (defun emerge-select-A (&optional force)
  1869.   "Select the A variant of this difference.  
  1870. Refuses to function if this difference has been edited, i.e., if it
  1871. is neither the A nor the B variant.
  1872. A prefix argument forces the variant to be selected
  1873. even if the difference has been edited."
  1874.   (interactive "P")
  1875.   (let ((operate
  1876.      (function (lambda ()
  1877.              (emerge-select-A-edit merge-begin merge-end A-begin A-end)
  1878.              (if emerge-auto-advance
  1879.              (emerge-next-difference)))))
  1880.     (operate-no-change
  1881.      (function (lambda ()
  1882.              (if emerge-auto-advance
  1883.              (emerge-next-difference))))))
  1884.     (emerge-select-version force operate-no-change operate operate)))
  1885.  
  1886. ;; Actually select the A variant
  1887. (defun emerge-select-A-edit (merge-begin merge-end A-begin A-end)
  1888.   (emerge-eval-in-buffer
  1889.    emerge-merge-buffer
  1890.    (delete-region merge-begin merge-end)
  1891.    (goto-char merge-begin)
  1892.    (insert-buffer-substring emerge-A-buffer A-begin A-end)
  1893.    (goto-char merge-begin)
  1894.    (aset diff-vector 6 'A)
  1895.    (emerge-refresh-mode-line)))
  1896.  
  1897. (defun emerge-select-B (&optional force)
  1898.   "Select the B variant of this difference.
  1899. Refuses to function if this difference has been edited, i.e., if it
  1900. is neither the A nor the B variant.
  1901. A prefix argument forces the variant to be selected
  1902. even if the difference has been edited."
  1903.   (interactive "P")
  1904.   (let ((operate
  1905.      (function (lambda ()
  1906.              (emerge-select-B-edit merge-begin merge-end B-begin B-end)
  1907.              (if emerge-auto-advance
  1908.              (emerge-next-difference)))))
  1909.     (operate-no-change
  1910.      (function (lambda ()
  1911.              (if emerge-auto-advance
  1912.              (emerge-next-difference))))))
  1913.     (emerge-select-version force operate operate-no-change operate)))
  1914.  
  1915. ;; Actually select the B variant
  1916. (defun emerge-select-B-edit (merge-begin merge-end B-begin B-end)
  1917.   (emerge-eval-in-buffer
  1918.    emerge-merge-buffer
  1919.    (delete-region merge-begin merge-end)
  1920.    (goto-char merge-begin)
  1921.    (insert-buffer-substring emerge-B-buffer B-begin B-end)
  1922.    (goto-char merge-begin)
  1923.    (aset diff-vector 6 'B)
  1924.    (emerge-refresh-mode-line)))
  1925.  
  1926. (defun emerge-default-A ()
  1927.   "Make the A variant the default from here down.
  1928. This selects the A variant for all differences from here down in the buffer
  1929. which are still defaulted, i.e., which the user has not selected and for
  1930. which there is no preference."
  1931.   (interactive)
  1932.   (let ((buffer-read-only nil))
  1933.     (let ((selected-difference emerge-current-difference)
  1934.       (n (max emerge-current-difference 0)))
  1935.       (while (< n emerge-number-of-differences)
  1936.     (let ((diff-vector (aref emerge-difference-list n)))
  1937.       (if (eq (aref diff-vector 6) 'default-B)
  1938.           (progn
  1939.         (emerge-unselect-and-select-difference n t)
  1940.         (emerge-select-A)
  1941.         (aset diff-vector 6 'default-A))))
  1942.     (setq n (1+ n))
  1943.     (if (zerop (% n 10))
  1944.         (message "Setting default to A...%d" n)))
  1945.       (emerge-unselect-and-select-difference selected-difference)))
  1946.   (message "Default choice is now A"))
  1947.  
  1948. (defun emerge-default-B ()
  1949.   "Make the B variant the default from here down.
  1950. This selects the B variant for all differences from here down in the buffer
  1951. which are still defaulted, i.e., which the user has not selected and for
  1952. which there is no preference."
  1953.   (interactive)
  1954.   (let ((buffer-read-only nil))
  1955.     (let ((selected-difference emerge-current-difference)
  1956.       (n (max emerge-current-difference 0)))
  1957.       (while (< n emerge-number-of-differences)
  1958.     (let ((diff-vector (aref emerge-difference-list n)))
  1959.       (if (eq (aref diff-vector 6) 'default-A)
  1960.           (progn
  1961.         (emerge-unselect-and-select-difference n t)
  1962.         (emerge-select-B)
  1963.         (aset diff-vector 6 'default-B))))
  1964.     (setq n (1+ n))
  1965.     (if (zerop (% n 10))
  1966.         (message "Setting default to B...%d" n)))
  1967.       (emerge-unselect-and-select-difference selected-difference)))
  1968.   (message "Default choice is now B"))
  1969.  
  1970. (defun emerge-fast-mode ()
  1971.   "Set fast mode, for Emerge.
  1972. In this mode ordinary Emacs commands are disabled, and Emerge commands
  1973. need not be prefixed with \\<emerge-fast-keymap>\\[emerge-basic-keymap]."
  1974.   (interactive)
  1975.   (setq buffer-read-only t)
  1976.   (use-local-map emerge-fast-keymap)
  1977.   (setq emerge-mode t)
  1978.   (setq emerge-fast-mode t)
  1979.   (setq emerge-edit-mode nil)
  1980.   (message "Fast mode set")
  1981.   ;; force mode line redisplay
  1982.   (set-buffer-modified-p (buffer-modified-p)))
  1983.  
  1984. (defun emerge-edit-mode ()
  1985.   "Set edit mode, for Emerge.
  1986. In this mode ordinary Emacs commands are available, and Emerge commands
  1987. must be prefixed with \\<emerge-fast-keymap>\\[emerge-basic-keymap]."
  1988.   (interactive)
  1989.   (setq buffer-read-only nil)
  1990.   (use-local-map emerge-edit-keymap)
  1991.   (setq emerge-mode t)
  1992.   (setq emerge-fast-mode nil)
  1993.   (setq emerge-edit-mode t)
  1994.   (message "Edit mode set")
  1995.   ;; force mode line redisplay
  1996.   (set-buffer-modified-p (buffer-modified-p)))
  1997.  
  1998. (defun emerge-auto-advance (arg)
  1999.   "Toggle Auto-Advance mode, for Emerge.
  2000. This mode causes `emerge-select-A' and `emerge-select-B' to automatically
  2001. advance to the next difference.
  2002. With a positive argument, turn on Auto-Advance mode.
  2003. With a negative argument, turn off Auto-Advance mode."
  2004.   (interactive "P")
  2005.   (setq emerge-auto-advance (if (null arg)
  2006.                 (not emerge-auto-advance)
  2007.                   (> (prefix-numeric-value arg) 0)))
  2008.   (message (if emerge-skip-prefers
  2009.            "Auto-advance set"
  2010.          "Auto-advance cleared"))
  2011.   ;; force mode line redisplay
  2012.   (set-buffer-modified-p (buffer-modified-p)))
  2013.  
  2014. (defun emerge-skip-prefers (arg)
  2015.   "Toggle Skip-Prefers mode, for Emerge.
  2016. This mode causes `emerge-next-difference' and `emerge-previous-difference'
  2017. to automatically skip over differences for which there is a preference.
  2018. With a positive argument, turn on Skip-Prefers mode.
  2019. With a negative argument, turn off Skip-Prefers mode."
  2020.   (interactive "P")
  2021.   (setq emerge-skip-prefers (if (null arg)
  2022.                 (not emerge-skip-prefers)
  2023.                   (> (prefix-numeric-value arg) 0)))
  2024.   (message (if emerge-skip-prefers
  2025.            "Skip-prefers set"
  2026.          "Skip-prefers cleared"))
  2027.   ;; force mode line redisplay
  2028.   (set-buffer-modified-p (buffer-modified-p)))
  2029.  
  2030. (defun emerge-copy-as-kill-A ()
  2031.   "Put the A variant of this difference in the kill ring."
  2032.   (interactive)
  2033.   (emerge-validate-difference)
  2034.   (let* ((diff-vector
  2035.       (aref emerge-difference-list emerge-current-difference))
  2036.      (A-begin (1+ (aref diff-vector 0)))
  2037.      (A-end (1- (aref diff-vector 1)))
  2038.      ;; so further kills don't append
  2039.      this-command)
  2040.     (save-excursion
  2041.       (set-buffer emerge-A-buffer)
  2042.       (copy-region-as-kill A-begin A-end))))
  2043.  
  2044. (defun emerge-copy-as-kill-B ()
  2045.   "Put the B variant of this difference in the kill ring."
  2046.   (interactive)
  2047.   (emerge-validate-difference)
  2048.   (let* ((diff-vector
  2049.       (aref emerge-difference-list emerge-current-difference))
  2050.      (B-begin (1+ (aref diff-vector 2)))
  2051.      (B-end (1- (aref diff-vector 3)))
  2052.      ;; so further kills don't append
  2053.      this-command)
  2054.     (save-excursion
  2055.       (set-buffer emerge-B-buffer)
  2056.       (copy-region-as-kill B-begin B-end))))
  2057.  
  2058. (defun emerge-insert-A (arg)
  2059.   "Insert the A variant of this difference at the point.
  2060. Leaves point after text, mark before.
  2061. With prefix argument, puts point before, mark after."
  2062.   (interactive "P")
  2063.   (emerge-validate-difference)
  2064.   (let* ((diff-vector
  2065.       (aref emerge-difference-list emerge-current-difference))
  2066.      (A-begin (1+ (aref diff-vector 0)))
  2067.      (A-end (1- (aref diff-vector 1)))
  2068.      (opoint (point))
  2069.      (buffer-read-only nil))
  2070.     (insert-buffer-substring emerge-A-buffer A-begin A-end)
  2071.     (if (not arg)
  2072.     (set-mark opoint)
  2073.       (set-mark (point))
  2074.       (goto-char opoint))))
  2075.  
  2076. (defun emerge-insert-B (arg)
  2077.   "Insert the B variant of this difference at the point.
  2078. Leaves point after text, mark before.
  2079. With prefix argument, puts point before, mark after."
  2080.   (interactive "P")
  2081.   (emerge-validate-difference)
  2082.   (let* ((diff-vector
  2083.       (aref emerge-difference-list emerge-current-difference))
  2084.      (B-begin (1+ (aref diff-vector 2)))
  2085.      (B-end (1- (aref diff-vector 3)))
  2086.      (opoint (point))
  2087.      (buffer-read-only nil))
  2088.     (insert-buffer-substring emerge-B-buffer B-begin B-end)
  2089.     (if (not arg)
  2090.     (set-mark opoint)
  2091.       (set-mark (point))
  2092.       (goto-char opoint))))
  2093.  
  2094. (defun emerge-mark-difference (arg)
  2095.   "Leaves the point before this difference and the mark after it.
  2096. With prefix argument, puts mark before, point after."
  2097.   (interactive "P")
  2098.   (emerge-validate-difference)
  2099.   (let* ((diff-vector
  2100.       (aref emerge-difference-list emerge-current-difference))
  2101.      (merge-begin (1+ (aref diff-vector 4)))
  2102.      (merge-end (1- (aref diff-vector 5))))
  2103.     (if (not arg)
  2104.     (progn
  2105.       (goto-char merge-begin)
  2106.       (set-mark merge-end))
  2107.       (goto-char merge-end)
  2108.       (set-mark merge-begin))))
  2109.  
  2110. (defun emerge-file-names ()
  2111.   "Show the names of the buffers or files being operated on by Emerge.
  2112. Use C-u l to reset the windows afterward."
  2113.   (interactive)
  2114.   (delete-other-windows)
  2115.   (let ((temp-buffer-show-function
  2116.      (function (lambda (buf)
  2117.              (split-window-vertically)
  2118.              (switch-to-buffer buf)
  2119.              (other-window 1)))))
  2120.     (with-output-to-temp-buffer "*Help*"
  2121.       (emerge-eval-in-buffer emerge-A-buffer
  2122.                  (if buffer-file-name
  2123.                  (progn
  2124.                    (princ "File A is: ")
  2125.                    (princ buffer-file-name))
  2126.                    (progn
  2127.                  (princ "Buffer A is: ")
  2128.                  (princ (buffer-name))))
  2129.                  (princ "\n"))
  2130.       (emerge-eval-in-buffer emerge-B-buffer
  2131.                  (if buffer-file-name
  2132.                  (progn
  2133.                    (princ "File B is: ")
  2134.                    (princ buffer-file-name))
  2135.                    (progn
  2136.                  (princ "Buffer B is: ")
  2137.                  (princ (buffer-name))))
  2138.                  (princ "\n"))
  2139.       (if emerge-ancestor-buffer
  2140.         (emerge-eval-in-buffer emerge-ancestor-buffer
  2141.                    (if buffer-file-name
  2142.                        (progn
  2143.                      (princ "Ancestor file is: ")
  2144.                      (princ buffer-file-name))
  2145.                      (progn
  2146.                        (princ "Ancestor buffer is: ")
  2147.                        (princ (buffer-name))))
  2148.                    (princ "\n")))
  2149.       (princ emerge-output-description))))
  2150.  
  2151. (defun emerge-join-differences (arg)
  2152.   "Join the selected difference with the following one.
  2153. With a prefix argument, join with the preceding one."
  2154.   (interactive "P")
  2155.   (let ((n emerge-current-difference))
  2156.     ;; adjust n to be first difference to join
  2157.     (if arg
  2158.     (setq n (1- n)))
  2159.     ;; n and n+1 are the differences to join
  2160.     ;; check that they are both differences
  2161.     (if (or (< n 0) (>= n (1- emerge-number-of-differences)))
  2162.     (error "Incorrect differences to join"))
  2163.     ;; remove the flags
  2164.     (emerge-unselect-difference emerge-current-difference)
  2165.     ;; decrement total number of differences
  2166.     (setq emerge-number-of-differences (1- emerge-number-of-differences))
  2167.     ;; build new differences vector
  2168.     (let ((i 0)
  2169.       (new-differences (make-vector emerge-number-of-differences nil)))
  2170.       (while (< i emerge-number-of-differences)
  2171.     (aset new-differences i
  2172.           (cond
  2173.            ((< i n) (aref emerge-difference-list i))
  2174.            ((> i n) (aref emerge-difference-list (1+ i)))
  2175.            (t (let ((prev (aref emerge-difference-list i))
  2176.             (next (aref emerge-difference-list (1+ i))))
  2177.             (vector (aref prev 0)
  2178.                 (aref next 1)
  2179.                 (aref prev 2)
  2180.                 (aref next 3)
  2181.                 (aref prev 4)
  2182.                 (aref next 5)
  2183.                 (let ((ps (aref prev 6))
  2184.                   (ns (aref next 6)))
  2185.                   (cond
  2186.                    ((eq ps ns)
  2187.                 ps)
  2188.                    ((and (or (eq ps 'B) (eq ps 'prefer-B))
  2189.                      (or (eq ns 'B) (eq ns 'prefer-B)))
  2190.                 'B)
  2191.                    (t 'A))))))))
  2192.     (setq i (1+ i)))
  2193.       (setq emerge-difference-list new-differences))
  2194.     ;; set the current difference correctly
  2195.     (setq emerge-current-difference n)
  2196.     ;; fix the mode line
  2197.     (emerge-refresh-mode-line)
  2198.     ;; reinsert the flags
  2199.     (emerge-select-difference emerge-current-difference)
  2200.     (emerge-recenter)))
  2201.  
  2202. (defun emerge-split-difference ()
  2203.   "Split the current difference where the points are in the three windows."
  2204.   (interactive)
  2205.   (let ((n emerge-current-difference))
  2206.     ;; check that this is a valid difference
  2207.     (emerge-validate-difference)
  2208.     ;; get the point values and old difference
  2209.     (let ((A-point (emerge-eval-in-buffer emerge-A-buffer
  2210.                       (point-marker)))
  2211.       (B-point (emerge-eval-in-buffer emerge-B-buffer
  2212.                       (point-marker)))
  2213.       (merge-point (point-marker))
  2214.       (old-diff (aref emerge-difference-list n)))
  2215.       ;; check location of the points, give error if they aren't in the
  2216.       ;; differences
  2217.       (if (or (< A-point (aref old-diff 0))
  2218.           (> A-point (aref old-diff 1)))
  2219.       (error "Point outside of difference in A buffer"))
  2220.       (if (or (< B-point (aref old-diff 2))
  2221.           (> B-point (aref old-diff 3)))
  2222.       (error "Point outside of difference in B buffer"))
  2223.       (if (or (< merge-point (aref old-diff 4))
  2224.           (> merge-point (aref old-diff 5)))
  2225.       (error "Point outside of difference in merge buffer"))
  2226.       ;; remove the flags
  2227.       (emerge-unselect-difference emerge-current-difference)
  2228.       ;; increment total number of differences
  2229.       (setq emerge-number-of-differences (1+ emerge-number-of-differences))
  2230.       ;; build new differences vector
  2231.       (let ((i 0)
  2232.         (new-differences (make-vector emerge-number-of-differences nil)))
  2233.     (while (< i emerge-number-of-differences)
  2234.       (aset new-differences i
  2235.         (cond
  2236.          ((< i n)
  2237.           (aref emerge-difference-list i))
  2238.          ((> i (1+ n))
  2239.           (aref emerge-difference-list (1- i)))
  2240.          ((= i n)
  2241.           (vector (aref old-diff 0)
  2242.               A-point
  2243.               (aref old-diff 2)
  2244.               B-point
  2245.               (aref old-diff 4)
  2246.               merge-point
  2247.               (aref old-diff 6)))
  2248.          (t
  2249.           (vector (copy-marker A-point)
  2250.               (aref old-diff 1)
  2251.               (copy-marker B-point)
  2252.               (aref old-diff 3)
  2253.               (copy-marker merge-point)
  2254.               (aref old-diff 5)
  2255.               (aref old-diff 6)))))
  2256.       (setq i (1+ i)))
  2257.     (setq emerge-difference-list new-differences))
  2258.       ;; set the current difference correctly
  2259.       (setq emerge-current-difference n)
  2260.       ;; fix the mode line
  2261.       (emerge-refresh-mode-line)
  2262.       ;; reinsert the flags
  2263.       (emerge-select-difference emerge-current-difference)
  2264.       (emerge-recenter))))
  2265.  
  2266. (defun emerge-trim-difference ()
  2267.   "Trim lines off top and bottom of difference that are the same.
  2268. If lines are the same in both the A and the B versions, strip them off.
  2269. \(This can happen when the A and B versions have common lines that the
  2270. ancestor version does not share.)"
  2271.   (interactive)
  2272.   ;; make sure we are in a real difference
  2273.   (emerge-validate-difference)
  2274.   ;; remove the flags
  2275.   (emerge-unselect-difference emerge-current-difference)
  2276.   (let* ((diff (aref emerge-difference-list emerge-current-difference))
  2277.      (top-a (marker-position (aref diff 0)))
  2278.      (bottom-a (marker-position (aref diff 1)))
  2279.      (top-b (marker-position (aref diff 2)))
  2280.      (bottom-b (marker-position (aref diff 3)))
  2281.      (top-m (marker-position (aref diff 4)))
  2282.      (bottom-m (marker-position (aref diff 5)))
  2283.      size success sa sb sm)
  2284.     ;; move down the tops of the difference regions as much as possible
  2285.     ;; Try advancing comparing 1000 chars at a time.
  2286.     ;; When that fails, go 500 chars at a time, and so on.
  2287.     (setq size 1000)
  2288.     (while (> size 0)
  2289.       (setq success t)
  2290.       (while success
  2291.     (setq size (min size (- bottom-a top-a) (- bottom-b top-b)
  2292.             (- bottom-m top-m)))
  2293.     (setq sa (emerge-eval-in-buffer emerge-A-buffer
  2294.                     (buffer-substring top-a
  2295.                               (+ size top-a))))
  2296.     (setq sb (emerge-eval-in-buffer emerge-B-buffer
  2297.                     (buffer-substring top-b
  2298.                               (+ size top-b))))
  2299.     (setq sm (buffer-substring top-m (+ size top-m)))
  2300.     (setq success (and (> size 0) (equal sa sb) (equal sb sm)))
  2301.     (if success
  2302.         (setq top-a (+ top-a size)
  2303.           top-b (+ top-b size)
  2304.           top-m (+ top-m size))))
  2305.       (setq size (/ size 2)))
  2306.     ;; move up the bottoms of the difference regions as much as possible
  2307.     ;; Try advancing comparing 1000 chars at a time.
  2308.     ;; When that fails, go 500 chars at a time, and so on.
  2309.     (setq size 1000)
  2310.     (while (> size 0)
  2311.       (setq success t)
  2312.       (while success
  2313.     (setq size (min size (- bottom-a top-a) (- bottom-b top-b)
  2314.             (- bottom-m top-m)))
  2315.     (setq sa (emerge-eval-in-buffer emerge-A-buffer
  2316.                     (buffer-substring (- bottom-a size)
  2317.                               bottom-a)))
  2318.     (setq sb (emerge-eval-in-buffer emerge-B-buffer
  2319.                     (buffer-substring (- bottom-b size)
  2320.                               bottom-b)))
  2321.     (setq sm (buffer-substring (- bottom-m size) bottom-m))
  2322.     (setq success (and (> size 0) (equal sa sb) (equal sb sm)))
  2323.     (if success
  2324.         (setq bottom-a (- bottom-a size)
  2325.           bottom-b (- bottom-b size)
  2326.           bottom-m (- bottom-m size))))
  2327.       (setq size (/ size 2)))
  2328.     ;; {top,bottom}-{a,b,m} are now set at the new beginnings and ends
  2329.     ;; of the difference regions.  Move them to the beginning of lines, as
  2330.     ;; appropriate.
  2331.     (emerge-eval-in-buffer emerge-A-buffer
  2332.                (goto-char top-a)
  2333.                (beginning-of-line)
  2334.                (aset diff 0 (point-marker))
  2335.                (goto-char bottom-a)
  2336.                (beginning-of-line 2)
  2337.                (aset diff 1 (point-marker)))
  2338.     (emerge-eval-in-buffer emerge-B-buffer
  2339.                (goto-char top-b)
  2340.                (beginning-of-line)
  2341.                (aset diff 2 (point-marker))
  2342.                (goto-char bottom-b)
  2343.                (beginning-of-line 2)
  2344.                (aset diff 3 (point-marker)))
  2345.     (goto-char top-m)
  2346.     (beginning-of-line)
  2347.     (aset diff 4 (point-marker))
  2348.     (goto-char bottom-m)
  2349.     (beginning-of-line 2)
  2350.     (aset diff 5 (point-marker))
  2351.     ;; put the flags back in, recenter the display
  2352.     (emerge-select-difference emerge-current-difference)
  2353.     (emerge-recenter)))
  2354.  
  2355. (defun emerge-find-difference (arg)
  2356.   "Find the difference containing the current position of the point.
  2357. If there is no containing difference and the prefix argument is positive,
  2358. it finds the nearest following difference.  A negative prefix argument finds
  2359. the nearest previous difference."
  2360.   (interactive "P")
  2361.   (cond ((eq (current-buffer) emerge-A-buffer)
  2362.      (emerge-find-difference-A arg))
  2363.     ((eq (current-buffer) emerge-B-buffer)
  2364.      (emerge-find-difference-B arg))
  2365.     (t (emerge-find-difference-merge arg))))
  2366.  
  2367. (defun emerge-find-difference-merge (arg)
  2368.   "Find the difference containing point, in the merge buffer.
  2369. If there is no containing difference and the prefix argument is positive,
  2370. it finds the nearest following difference.  A negative prefix argument finds
  2371. the nearest previous difference."
  2372.   (interactive "P")
  2373.   ;; search for the point in the merge buffer, using the markers
  2374.   ;; for the beginning and end of the differences in the merge buffer
  2375.   (emerge-find-difference1 arg (point) 4 5))
  2376.  
  2377. (defun emerge-find-difference-A (arg)
  2378.   "Find the difference containing point, in the A buffer.
  2379. This command must be executed in the merge buffer.
  2380. If there is no containing difference and the prefix argument is positive,
  2381. it finds the nearest following difference.  A negative prefix argument finds
  2382. the nearest previous difference."
  2383.   (interactive "P")
  2384.   ;; search for the point in the A buffer, using the markers
  2385.   ;; for the beginning and end of the differences in the A buffer
  2386.   (emerge-find-difference1 arg
  2387.                (emerge-eval-in-buffer emerge-A-buffer (point))
  2388.                0 1))
  2389.  
  2390. (defun emerge-find-difference-B (arg)
  2391.   "Find the difference containing point, in the B buffer.
  2392. This command must be executed in the merge buffer.
  2393. If there is no containing difference and the prefix argument is positive,
  2394. it finds the nearest following difference.  A negative prefix argument finds
  2395. the nearest previous difference."
  2396.   (interactive "P")
  2397.   ;; search for the point in the B buffer, using the markers
  2398.   ;; for the beginning and end of the differences in the B buffer
  2399.   (emerge-find-difference1 arg
  2400.                (emerge-eval-in-buffer emerge-B-buffer (point))
  2401.                2 3))
  2402.  
  2403. (defun emerge-find-difference1 (arg location begin end)
  2404.   (let* ((index
  2405.       ;; find first difference containing or after the current position
  2406.       (catch 'search
  2407.         (let ((n 0))
  2408.           (while (< n emerge-number-of-differences)
  2409.         (let ((diff-vector (aref emerge-difference-list n)))
  2410.           (if (<= location (marker-position (aref diff-vector end)))
  2411.               (throw 'search n)))
  2412.         (setq n (1+ n))))
  2413.         emerge-number-of-differences))
  2414.      (contains
  2415.       ;; whether the found difference contains the current position
  2416.       (and (< index emerge-number-of-differences)
  2417.            (<= (marker-position (aref (aref emerge-difference-list index)
  2418.                       begin))
  2419.            location)))
  2420.      (arg-value
  2421.       ;; numeric value of prefix argument
  2422.       (prefix-numeric-value arg)))
  2423.     (emerge-unselect-and-select-difference
  2424.      (cond
  2425.       ;; if the point is in a difference, select it
  2426.       (contains index)
  2427.       ;; if the arg is nil and the point is not in a difference, error
  2428.       ((null arg) (error "No difference contains point"))
  2429.       ;; if the arg is positive, select the following difference
  2430.       ((> arg-value 0)
  2431.        (if (< index emerge-number-of-differences)
  2432.        index
  2433.      (error "No difference contains or follows point")))
  2434.       ;; if the arg is negative, select the preceding difference
  2435.       (t
  2436.        (if (> index 0)
  2437.        (1- index)
  2438.      (error "No difference contains or precedes point")))))))
  2439.  
  2440. (defun emerge-line-numbers ()
  2441.   "Display the current line numbers.
  2442. This function displays the line numbers of the points in the A, B, and
  2443. merge buffers."
  2444.   (interactive)
  2445.   (let* ((valid-diff
  2446.      (and (>= emerge-current-difference 0)
  2447.           (< emerge-current-difference emerge-number-of-differences)))
  2448.     (diff (and valid-diff
  2449.            (aref emerge-difference-list emerge-current-difference)))
  2450.     (merge-line (emerge-line-number-in-buf 4 5))
  2451.     (A-line (emerge-eval-in-buffer emerge-A-buffer
  2452.                        (emerge-line-number-in-buf 0 1)))
  2453.     (B-line (emerge-eval-in-buffer emerge-B-buffer
  2454.                        (emerge-line-number-in-buf 2 3))))
  2455.     (message "At lines: merge = %d, A = %d, B = %d"
  2456.          merge-line A-line B-line)))
  2457.  
  2458. (defun emerge-line-number-in-buf (begin-marker end-marker)
  2459.   (let (temp)
  2460.     (setq temp (save-excursion
  2461.          (beginning-of-line)
  2462.          (1+ (count-lines 1 (point)))))
  2463.     (if valid-diff
  2464.     (progn
  2465.       (if (> (point) (aref diff begin-marker))
  2466.           (setq temp (- temp emerge-before-flag-lines)))
  2467.       (if (> (point) (aref diff end-marker))
  2468.           (setq temp (- temp emerge-after-flag-lines)))))
  2469.     temp))
  2470.  
  2471. (defun emerge-set-combine-template (string &optional localize)
  2472.   "Set `emerge-combine-versions-template' to STRING.
  2473. This value controls how `emerge-combine-versions' combines the two versions.
  2474. With prefix argument, `emerge-combine-versions-template' is made local to this
  2475. merge buffer.  Localization is permanent for any particular merge buffer."
  2476.   (interactive "s\nP")
  2477.   (if localize
  2478.       (make-local-variable 'emerge-combine-versions-template))
  2479.   (setq emerge-combine-versions-template string)
  2480.   (message
  2481.    (if (assq 'emerge-combine-versions-template (buffer-local-variables))
  2482.        "emerge-set-combine-versions-template set locally"
  2483.      "emerge-set-combine-versions-template set")))
  2484.  
  2485. (defun emerge-set-combine-versions-template (start end &optional localize)
  2486.   "Copy region into `emerge-combine-versions-template'.
  2487. This controls how `emerge-combine-versions' will combine the two versions.
  2488. With prefix argument, `emerge-combine-versions-template' is made local to this
  2489. merge buffer.  Localization is permanent for any particular merge buffer."
  2490.   (interactive "r\nP")
  2491.   (if localize
  2492.       (make-local-variable 'emerge-combine-versions-template))
  2493.   (setq emerge-combine-versions-template (buffer-substring start end))
  2494.   (message
  2495.    (if (assq 'emerge-combine-versions-template (buffer-local-variables))
  2496.        "emerge-set-combine-versions-template set locally."
  2497.      "emerge-set-combine-versions-template set.")))
  2498.  
  2499. (defun emerge-combine-versions (&optional force)
  2500.   "Combine versions using the template in `emerge-combine-versions-template'.
  2501. Refuses to function if this difference has been edited, i.e., if it is
  2502. neither the A nor the B variant.
  2503. An argument forces the variant to be selected even if the difference has
  2504. been edited."
  2505.   (interactive "P")
  2506.   (emerge-combine-versions-internal emerge-combine-versions-template force))
  2507.  
  2508. (defun emerge-combine-versions-register (char &optional force)
  2509.   "Combine the two versions using the template in register REG.
  2510. See documentation of the variable `emerge-combine-versions-template'
  2511. for how the template is interpreted.
  2512. Refuses to function if this difference has been edited, i.e., if it is
  2513. neither the A nor the B variant.
  2514. An argument forces the variant to be selected even if the difference has
  2515. been edited."
  2516.   (interactive "cRegister containing template: \nP")
  2517.   (let ((template (get-register char)))
  2518.     (if (not (stringp template))
  2519.     (error "Register does not contain text"))
  2520.     (emerge-combine-versions-internal template force)))
  2521.  
  2522. (defun emerge-combine-versions-internal (template force)
  2523.   (let ((operate
  2524.      (function (lambda ()
  2525.              (emerge-combine-versions-edit merge-begin merge-end
  2526.                            A-begin A-end B-begin B-end)
  2527.              (if emerge-auto-advance
  2528.              (emerge-next-difference))))))
  2529.     (emerge-select-version force operate operate operate)))
  2530.  
  2531. (defun emerge-combine-versions-edit (merge-begin merge-end
  2532.                      A-begin A-end B-begin B-end)
  2533.   (emerge-eval-in-buffer
  2534.    emerge-merge-buffer
  2535.    (delete-region merge-begin merge-end)
  2536.    (goto-char merge-begin)
  2537.    (let ((i 0))
  2538.      (while (< i (length template))
  2539.        (let ((c (aref template i)))
  2540.      (if (= c ?%)
  2541.          (progn
  2542.            (setq i (1+ i))
  2543.            (setq c 
  2544.              (condition-case nil
  2545.              (aref template i)
  2546.                (error ?%)))
  2547.            (cond ((= c ?a)
  2548.               (insert-buffer-substring emerge-A-buffer A-begin A-end))
  2549.              ((= c ?b) 
  2550.               (insert-buffer-substring emerge-B-buffer B-begin B-end))
  2551.              ((= c ?%) 
  2552.               (insert ?%))
  2553.              (t
  2554.               (insert c))))
  2555.        (insert c)))
  2556.        (setq i (1+ i))))
  2557.    (goto-char merge-begin)
  2558.    (aset diff-vector 6 'combined)
  2559.    (emerge-refresh-mode-line)))
  2560.  
  2561. (defun emerge-set-merge-mode (mode)
  2562.   "Set the major mode in a merge buffer.
  2563. Overrides any change that the mode might make to the mode line or local
  2564. keymap.  Leaves merge in fast mode."
  2565.   (interactive
  2566.    (list (intern (completing-read "New major mode for merge buffer: "
  2567.                   obarray 'commandp t nil))))
  2568.   (funcall mode)
  2569.   (emerge-refresh-mode-line)
  2570.   (if emerge-fast-mode
  2571.       (emerge-fast-mode)
  2572.     (emerge-edit-mode)))
  2573.  
  2574. (defun emerge-one-line-window ()
  2575.   (interactive)
  2576.   (let ((window-min-height 1))
  2577.     (shrink-window (- (window-height) 2))))
  2578.  
  2579. ;;; Support routines
  2580.  
  2581. ;; Select a difference by placing the visual flags around the appropriate
  2582. ;; group of lines in the A, B, and merge buffers
  2583. (defun emerge-select-difference (n)
  2584.   (let ((emerge-globalized-difference-list emerge-difference-list)
  2585.     (emerge-globalized-number-of-differences emerge-number-of-differences))
  2586.     (emerge-place-flags-in-buffer emerge-A-buffer n 0 1)
  2587.     (emerge-place-flags-in-buffer emerge-B-buffer n 2 3)
  2588.     (emerge-place-flags-in-buffer nil n 4 5))
  2589.   (run-hooks 'emerge-select-hook))
  2590.  
  2591. (defun emerge-place-flags-in-buffer (buffer difference before-index
  2592.                         after-index)
  2593.   (if buffer
  2594.       (emerge-eval-in-buffer
  2595.        buffer
  2596.        (emerge-place-flags-in-buffer1 difference before-index after-index))
  2597.     (emerge-place-flags-in-buffer1 difference before-index after-index)))
  2598.  
  2599. (defun emerge-place-flags-in-buffer1 (difference before-index after-index)
  2600.   (let ((buffer-read-only nil))
  2601.     ;; insert the flag before the difference
  2602.     (let ((before (aref (aref emerge-globalized-difference-list difference)
  2603.             before-index))
  2604.       here)
  2605.       (goto-char before)
  2606.       ;; insert the flag itself
  2607.       (insert-before-markers emerge-before-flag)
  2608.       (setq here (point))
  2609.       ;; Put the marker(s) referring to this position 1 character before the
  2610.       ;; end of the flag, so it won't be damaged by the user.
  2611.       ;; This gets a bit tricky, as there could be a number of markers
  2612.       ;; that have to be moved.
  2613.       (set-marker before (1- before))
  2614.       (let ((n (1- difference)) after-marker before-marker diff-list)
  2615.     (while (and
  2616.         (>= n 0)
  2617.         (progn
  2618.           (setq diff-list (aref emerge-globalized-difference-list n)
  2619.             after-marker (aref diff-list after-index))
  2620.           (= after-marker here)))
  2621.       (set-marker after-marker (1- after-marker))
  2622.       (setq before-marker (aref diff-list before-index))
  2623.       (if (= before-marker here)
  2624.           (setq before-marker (1- before-marker)))
  2625.       (setq n (1- n)))))
  2626.     ;; insert the flag after the difference
  2627.     (let* ((after (aref (aref emerge-globalized-difference-list difference)
  2628.             after-index))
  2629.        (here (marker-position after)))
  2630.       (goto-char here)
  2631.       ;; insert the flag itself
  2632.       (insert emerge-after-flag)
  2633.       ;; Put the marker(s) referring to this position 1 character after the
  2634.       ;; beginning of the flag, so it won't be damaged by the user.
  2635.       ;; This gets a bit tricky, as there could be a number of markers
  2636.       ;; that have to be moved.
  2637.       (set-marker after (1+ after))
  2638.       (let ((n (1+ difference)) before-marker after-marker diff-list)
  2639.     (while (and
  2640.         (< n emerge-globalized-number-of-differences)
  2641.         (progn
  2642.           (setq diff-list (aref emerge-globalized-difference-list n)
  2643.             before-marker (aref diff-list before-index))
  2644.           (= before-marker here)))
  2645.       (set-marker before-marker (1+ before-marker))
  2646.       (setq after-marker (aref diff-list after-index))
  2647.       (if (= after-marker here)
  2648.           (setq after-marker (1+ after-marker)))
  2649.       (setq n (1+ n)))))))
  2650.  
  2651. ;; Unselect a difference by removing the visual flags in the buffers.
  2652. (defun emerge-unselect-difference (n)
  2653.   (let ((diff-vector (aref emerge-difference-list n)))
  2654.     (emerge-remove-flags-in-buffer emerge-A-buffer
  2655.                    (aref diff-vector 0) (aref diff-vector 1))
  2656.     (emerge-remove-flags-in-buffer emerge-B-buffer
  2657.                    (aref diff-vector 2) (aref diff-vector 3))
  2658.     (emerge-remove-flags-in-buffer emerge-merge-buffer
  2659.                    (aref diff-vector 4) (aref diff-vector 5)))
  2660.   (run-hooks 'emerge-unselect-hook))
  2661.  
  2662. (defun emerge-remove-flags-in-buffer (buffer before after)
  2663.   (emerge-eval-in-buffer
  2664.    buffer
  2665.    (let ((buffer-read-only nil))
  2666.      ;; remove the flags, if they're there
  2667.      (goto-char (- before (1- emerge-before-flag-length)))
  2668.      (if (looking-at emerge-before-flag-match)
  2669.      (delete-char emerge-before-flag-length)
  2670.        ;; the flag isn't there
  2671.        (ding)
  2672.        (message "Trouble removing flag"))
  2673.      (goto-char (1- after))
  2674.      (if (looking-at emerge-after-flag-match)
  2675.      (delete-char emerge-after-flag-length)
  2676.        ;; the flag isn't there
  2677.        (ding)
  2678.        (message "Trouble removing flag")))))
  2679.  
  2680. ;; Select a difference, removing any flags that exist now.
  2681. (defun emerge-unselect-and-select-difference (n &optional suppress-display)
  2682.   (if (and (>= emerge-current-difference 0)
  2683.        (< emerge-current-difference emerge-number-of-differences))
  2684.       (emerge-unselect-difference emerge-current-difference))
  2685.   (if (and (>= n 0) (< n emerge-number-of-differences))
  2686.       (progn
  2687.     (emerge-select-difference n)
  2688.     (let* ((diff-vector (aref emerge-difference-list n))
  2689.            (selection-type (aref diff-vector 6)))
  2690.       (if (eq selection-type 'default-A)
  2691.           (aset diff-vector 6 'A)
  2692.         (if (eq selection-type 'default-B)
  2693.         (aset diff-vector 6 'B))))))
  2694.   (setq emerge-current-difference n)
  2695.   (if (not suppress-display)
  2696.       (progn
  2697.     (emerge-recenter)
  2698.     (emerge-refresh-mode-line))))
  2699.  
  2700. ;; Perform tests to see whether user should be allowed to select a version
  2701. ;; of this difference:
  2702. ;;   a valid difference has been selected; and
  2703. ;;   the difference text in the merge buffer is:
  2704. ;;     the A version (execute a-version), or
  2705. ;;     the B version (execute b-version), or
  2706. ;;     empty (execute neither-version), or
  2707. ;;     argument FORCE is true (execute neither-version)
  2708. ;; Otherwise, signal an error.
  2709. (defun emerge-select-version (force a-version b-version neither-version)
  2710.   (emerge-validate-difference)
  2711.   (let ((buffer-read-only nil))
  2712.     (let* ((diff-vector
  2713.         (aref emerge-difference-list emerge-current-difference))
  2714.        (A-begin (1+ (aref diff-vector 0)))
  2715.        (A-end (1- (aref diff-vector 1)))
  2716.        (B-begin (1+ (aref diff-vector 2)))
  2717.        (B-end (1- (aref diff-vector 3)))
  2718.        (merge-begin (1+ (aref diff-vector 4)))
  2719.        (merge-end (1- (aref diff-vector 5))))
  2720.       (if (emerge-compare-buffers emerge-A-buffer A-begin A-end
  2721.                   emerge-merge-buffer merge-begin
  2722.                   merge-end)
  2723.       (funcall a-version)
  2724.     (if (emerge-compare-buffers emerge-B-buffer B-begin B-end
  2725.                     emerge-merge-buffer merge-begin
  2726.                     merge-end)
  2727.         (funcall b-version)
  2728.       (if (or force (= merge-begin merge-end))
  2729.           (funcall neither-version)
  2730.         (error "This difference region has been edited")))))))
  2731.  
  2732. ;; Read a file name, handling all of the various defaulting rules.
  2733.  
  2734. (defun emerge-read-file-name (prompt alternative-default-dir default-file
  2735.                   A-file)
  2736.   ;; `prompt' should not have trailing ": ", so that it can be modified
  2737.   ;; according to context.
  2738.   ;; If alternative-default-dir is non-nil, it should be used as the default
  2739.   ;; directory instead if default-directory, if emerge-default-last-directories
  2740.   ;; is set.
  2741.   ;; If default-file is set, it should be used as the default value.
  2742.   ;; If A-file is set, and its directory is different from
  2743.   ;; alternative-default-dir, and if emerge-default-last-directories is set,
  2744.   ;; the default file should be the last part of A-file in the default
  2745.   ;; directory.  (Overriding default-file.)
  2746.   (cond
  2747.    ;; If this is not the A-file argument (shown by non-nil A-file), and
  2748.    ;; if emerge-default-last-directories is set, and
  2749.    ;; the default directory exists but is not the same as the directory of the
  2750.    ;; A-file,
  2751.    ;; then make the default file have the same name as the A-file, but in
  2752.    ;; the default directory.
  2753.    ((and emerge-default-last-directories
  2754.      A-file
  2755.      alternative-default-dir
  2756.      (not (string-equal alternative-default-dir
  2757.                 (file-name-directory A-file))))
  2758.     (read-file-name (format "%s (default %s): "
  2759.                 prompt (file-name-nondirectory A-file))
  2760.             alternative-default-dir
  2761.             (concat alternative-default-dir
  2762.                 (file-name-nondirectory A-file))
  2763.             'confirm))
  2764.    ;; If there is a default file, use it.
  2765.    (default-file
  2766.      (read-file-name (format "%s (default %s): " prompt default-file)
  2767.              ;; If emerge-default-last-directories is set, use the
  2768.              ;; directory from the same argument of the last call of
  2769.              ;; Emerge as the default for this argument.
  2770.              (and emerge-default-last-directories
  2771.               alternative-default-dir)
  2772.              default-file 'confirm))
  2773.    (t
  2774.     (read-file-name (concat prompt ": ")
  2775.             ;; If emerge-default-last-directories is set, use the
  2776.             ;; directory from the same argument of the last call of
  2777.             ;; Emerge as the default for this argument.
  2778.             (and emerge-default-last-directories
  2779.              alternative-default-dir)
  2780.             nil 'confirm))))
  2781.  
  2782. ;; Revise the mode line to display which difference we have selected
  2783.  
  2784. (defun emerge-refresh-mode-line ()
  2785.   (setq mode-line-buffer-identification
  2786.     (list (format "Emerge: %%b   diff %d of %d%s"
  2787.               (1+ emerge-current-difference)
  2788.               emerge-number-of-differences
  2789.               (if (and (>= emerge-current-difference 0)
  2790.                    (< emerge-current-difference
  2791.                   emerge-number-of-differences))
  2792.               (cdr (assq (aref (aref emerge-difference-list
  2793.                          emerge-current-difference)
  2794.                        6)
  2795.                      '((A . " - A")
  2796.                        (B . " - B")
  2797.                        (prefer-A . " - A*")
  2798.                        (prefer-B . " - B*")
  2799.                        (combined . " - comb"))))
  2800.             ""))))
  2801.   ;; Force mode-line redisplay
  2802.   (set-buffer-modified-p (buffer-modified-p)))
  2803.  
  2804. ;; compare two regions in two buffers for containing the same text
  2805. (defun emerge-compare-buffers (buffer-x x-begin x-end buffer-y y-begin y-end)
  2806.   ;; first check that the two regions are the same length
  2807.   (if (not (and (= (- x-end x-begin) (- y-end y-begin))))
  2808.       nil
  2809.     (catch 'exit
  2810.       (while (< x-begin x-end)
  2811.     ;; bite off and compare no more than 1000 characters at a time
  2812.     (let* ((compare-length (min (- x-end x-begin) 1000))
  2813.            (x-string (emerge-eval-in-buffer 
  2814.               buffer-x
  2815.               (buffer-substring x-begin
  2816.                         (+ x-begin compare-length))))
  2817.            (y-string (emerge-eval-in-buffer
  2818.               buffer-y
  2819.               (buffer-substring y-begin
  2820.                         (+ y-begin compare-length)))))
  2821.       (if (not (string-equal x-string y-string))
  2822.           (throw 'exit nil)
  2823.         (setq x-begin (+ x-begin compare-length))
  2824.         (setq y-begin (+ y-begin compare-length)))))
  2825.       t)))
  2826.  
  2827. ;; Construct a unique buffer name.
  2828. ;; The first one tried is prefixsuffix, then prefix<2>suffix, 
  2829. ;; prefix<3>suffix, etc.
  2830. (defun emerge-unique-buffer-name (prefix suffix)
  2831.   (if (null (get-buffer (concat prefix suffix)))
  2832.       (concat prefix suffix)
  2833.     (let ((n 2))
  2834.       (while (get-buffer (format "%s<%d>%s" prefix n suffix))
  2835.     (setq n (1+ n)))
  2836.       (format "%s<%d>%s" prefix n suffix))))
  2837.  
  2838. ;; Verify that we have a difference selected.
  2839. (defun emerge-validate-difference ()
  2840.   (if (not (and (>= emerge-current-difference 0)
  2841.         (< emerge-current-difference emerge-number-of-differences)))
  2842.       (error "No difference selected")))
  2843.  
  2844. ;;; Functions for saving and restoring a batch of variables
  2845.  
  2846. ;; These functions save (get the values of) and restore (set the values of)
  2847. ;; a list of variables.  The argument is a list of symbols (the names of
  2848. ;; the variables).  A list element can also be a list of two functions,
  2849. ;; the first of which (when called with no arguments) gets the value, and
  2850. ;; the second (when called with a value as an argment) sets the value.
  2851. ;; A "function" is anything that funcall can handle as an argument.
  2852.  
  2853. (defun emerge-save-variables (vars)
  2854.   (mapcar (function (lambda (v) (if (symbolp v)
  2855.                     (symbol-value v)
  2856.                   (funcall (car v)))))
  2857.       vars))
  2858.  
  2859. (defun emerge-restore-variables (vars values)
  2860.   (while vars
  2861.     (let ((var (car vars))
  2862.       (value (car values)))
  2863.       (if (symbolp var)
  2864.       (set var value)
  2865.     (funcall (car (cdr var)) value)))
  2866.     (setq vars (cdr vars))
  2867.     (setq values (cdr values))))
  2868.  
  2869. ;; Make a temporary file that only we have access to.
  2870. ;; PREFIX is appended to emerge-temp-file-prefix to make the filename prefix.
  2871. (defun emerge-make-temp-file (prefix)
  2872.   (let ((f (make-temp-name (concat emerge-temp-file-prefix prefix))))
  2873.     ;; create the file
  2874.     (write-region (point-min) (point-min) f nil 'no-message)
  2875.     (set-file-modes f emerge-temp-file-mode)
  2876.     f))
  2877.  
  2878. ;;; Functions that query the user before he can write out the current buffer.
  2879.  
  2880. (defun emerge-query-write-file ()
  2881.   "Ask the user whether to write out an incomplete merge.
  2882. If answer is yes, call `write-file' to do so.  See `emerge-query-and-call'
  2883. for details of the querying process."
  2884.   (interactive)
  2885.   (emerge-query-and-call 'write-file))
  2886.  
  2887. (defun emerge-query-save-buffer ()
  2888.   "Ask the user whether to save an incomplete merge.
  2889. If answer is yes, call `save-buffer' to do so.  See `emerge-query-and-call'
  2890. for details of the querying process."
  2891.   (interactive)
  2892.   (emerge-query-and-call 'save-buffer))
  2893.  
  2894. (defun emerge-query-and-call (command)
  2895.   "Ask the user whether to save or write out the incomplete merge.
  2896. If answer is yes, call COMMAND interactively.  During the call, the flags
  2897. around the current difference are removed."
  2898.   (if (yes-or-no-p "Do you really write to write out this unfinished merge? ")
  2899.       ;; He really wants to do it -- unselect the difference for the duration
  2900.       (progn
  2901.     (if (and (>= emerge-current-difference 0)
  2902.          (< emerge-current-difference emerge-number-of-differences))
  2903.         (emerge-unselect-difference emerge-current-difference))
  2904.     ;; call-interactively takes the value of current-prefix-arg as the
  2905.     ;; prefix argument value to be passed to the command.  Thus, we have
  2906.     ;; to do nothing special to make sure the prefix argument is
  2907.     ;; transmitted to the command.
  2908.     (call-interactively command)
  2909.     (if (and (>= emerge-current-difference 0)
  2910.          (< emerge-current-difference emerge-number-of-differences))
  2911.         (progn
  2912.           (emerge-select-difference emerge-current-difference)
  2913.           (emerge-recenter))))
  2914.     ;; He's being smart and not doing it
  2915.     (message "Not written")))
  2916.  
  2917. ;; Make sure the current buffer (for a file) has the same contents as the
  2918. ;; file on disk, and attempt to remedy the situation if not.
  2919. ;; Signal an error if we can't make them the same, or the user doesn't want
  2920. ;; to do what is necessary to make them the same.
  2921. (defun emerge-verify-file-buffer ()
  2922.   ;; First check if the file has been modified since the buffer visited it.
  2923.   (if (verify-visited-file-modtime (current-buffer))
  2924.       (if (buffer-modified-p)
  2925.       ;; If buffer is not obsolete and is modified, offer to save
  2926.       (if (yes-or-no-p (format "Save file %s? " buffer-file-name))
  2927.           (save-buffer)
  2928.         (error "Buffer out of sync for file %s" buffer-file-name))
  2929.     ;; If buffer is not obsolete and is not modified, do nothing
  2930.     nil)
  2931.     (if (buffer-modified-p)
  2932.     ;; If buffer is obsolete and is modified, give error
  2933.     (error "Buffer out of sync for file %s" buffer-file-name)
  2934.       ;; If buffer is obsolete and is not modified, offer to revert
  2935.       (if (yes-or-no-p (format "Revert file %s? " buffer-file-name))
  2936.           (revert-buffer t t)
  2937.     (error "Buffer out of sync for file %s" buffer-file-name)))))
  2938.  
  2939. ;; Utilities that might have value outside of Emerge.
  2940.  
  2941. ;; Set up the mode in the current buffer to duplicate the mode in another
  2942. ;; buffer.
  2943. (defun emerge-copy-modes (buffer)
  2944.   ;; Set the major mode
  2945.   (funcall (emerge-eval-in-buffer buffer major-mode)))
  2946.  
  2947. ;; Define a key, even if a prefix of it is defined
  2948. (defun emerge-force-define-key (keymap key definition)
  2949.   "Like `define-key', but forcibly creates prefix characters as needed.
  2950. If some prefix of KEY has a non-prefix definition, it is redefined."
  2951.   ;; Find out if a prefix of key is defined
  2952.   (let ((v (lookup-key keymap key)))
  2953.     ;; If so, undefine it
  2954.     (if (integerp v)
  2955.     (define-key keymap (substring key 0 v) nil)))
  2956.   ;; Now define the key
  2957.   (define-key keymap key definition))
  2958.  
  2959. ;;;;; Improvements to describe-mode, so that it describes minor modes as well
  2960. ;;;;; as the major mode
  2961. ;;(defun describe-mode (&optional minor)
  2962. ;;  "Display documentation of current major mode.
  2963. ;;If optional arg MINOR is non-nil (or prefix argument is given if interactive),
  2964. ;;display documentation of active minor modes as well.
  2965. ;;For this to work correctly for a minor mode, the mode's indicator variable
  2966. ;;\(listed in `minor-mode-alist') must also be a function whose documentation
  2967. ;;describes the minor mode."
  2968. ;;  (interactive)
  2969. ;;  (with-output-to-temp-buffer "*Help*"
  2970. ;;    (princ mode-name)
  2971. ;;    (princ " Mode:\n")
  2972. ;;    (princ (documentation major-mode))
  2973. ;;    (let ((minor-modes minor-mode-alist)
  2974. ;;      (locals (buffer-local-variables)))
  2975. ;;      (while minor-modes
  2976. ;;    (let* ((minor-mode (car (car minor-modes)))
  2977. ;;           (indicator (car (cdr (car minor-modes))))
  2978. ;;           (local-binding (assq minor-mode locals)))
  2979. ;;      ;; Document a minor mode if it is listed in minor-mode-alist,
  2980. ;;      ;; bound locally in this buffer, non-nil, and has a function
  2981. ;;      ;; definition.
  2982. ;;      (if (and local-binding
  2983. ;;           (cdr local-binding)
  2984. ;;           (fboundp minor-mode))
  2985. ;;          (progn
  2986. ;;        (princ (format "\n\n\n%s minor mode (indicator%s):\n"
  2987. ;;                   minor-mode indicator))
  2988. ;;        (princ (documentation minor-mode)))))
  2989. ;;    (setq minor-modes (cdr minor-modes))))
  2990. ;;    (print-help-return-message)))
  2991.  
  2992. ;; This goes with the redefinition of describe-mode.
  2993. ;;;; Adjust things so that keyboard macro definitions are documented correctly.
  2994. ;;(fset 'defining-kbd-macro (symbol-function 'start-kbd-macro))
  2995.  
  2996. ;; substitute-key-definition should work now.
  2997. ;;;; Function to shadow a definition in a keymap with definitions in another.
  2998. ;;(defun emerge-shadow-key-definition (olddef newdef keymap shadowmap)
  2999. ;;  "Shadow OLDDEF with NEWDEF for any keys in KEYMAP with entries in SHADOWMAP.
  3000. ;;In other words, SHADOWMAP will now shadow all definitions of OLDDEF in KEYMAP
  3001. ;;with NEWDEF.  Does not affect keys that are already defined in SHADOWMAP,
  3002. ;;including those whose definition is OLDDEF."
  3003. ;;  ;; loop through all keymaps accessible from keymap
  3004. ;;  (let ((maps (accessible-keymaps keymap)))
  3005. ;;    (while maps
  3006. ;;      (let ((prefix (car (car maps)))
  3007. ;;        (map (cdr (car maps))))
  3008. ;;    ;; examine a keymap
  3009. ;;    (if (arrayp map)
  3010. ;;        ;; array keymap
  3011. ;;        (let ((len (length map))
  3012. ;;          (i 0))
  3013. ;;          (while (< i len)
  3014. ;;        (if (eq (aref map i) olddef)
  3015. ;;            ;; set the shadowing definition
  3016. ;;            (let ((key (concat prefix (char-to-string i))))
  3017. ;;              (emerge-define-key-if-possible shadowmap key newdef)))
  3018. ;;        (setq i (1+ i))))
  3019. ;;      ;; sparse keymap
  3020. ;;      (while map
  3021. ;;        (if (eq (cdr-safe (car-safe map)) olddef)
  3022. ;;        ;; set the shadowing definition
  3023. ;;        (let ((key
  3024. ;;               (concat prefix (char-to-string (car (car map))))))
  3025. ;;              (emerge-define-key-if-possible shadowmap key newdef)))
  3026. ;;        (setq map (cdr map)))))
  3027. ;;      (setq maps (cdr maps)))))
  3028.  
  3029. ;; Define a key if it (or a prefix) is not already defined in the map.
  3030. (defun emerge-define-key-if-possible (keymap key definition)
  3031.   ;; look up the present definition of the key
  3032.   (let ((present (lookup-key keymap key)))
  3033.     (if (integerp present)
  3034.     ;; if it is "too long", look up the valid prefix
  3035.     (if (not (lookup-key keymap (substring key 0 present)))
  3036.         ;; if the prefix isn't defined, define it
  3037.         (define-key keymap key definition))
  3038.       ;; if there is no present definition, define it
  3039.       (if (not present)
  3040.       (define-key keymap key definition)))))
  3041.  
  3042. ;; Ordinary substitute-key-definition should do this now.
  3043. ;;(defun emerge-recursively-substitute-key-definition (olddef newdef keymap)
  3044. ;;  "Like `substitute-key-definition', but act recursively on subkeymaps.
  3045. ;;Make sure that subordinate keymaps aren't shared with other keymaps!
  3046. ;;\(`copy-keymap' will suffice.)"
  3047. ;;  ;; Loop through all keymaps accessible from keymap
  3048. ;;  (let ((maps (accessible-keymaps keymap)))
  3049. ;;    (while maps
  3050. ;;      ;; Substitute in this keymap
  3051. ;;      (substitute-key-definition olddef newdef (cdr (car maps)))
  3052. ;;      (setq maps (cdr maps)))))
  3053.  
  3054. ;; Show the name of the file in the buffer.
  3055. (defun emerge-show-file-name ()
  3056.   "Displays the name of the file loaded into the current buffer.
  3057. If the name won't fit on one line, the minibuffer is expanded to hold it,
  3058. and the command waits for a keystroke from the user.  If the keystroke is
  3059. SPC, it is ignored; if it is anything else, it is processed as a command."
  3060.   (interactive)
  3061.   (let ((name (buffer-file-name)))
  3062.     (or name
  3063.     (setq name "Buffer has no file name."))
  3064.     (save-window-excursion
  3065.       (select-window (minibuffer-window))
  3066.       (erase-buffer)
  3067.       (insert name)
  3068.       (if (not (pos-visible-in-window-p))
  3069.       (let ((echo-keystrokes 0))
  3070.         (while (and (not (pos-visible-in-window-p))
  3071.             (> (1- (screen-height)) (window-height)))
  3072.           (enlarge-window 1))
  3073.         (let ((c (read-event)))
  3074.           (if (not (eq c 32))
  3075.           (setq unread-command-events (list c)))))))))
  3076.  
  3077. ;; Improved auto-save file names.
  3078. ;; This function fixes many problems with the standard auto-save file names:
  3079. ;; Auto-save files for non-file buffers get put in the default directory
  3080. ;; for the buffer, whether that makes sense or not.
  3081. ;; Auto-save files for file buffers get put in the directory of the file,
  3082. ;; regardless of whether we can write into it or not.
  3083. ;; Auto-save files for non-file buffers don't use the process id, so if a
  3084. ;; user runs more than on Emacs, they can make auto-save files that overwrite
  3085. ;; each other.
  3086. ;; To use this function, do:
  3087. ;;    (fset 'make-auto-save-file-name
  3088. ;;          (symbol-function 'emerge-make-auto-save-file-name))
  3089. (defun emerge-make-auto-save-file-name ()
  3090.   "Return file name to use for auto-saves of current buffer.
  3091. Does not consider `auto-save-visited-file-name';
  3092. that is checked before calling this function.
  3093. You can redefine this for customization.
  3094. See also `auto-save-file-name-p'."
  3095.   (if buffer-file-name
  3096.       ;; if buffer has a file, try the format <file directory>/#<file name>#
  3097.       (let ((f (concat (file-name-directory buffer-file-name)
  3098.                "#"
  3099.                (file-name-nondirectory buffer-file-name)
  3100.                "#")))
  3101.     (if (file-writable-p f)
  3102.         ;; the file is writable, so use it
  3103.         f
  3104.       ;; the file isn't writable, so use the format
  3105.       ;; ~/#&<file name>&<hash of directory>#
  3106.       (concat (getenv "HOME")
  3107.           "/#&"
  3108.           (file-name-nondirectory buffer-file-name)
  3109.           "&"
  3110.           (emerge-hash-string-into-string
  3111.            (file-name-directory buffer-file-name))
  3112.           "#")))
  3113.     ;; if buffer has no file, use the format ~/#%<buffer name>%<process id>#
  3114.     (expand-file-name (concat (getenv "HOME")
  3115.                   "/#%"
  3116.                   ;; quote / into \! and \ into \\
  3117.                   (emerge-unslashify-name (buffer-name))
  3118.                   "%"
  3119.                   (make-temp-name "")
  3120.                   "#"))))
  3121.  
  3122. ;; Hash a string into five characters more-or-less suitable for use in a file
  3123. ;; name.  (Allowed characters are ! through ~, except /.)
  3124. (defun emerge-hash-string-into-string (s)
  3125.   (let ((bins (vector 0 0 0 0 0))
  3126.     (i 0))
  3127.     (while (< i (length s))
  3128.       (aset bins (% i 5) (% (+ (* (aref bins (% i 5)) 35)
  3129.                    (aref s i))
  3130.                 65536))
  3131.       (setq i (1+ i)))
  3132.     (mapconcat (function (lambda (b)
  3133.                (setq b (+ (% b 93) ?!))
  3134.                (if (>= b ?/)
  3135.                    (setq b (1+ b)))
  3136.                (char-to-string b)))
  3137.            bins "")))
  3138.  
  3139. ;; Quote any /s in a string by replacing them with \!.
  3140. ;; Also, replace any \s by \\, to make it one-to-one.
  3141. (defun emerge-unslashify-name (s)
  3142.   (let ((limit 0))
  3143.     (while (string-match "[/\\]" s limit)
  3144.       (setq s (concat (substring s 0 (match-beginning 0))
  3145.               (if (string= (substring s (match-beginning 0)
  3146.                           (match-end 0))
  3147.                    "/")
  3148.               "\\!"
  3149.             "\\\\")
  3150.               (substring s (match-end 0))))
  3151.       (setq limit (1+ (match-end 0)))))
  3152.   s)
  3153.  
  3154. ;; Metacharacters that have to be protected from the shell when executing
  3155. ;; a diff/diff3 command.
  3156. (defvar emerge-metachars "[ \t\n!\"#$&'()*;<=>?[\\^`{|~]"
  3157.   "Characters that must be quoted with \\ when used in a shell command line.
  3158. More precisely, a [...] regexp to match any one such character.")
  3159.  
  3160. ;; Quote metacharacters (using \) when executing a diff/diff3 command.
  3161. (defun emerge-protect-metachars (s)
  3162.   (let ((limit 0))
  3163.     (while (string-match emerge-metachars s limit)
  3164.       (setq s (concat (substring s 0 (match-beginning 0))
  3165.               "\\"
  3166.               (substring s (match-beginning 0))))
  3167.       (setq limit (1+ (match-end 0)))))
  3168.   s)
  3169.  
  3170. (provide 'emerge)
  3171.  
  3172. ;;; emerge.el ends here
  3173.