1 ;;; emerge.el --- merge diffs under Emacs control
3 ;;; The author has placed this file in the public domain.
5 ;; Author: Dale R. Worley <drw@math.mit.edu>
7 ;; Keywords: unix, tools
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.
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
24 ;;;###autoload (autoload 'menu-bar-emerge-map "emerge" nil t 'keymap)
26 (defvar menu-bar-emerge-menu (make-sparse-keymap "menu-bar-emerge-map"))
27 (fset 'menu-bar-emerge-map (symbol-value 'menu-bar-emerge-map))
29 (define-key menu-bar-emerge-menu [emerge-merge-directories]
30 '("Merge Directories ..." . emerge-merge-directories))
31 (define-key menu-bar-emerge-menu [emerge-revisions-with-ancestor]
32 '("Revisions with Ancestor ..." . emerge-revisions-with-ancestor))
33 (define-key menu-bar-emerge-menu [emerge-revisions]
34 '("Revisions ..." . emerge-revisions))
35 (define-key menu-bar-emerge-menu [emerge-files-with-ancestor]
36 '("Files with Ancestor ..." . emerge-files-with-ancestor))
37 (define-key menu-bar-emerge-menu [emerge-files]
38 '("Files ..." . emerge-files))
39 (define-key menu-bar-emerge-menu [emerge-buffers-with-ancestor]
40 '("Buffers with Ancestor ..." . emerge-buffers-with-ancestor))
41 (define-key menu-bar-emerge-menu [emerge-buffers]
42 '("Buffers ..." . emerge-buffers))
46 (defmacro emerge-eval-in-buffer (buffer &rest forms)
47 "Macro to switch to BUFFER, evaluate FORMS, returns to original buffer.
48 Differs from `save-excursion' in that it doesn't save the point and mark."
49 (` (let ((StartBuffer (current-buffer)))
52 (set-buffer (, buffer))
54 (set-buffer StartBuffer)))))
56 (defmacro emerge-defvar-local (var value doc)
57 "Defines SYMBOL as an advertised variable.
58 Performs a defvar, then executes `make-variable-buffer-local' on
59 the variable. Also sets the `preserved' property, so that
60 `kill-all-local-variables' (called by major-mode setting commands)
61 won't destroy Emerge control variables."
63 (defvar (, var) (, value) (, doc))
64 (make-variable-buffer-local '(, var))
65 (put '(, var) 'preserved t))))
67 ;; Add entries to minor-mode-alist so that emerge modes show correctly
68 (defvar emerge-minor-modes-list
69 '((emerge-mode " Emerge")
70 (emerge-fast-mode " F")
71 (emerge-edit-mode " E")
72 (emerge-auto-advance " A")
73 (emerge-skip-prefers " S")))
74 (if (not (assq 'emerge-mode minor-mode-alist))
75 (setq minor-mode-alist (append emerge-minor-modes-list
78 ;; We need to define this function so describe-mode can describe Emerge mode.
80 "Emerge mode is used by the Emerge file-merging package.
81 It is entered only through one of the functions:
83 `emerge-files-with-ancestor'
85 `emerge-buffers-with-ancestor'
86 `emerge-files-command'
87 `emerge-files-with-ancestor-command'
89 `emerge-files-with-ancestor-remote'
92 \\{emerge-basic-keymap}
93 Commands must be prefixed by \\<emerge-fast-keymap>\\[emerge-basic-keymap] in `edit' mode,
94 but can be invoked directly in `fast' mode.")
96 (defvar emerge-version "5fsf"
97 "The version of Emerge.")
99 (defun emerge-version ()
100 "Return string describing the version of Emerge.
101 When called interactively, displays the version."
104 (message "Emerge version %s" (emerge-version))
107 ;;; Emerge configuration variables
109 ;; Commands that produce difference files
110 ;; All that can be configured is the name of the programs to execute
111 ;; (emerge-diff-program and emerge-diff3-program) and the options
112 ;; to be provided (emerge-diff-options). The order in which the file names
113 ;; are given is fixed.
114 ;; The file names are always expanded (see expand-file-name) before being
115 ;; passed to diff, thus they need not be invoked under a shell that
117 ;; The code which processes the diff/diff3 output depends on all the
118 ;; finicky details of their output, including the somewhat strange
119 ;; way they number lines of a file.
120 (defvar emerge-diff-program "diff"
121 "*Name of the program which compares two files.")
122 (defvar emerge-diff3-program "diff3"
123 "*Name of the program which compares three files.
124 Its arguments are the ancestor file and the two variant files.")
125 (defvar emerge-diff-options ""
126 "*Options to pass to `emerge-diff-program' and `emerge-diff3-program'.")
127 (defvar emerge-match-diff-line (let ((x "\\([0-9]+\\)\\(\\|,\\([0-9]+\\)\\)"))
128 (concat "^" x "\\([acd]\\)" x "$"))
129 "*Pattern to match lines produced by diff that describe differences.
130 This is as opposed to lines from the source files.")
131 (defvar emerge-diff-ok-lines-regexp
132 "^\\([0-9,]+[acd][0-9,]+$\\|[<>] \\|---\\)"
133 "*Regexp that matches normal output lines from `emerge-diff-program'.
134 Lines that do not match are assumed to be error messages.")
135 (defvar emerge-diff3-ok-lines-regexp
136 "^\\([1-3]:\\|====\\| \\)"
137 "*Regexp that matches normal output lines from `emerge-diff3-program'.
138 Lines that do not match are assumed to be error messages.")
140 (defvar emerge-rcs-ci-program "ci"
141 "*Name of the program that checks in RCS revisions.")
142 (defvar emerge-rcs-co-program "co"
143 "*Name of the program that checks out RCS revisions.")
145 (defvar emerge-process-local-variables nil
146 "*Non-nil if Emerge should process local-variables lists in merge buffers.
147 \(You can explicitly request processing the local-variables
148 by executing `(hack-local-variables)'.)")
149 (defvar emerge-execute-line-deletions nil
150 "*If non-nil: `emerge-execute-line' makes no output if an input was deleted.
151 It concludes that an input version has been deleted when an ancestor entry
152 is present, only one A or B entry is present, and an output entry is present.
153 If nil: In such circumstances, the A or B file that is present will be
154 copied to the designated output file.")
156 (defvar emerge-before-flag "vvvvvvvvvvvvvvvvvvvv\n"
157 "*Flag placed above the highlighted block of code. Must end with newline.
158 Must be set before Emerge is loaded, or emerge-new-flags must be run
160 (defvar emerge-after-flag "^^^^^^^^^^^^^^^^^^^^\n"
161 "*Flag placed below the highlighted block of code. Must end with newline.
162 Must be set before Emerge is loaded, or emerge-new-flags must be run
167 (defvar emerge-startup-hook nil
168 "*Hook to run in the merge buffer after the merge has been set up.")
169 (defvar emerge-select-hook nil
170 "*Hook to run after a difference has been selected.
171 The variable `n' holds the (internal) number of the difference.")
172 (defvar emerge-unselect-hook nil
173 "*Hook to run after a difference has been unselected.
174 The variable `n' holds the (internal) number of the difference.")
176 ;; Variables to control the default directories of the arguments to
179 (defvar emerge-default-last-directories nil
180 "*If nil, default dir for filenames in emerge is `default-directory'.
181 If non-nil, filenames complete in the directory of the last argument of the
182 same type to an `emerge-files...' command.")
184 (defvar emerge-last-dir-A nil
185 "Last directory for the first file of an `emerge-files...' command.")
186 (defvar emerge-last-dir-B nil
187 "Last directory for the second file of an `emerge-files...' command.")
188 (defvar emerge-last-dir-ancestor nil
189 "Last directory for the ancestor file of an `emerge-files...' command.")
190 (defvar emerge-last-dir-output nil
191 "Last directory for the output file of an `emerge-files...' command.")
192 (defvar emerge-last-revision-A nil
193 "Last RCS revision used for first file of an `emerge-revisions...' command.")
194 (defvar emerge-last-revision-B nil
195 "Last RCS revision used for second file of an `emerge-revisions...' command.")
196 (defvar emerge-last-revision-ancestor nil
197 "Last RCS revision used for ancestor file of an `emerge-revisions...' command.")
199 (defvar emerge-before-flag-length)
200 (defvar emerge-before-flag-lines)
201 (defvar emerge-before-flag-match)
202 (defvar emerge-after-flag-length)
203 (defvar emerge-after-flag-lines)
204 (defvar emerge-after-flag-match)
205 (defvar emerge-diff-buffer)
206 (defvar emerge-diff-error-buffer)
207 (defvar emerge-prefix-argument)
208 (defvar emerge-file-out)
209 (defvar emerge-exit-func)
210 (defvar emerge-globalized-difference-list)
211 (defvar emerge-globalized-number-of-differences)
213 ;; The flags used to mark differences in the buffers.
215 ;; These function definitions need to be up here, because they are used
217 (defun emerge-new-flags ()
218 "Function to be called after `emerge-{before,after}-flag'.
219 This is called after these functions are changed to compute values that
220 depend on the flags."
221 (setq emerge-before-flag-length (length emerge-before-flag))
222 (setq emerge-before-flag-lines
223 (emerge-count-matches-string emerge-before-flag "\n"))
224 (setq emerge-before-flag-match (regexp-quote emerge-before-flag))
225 (setq emerge-after-flag-length (length emerge-after-flag))
226 (setq emerge-after-flag-lines
227 (emerge-count-matches-string emerge-after-flag "\n"))
228 (setq emerge-after-flag-match (regexp-quote emerge-after-flag)))
230 (defun emerge-count-matches-string (string regexp)
231 "Return the number of matches in STRING for REGEXP."
234 (while (string-match regexp string i)
235 (setq count (1+ count))
236 (setq i (match-end 0)))
239 ;; Calculate dependent variables
242 (defvar emerge-min-visible-lines 3
243 "*Number of lines that we want to show above and below the flags when we are
244 displaying a difference.")
246 (defvar emerge-temp-file-prefix
247 (let ((env (getenv "TMPDIR"))
249 (setq d (if (and env (> (length env) 0))
252 (if (= (aref d (1- (length d))) ?/)
253 (setq d (substring d 0 -1)))
254 (concat d "/emerge"))
255 "*Prefix to put on Emerge temporary file names.
256 Do not start with `~/' or `~user-name/'.")
258 (defvar emerge-temp-file-mode 384 ; u=rw only
259 "*Mode for Emerge temporary files.")
261 (defvar emerge-combine-versions-template
262 "#ifdef NEW\n%b#else /* NEW */\n%a#endif /* NEW */\n"
263 "*Template for `emerge-combine-versions' to combine the two versions.
264 The template is inserted as a string, with the following interpolations:
265 %a the A version of the difference
266 %b the B version of the difference
268 Don't forget to end the template with a newline.
269 Note that this variable can be made local to a particular merge buffer by
270 giving a prefix argument to `emerge-set-combine-versions-template'.")
274 (defvar emerge-basic-keymap nil
275 "Keymap of Emerge commands.
276 Directly available in `fast' mode;
277 must be prefixed by \\<emerge-fast-keymap>\\[emerge-basic-keymap] in `edit' mode.")
279 (defvar emerge-fast-keymap nil
280 "Local keymap used in Emerge `fast' mode.
281 Makes Emerge commands directly available.")
283 (defvar emerge-options-menu
284 (make-sparse-keymap "Options"))
286 (defvar emerge-merge-menu
287 (make-sparse-keymap "Merge"))
289 (defvar emerge-move-menu
290 (make-sparse-keymap "Move"))
292 (defvar emerge-command-prefix "\C-c\C-c"
293 "*Command prefix for Emerge commands in `edit' mode.
294 Must be set before Emerge is loaded.")
296 ;; This function sets up the fixed keymaps. It is executed when the first
297 ;; Emerge is done to allow the user maximum time to set up the global keymap.
298 (defun emerge-setup-fixed-keymaps ()
299 ;; Set up the basic keymap
300 (setq emerge-basic-keymap (make-keymap))
301 (suppress-keymap emerge-basic-keymap) ; this sets 0..9 to digit-argument and
302 ; - to negative-argument
303 (define-key emerge-basic-keymap "p" 'emerge-previous-difference)
304 (define-key emerge-basic-keymap "n" 'emerge-next-difference)
305 (define-key emerge-basic-keymap "a" 'emerge-select-A)
306 (define-key emerge-basic-keymap "b" 'emerge-select-B)
307 (define-key emerge-basic-keymap "j" 'emerge-jump-to-difference)
308 (define-key emerge-basic-keymap "." 'emerge-find-difference)
309 (define-key emerge-basic-keymap "q" 'emerge-quit)
310 (define-key emerge-basic-keymap "\C-]" 'emerge-abort)
311 (define-key emerge-basic-keymap "f" 'emerge-fast-mode)
312 (define-key emerge-basic-keymap "e" 'emerge-edit-mode)
313 (define-key emerge-basic-keymap "s" nil)
314 (define-key emerge-basic-keymap "sa" 'emerge-auto-advance)
315 (define-key emerge-basic-keymap "ss" 'emerge-skip-prefers)
316 (define-key emerge-basic-keymap "l" 'emerge-recenter)
317 (define-key emerge-basic-keymap "d" nil)
318 (define-key emerge-basic-keymap "da" 'emerge-default-A)
319 (define-key emerge-basic-keymap "db" 'emerge-default-B)
320 (define-key emerge-basic-keymap "c" nil)
321 (define-key emerge-basic-keymap "ca" 'emerge-copy-as-kill-A)
322 (define-key emerge-basic-keymap "cb" 'emerge-copy-as-kill-B)
323 (define-key emerge-basic-keymap "i" nil)
324 (define-key emerge-basic-keymap "ia" 'emerge-insert-A)
325 (define-key emerge-basic-keymap "ib" 'emerge-insert-B)
326 (define-key emerge-basic-keymap "m" 'emerge-mark-difference)
327 (define-key emerge-basic-keymap "v" 'emerge-scroll-up)
328 (define-key emerge-basic-keymap "^" 'emerge-scroll-down)
329 (define-key emerge-basic-keymap "<" 'emerge-scroll-left)
330 (define-key emerge-basic-keymap ">" 'emerge-scroll-right)
331 (define-key emerge-basic-keymap "|" 'emerge-scroll-reset)
332 (define-key emerge-basic-keymap "x" nil)
333 (define-key emerge-basic-keymap "x1" 'emerge-one-line-window)
334 (define-key emerge-basic-keymap "xc" 'emerge-combine-versions)
335 (define-key emerge-basic-keymap "xC" 'emerge-combine-versions-register)
336 (define-key emerge-basic-keymap "xf" 'emerge-file-names)
337 (define-key emerge-basic-keymap "xj" 'emerge-join-differences)
338 (define-key emerge-basic-keymap "xl" 'emerge-line-numbers)
339 (define-key emerge-basic-keymap "xm" 'emerge-set-merge-mode)
340 (define-key emerge-basic-keymap "xs" 'emerge-split-difference)
341 (define-key emerge-basic-keymap "xt" 'emerge-trim-difference)
342 (define-key emerge-basic-keymap "xx" 'emerge-set-combine-versions-template)
343 ;; Allow emerge-basic-keymap to be referenced indirectly
344 (fset 'emerge-basic-keymap emerge-basic-keymap)
345 ;; Set up the fast mode keymap
346 (setq emerge-fast-keymap (copy-keymap emerge-basic-keymap))
347 ;; Allow prefixed commands to work in fast mode
348 (define-key emerge-fast-keymap emerge-command-prefix 'emerge-basic-keymap)
349 ;; Allow emerge-fast-keymap to be referenced indirectly
350 (fset 'emerge-fast-keymap emerge-fast-keymap)
351 ;; Suppress write-file and save-buffer
352 (substitute-key-definition 'write-file 'emerge-query-write-file
353 emerge-fast-keymap (current-global-map))
354 (substitute-key-definition 'save-buffer 'emerge-query-save-buffer
355 emerge-fast-keymap (current-global-map))
357 (define-key emerge-basic-keymap [menu-bar] (make-sparse-keymap))
359 (define-key emerge-fast-keymap [menu-bar options]
360 (cons "Options" emerge-options-menu))
361 (define-key emerge-fast-keymap [menu-bar merge]
362 (cons "Merge" emerge-merge-menu))
363 (define-key emerge-fast-keymap [menu-bar move]
364 (cons "Move" emerge-move-menu))
366 (define-key emerge-move-menu [emerge-scroll-reset]
367 '("Scroll Reset" . emerge-scroll-reset))
368 (define-key emerge-move-menu [emerge-scroll-right]
369 '("Scroll Right" . emerge-scroll-right))
370 (define-key emerge-move-menu [emerge-scroll-left]
371 '("Scroll Left" . emerge-scroll-left))
372 (define-key emerge-move-menu [emerge-scroll-down]
373 '("Scroll Down" . emerge-scroll-down))
374 (define-key emerge-move-menu [emerge-scroll-up]
375 '("Scroll Up" . emerge-scroll-up))
376 (define-key emerge-move-menu [emerge-recenter]
377 '("Recenter" . emerge-recenter))
378 (define-key emerge-move-menu [emerge-mark-difference]
379 '("Mark Difference" . emerge-mark-difference))
380 (define-key emerge-move-menu [emerge-jump-to-difference]
381 '("Jump To Difference" . emerge-jump-to-difference))
382 (define-key emerge-move-menu [emerge-find-difference]
383 '("Find Difference" . emerge-find-difference))
384 (define-key emerge-move-menu [emerge-previous-difference]
385 '("Previous Difference" . emerge-previous-difference))
386 (define-key emerge-move-menu [emerge-next-difference]
387 '("Next Difference" . emerge-next-difference))
390 (define-key emerge-options-menu [emerge-one-line-window]
391 '("One Line Window" . emerge-one-line-window))
392 (define-key emerge-options-menu [emerge-set-merge-mode]
393 '("Set Merge Mode" . emerge-set-merge-mode))
394 (define-key emerge-options-menu [emerge-set-combine-template]
395 '("Set Combine Template..." . emerge-set-combine-template))
396 (define-key emerge-options-menu [emerge-default-B]
397 '("Default B" . emerge-default-B))
398 (define-key emerge-options-menu [emerge-default-A]
399 '("Default A" . emerge-default-A))
400 (define-key emerge-options-menu [emerge-skip-prefers]
401 '("Skip Prefers" . emerge-skip-prefers))
402 (define-key emerge-options-menu [emerge-auto-advance]
403 '("Auto Advance" . emerge-auto-advance))
404 (define-key emerge-options-menu [emerge-edit-mode]
405 '("Edit Mode" . emerge-edit-mode))
406 (define-key emerge-options-menu [emerge-fast-mode]
407 '("Fast Mode" . emerge-fast-mode))
409 (define-key emerge-merge-menu [emerge-abort] '("Abort" . emerge-abort))
410 (define-key emerge-merge-menu [emerge-quit] '("Quit" . emerge-quit))
411 (define-key emerge-merge-menu [emerge-split-difference]
412 '("Split Difference" . emerge-split-difference))
413 (define-key emerge-merge-menu [emerge-join-differences]
414 '("Join Differences" . emerge-join-differences))
415 (define-key emerge-merge-menu [emerge-trim-difference]
416 '("Trim Difference" . emerge-trim-difference))
417 (define-key emerge-merge-menu [emerge-combine-versions]
418 '("Combine Versions" . emerge-combine-versions))
419 (define-key emerge-merge-menu [emerge-copy-as-kill-B]
420 '("Copy B as Kill" . emerge-copy-as-kill-B))
421 (define-key emerge-merge-menu [emerge-copy-as-kill-A]
422 '("Copy A as Kill" . emerge-copy-as-kill-A))
423 (define-key emerge-merge-menu [emerge-insert-B]
424 '("Insert B" . emerge-insert-B))
425 (define-key emerge-merge-menu [emerge-insert-A]
426 '("Insert A" . emerge-insert-A))
427 (define-key emerge-merge-menu [emerge-select-B]
428 '("Select B" . emerge-select-B))
429 (define-key emerge-merge-menu [emerge-select-A]
430 '("Select A" . emerge-select-A)))
433 ;; Variables which control each merge. They are local to the merge buffer.
436 (emerge-defvar-local emerge-mode nil
437 "Indicator for emerge-mode.")
438 (emerge-defvar-local emerge-fast-mode nil
439 "Indicator for emerge-mode fast submode.")
440 (emerge-defvar-local emerge-edit-mode nil
441 "Indicator for emerge-mode edit submode.")
442 (emerge-defvar-local emerge-A-buffer nil
443 "The buffer in which the A variant is stored.")
444 (emerge-defvar-local emerge-B-buffer nil
445 "The buffer in which the B variant is stored.")
446 (emerge-defvar-local emerge-merge-buffer nil
447 "The buffer in which the merged file is manipulated.")
448 (emerge-defvar-local emerge-ancestor-buffer nil
449 "The buffer in which the ancestor variant is stored,
450 or nil if there is none.")
452 (defconst emerge-saved-variables
453 '((buffer-modified-p set-buffer-modified-p)
455 buffer-auto-save-file-name)
456 "Variables and properties of a buffer which are saved, modified and restored
458 (defconst emerge-merging-values '(nil t nil)
459 "Values to be assigned to emerge-saved-variables during a merge.")
461 (emerge-defvar-local emerge-A-buffer-values nil
462 "Remembers emerge-saved-variables for emerge-A-buffer.")
463 (emerge-defvar-local emerge-B-buffer-values nil
464 "Remembers emerge-saved-variables for emerge-B-buffer.")
466 (emerge-defvar-local emerge-difference-list nil
467 "Vector of differences between the variants, and markers in the buffers to
468 show where they are. Each difference is represented by a vector of seven
469 elements. The first two are markers to the beginning and end of the difference
470 section in the A buffer, the second two are markers for the B buffer, the third
471 two are markers for the merge buffer, and the last element is the \"state\" of
472 that difference in the merge buffer.
473 A section of a buffer is described by two markers, one to the beginning of
474 the first line of the section, and one to the beginning of the first line
475 after the section. (If the section is empty, both markers point to the same
476 point.) If the section is part of the selected difference, then the markers
477 are moved into the flags, so the user can edit the section without disturbing
480 A the merge buffer currently contains the A variant
481 B the merge buffer currently contains the B variant
482 default-A the merge buffer contains the A variant by default,
483 but this difference hasn't been selected yet, so
484 change-default commands can alter it
485 default-B the merge buffer contains the B variant by default,
486 but this difference hasn't been selected yet, so
487 change-default commands can alter it
488 prefer-A in a three-file merge, the A variant is the preferred
490 prefer-B in a three-file merge, the B variant is the preferred
492 (emerge-defvar-local emerge-current-difference -1
493 "The difference that is currently selected.")
494 (emerge-defvar-local emerge-number-of-differences nil
495 "Number of differences found.")
496 (emerge-defvar-local emerge-edit-keymap nil
497 "The local keymap for the merge buffer, with the emerge commands defined in
498 it. Used to save the local keymap during fast mode, when the local keymap is
499 replaced by emerge-fast-keymap.")
500 (emerge-defvar-local emerge-old-keymap nil
501 "The original local keymap for the merge buffer.")
502 (emerge-defvar-local emerge-auto-advance nil
503 "*If non-nil, emerge-select-A and emerge-select-B automatically advance to
504 the next difference.")
505 (emerge-defvar-local emerge-skip-prefers nil
506 "*If non-nil, differences for which there is a preference are automatically
508 (emerge-defvar-local emerge-quit-hook nil
509 "Hooks to run in the merge buffer after the merge has been finished.
510 `emerge-prefix-argument' will hold the prefix argument of the `emerge-quit'
512 This is *not* a user option, since Emerge uses it for its own processing.")
513 (emerge-defvar-local emerge-output-description nil
514 "Describes output destination of emerge, for `emerge-file-names'.")
516 ;;; Setup functions for two-file mode.
518 (defun emerge-files-internal (file-A file-B &optional startup-hooks quit-hooks
520 (if (not (file-readable-p file-A))
521 (error "File `%s' does not exist or is not readable" file-A))
522 (if (not (file-readable-p file-B))
523 (error "File `%s' does not exist or is not readable" file-B))
524 (let ((buffer-A (find-file-noselect file-A))
525 (buffer-B (find-file-noselect file-B)))
526 ;; Record the directories of the files
527 (setq emerge-last-dir-A (file-name-directory file-A))
528 (setq emerge-last-dir-B (file-name-directory file-B))
530 (setq emerge-last-dir-output (file-name-directory output-file)))
531 ;; Make sure the entire files are seen, and they reflect what is on disk
532 (emerge-eval-in-buffer
535 (let ((temp (file-local-copy file-A)))
539 (cons (` (lambda () (delete-file (, file-A))))
541 ;; Verify that the file matches the buffer
542 (emerge-verify-file-buffer))))
543 (emerge-eval-in-buffer
546 (let ((temp (file-local-copy file-B)))
550 (cons (` (lambda () (delete-file (, file-B))))
552 ;; Verify that the file matches the buffer
553 (emerge-verify-file-buffer))))
554 (emerge-setup buffer-A file-A buffer-B file-B startup-hooks quit-hooks
557 ;; Start up Emerge on two files
558 (defun emerge-setup (buffer-A file-A buffer-B file-B startup-hooks quit-hooks
560 (setq file-A (expand-file-name file-A))
561 (setq file-B (expand-file-name file-B))
562 (setq output-file (and output-file (expand-file-name output-file)))
563 (let* ((merge-buffer-name (emerge-unique-buffer-name "*merge" "*"))
564 ;; create the merge buffer from buffer A, so it inherits buffer A's
565 ;; default directory, etc.
566 (merge-buffer (emerge-eval-in-buffer
568 (get-buffer-create merge-buffer-name))))
569 (emerge-eval-in-buffer
571 (emerge-copy-modes buffer-A)
572 (setq buffer-read-only nil)
575 (setq emerge-A-buffer buffer-A)
576 (setq emerge-B-buffer buffer-B)
577 (setq emerge-ancestor-buffer nil)
578 (setq emerge-merge-buffer merge-buffer)
579 (setq emerge-output-description
581 (concat "Output to file: " output-file)
582 (concat "Output to buffer: " (buffer-name merge-buffer))))
583 (insert-buffer emerge-A-buffer)
585 (setq emerge-difference-list (emerge-make-diff-list file-A file-B))
586 (setq emerge-number-of-differences (length emerge-difference-list))
587 (setq emerge-current-difference -1)
588 (setq emerge-quit-hook quit-hooks)
589 (emerge-remember-buffer-characteristics)
590 (emerge-handle-local-variables))
591 (emerge-setup-windows buffer-A buffer-B merge-buffer t)
592 (emerge-eval-in-buffer merge-buffer
593 (run-hooks 'startup-hooks 'emerge-startup-hook)
594 (setq buffer-read-only t))))
596 ;; Generate the Emerge difference list between two files
597 (defun emerge-make-diff-list (file-A file-B)
598 (setq emerge-diff-buffer (get-buffer-create "*emerge-diff*"))
599 (emerge-eval-in-buffer
603 (format "%s %s %s %s"
604 emerge-diff-program emerge-diff-options
605 (emerge-protect-metachars file-A)
606 (emerge-protect-metachars file-B))
608 (emerge-prepare-error-list emerge-diff-ok-lines-regexp)
609 (emerge-convert-diffs-to-markers
610 emerge-A-buffer emerge-B-buffer emerge-merge-buffer
611 (emerge-extract-diffs emerge-diff-buffer)))
613 (defun emerge-extract-diffs (diff-buffer)
615 (emerge-eval-in-buffer
617 (goto-char (point-min))
618 (while (re-search-forward emerge-match-diff-line nil t)
619 (let* ((a-begin (string-to-int (buffer-substring (match-beginning 1)
621 (a-end (let ((b (match-beginning 3))
624 (string-to-int (buffer-substring b e))
626 (diff-type (buffer-substring (match-beginning 4) (match-end 4)))
627 (b-begin (string-to-int (buffer-substring (match-beginning 5)
629 (b-end (let ((b (match-beginning 7))
632 (string-to-int (buffer-substring b e))
634 ;; fix the beginning and end numbers, because diff is somewhat
635 ;; strange about how it numbers lines
636 (if (string-equal diff-type "a")
638 (setq b-end (1+ b-end))
639 (setq a-begin (1+ a-begin))
640 (setq a-end a-begin))
641 (if (string-equal diff-type "d")
643 (setq a-end (1+ a-end))
644 (setq b-begin (1+ b-begin))
645 (setq b-end b-begin))
646 ;; (string-equal diff-type "c")
648 (setq a-end (1+ a-end))
649 (setq b-end (1+ b-end)))))
650 (setq list (cons (vector a-begin a-end
656 ;; Set up buffer of diff/diff3 error messages.
657 (defun emerge-prepare-error-list (ok-regexp)
658 (setq emerge-diff-error-buffer (get-buffer-create "*emerge-diff-errors*"))
659 (emerge-eval-in-buffer
660 emerge-diff-error-buffer
662 (insert-buffer emerge-diff-buffer)
663 (delete-matching-lines ok-regexp)))
665 ;;; Top-level and setup functions for three-file mode.
667 (defun emerge-files-with-ancestor-internal (file-A file-B file-ancestor
668 &optional startup-hooks quit-hooks
670 (if (not (file-readable-p file-A))
671 (error "File `%s' does not exist or is not readable" file-A))
672 (if (not (file-readable-p file-B))
673 (error "File `%s' does not exist or is not readable" file-B))
674 (if (not (file-readable-p file-ancestor))
675 (error "File `%s' does not exist or is not readable" file-ancestor))
676 (let ((buffer-A (find-file-noselect file-A))
677 (buffer-B (find-file-noselect file-B))
678 (buffer-ancestor (find-file-noselect file-ancestor)))
679 ;; Record the directories of the files
680 (setq emerge-last-dir-A (file-name-directory file-A))
681 (setq emerge-last-dir-B (file-name-directory file-B))
682 (setq emerge-last-dir-ancestor (file-name-directory file-ancestor))
684 (setq emerge-last-dir-output (file-name-directory output-file)))
685 ;; Make sure the entire files are seen, and they reflect what is on disk
686 (emerge-eval-in-buffer
689 (let ((temp (file-local-copy file-A)))
693 (cons (` (lambda () (delete-file (, file-A))))
695 ;; Verify that the file matches the buffer
696 (emerge-verify-file-buffer))))
697 (emerge-eval-in-buffer
700 (let ((temp (file-local-copy file-B)))
704 (cons (` (lambda () (delete-file (, file-B))))
706 ;; Verify that the file matches the buffer
707 (emerge-verify-file-buffer))))
708 (emerge-eval-in-buffer
711 (let ((temp (file-local-copy file-ancestor)))
713 (setq file-ancestor temp
715 (cons (` (lambda () (delete-file (, file-ancestor))))
717 ;; Verify that the file matches the buffer
718 (emerge-verify-file-buffer))))
719 (emerge-setup-with-ancestor buffer-A file-A buffer-B file-B
720 buffer-ancestor file-ancestor
721 startup-hooks quit-hooks output-file)))
723 ;; Start up Emerge on two files with an ancestor
724 (defun emerge-setup-with-ancestor (buffer-A file-A buffer-B file-B
725 buffer-ancestor file-ancestor
726 &optional startup-hooks quit-hooks
728 (setq file-A (expand-file-name file-A))
729 (setq file-B (expand-file-name file-B))
730 (setq file-ancestor (expand-file-name file-ancestor))
731 (setq output-file (and output-file (expand-file-name output-file)))
732 (let* ((merge-buffer-name (emerge-unique-buffer-name "*merge" "*"))
733 ;; create the merge buffer from buffer A, so it inherits buffer A's
734 ;; default directory, etc.
735 (merge-buffer (emerge-eval-in-buffer
737 (get-buffer-create merge-buffer-name))))
738 (emerge-eval-in-buffer
740 (emerge-copy-modes buffer-A)
741 (setq buffer-read-only nil)
744 (setq emerge-A-buffer buffer-A)
745 (setq emerge-B-buffer buffer-B)
746 (setq emerge-ancestor-buffer buffer-ancestor)
747 (setq emerge-merge-buffer merge-buffer)
748 (setq emerge-output-description
750 (concat "Output to file: " output-file)
751 (concat "Output to buffer: " (buffer-name merge-buffer))))
752 (insert-buffer emerge-A-buffer)
754 (setq emerge-difference-list
755 (emerge-make-diff3-list file-A file-B file-ancestor))
756 (setq emerge-number-of-differences (length emerge-difference-list))
757 (setq emerge-current-difference -1)
758 (setq emerge-quit-hook quit-hooks)
759 (emerge-remember-buffer-characteristics)
760 (emerge-select-prefer-Bs)
761 (emerge-handle-local-variables))
762 (emerge-setup-windows buffer-A buffer-B merge-buffer t)
763 (emerge-eval-in-buffer merge-buffer
764 (run-hooks 'startup-hooks 'emerge-startup-hook)
765 (setq buffer-read-only t))))
767 ;; Generate the Emerge difference list between two files with an ancestor
768 (defun emerge-make-diff3-list (file-A file-B file-ancestor)
769 (setq emerge-diff-buffer (get-buffer-create "*emerge-diff*"))
770 (emerge-eval-in-buffer
774 (format "%s %s %s %s %s"
775 emerge-diff3-program emerge-diff-options
776 (emerge-protect-metachars file-A)
777 (emerge-protect-metachars file-ancestor)
778 (emerge-protect-metachars file-B))
780 (emerge-prepare-error-list emerge-diff3-ok-lines-regexp)
781 (emerge-convert-diffs-to-markers
782 emerge-A-buffer emerge-B-buffer emerge-merge-buffer
783 (emerge-extract-diffs3 emerge-diff-buffer)))
785 (defun emerge-extract-diffs3 (diff-buffer)
787 (emerge-eval-in-buffer
789 (while (re-search-forward "^====\\(.?\\)$" nil t)
790 ;; leave point after matched line
791 (beginning-of-line 2)
792 (let ((agreement (buffer-substring (match-beginning 1) (match-end 1))))
793 ;; if the A and B files are the same, ignore the difference
794 (if (not (string-equal agreement "2"))
797 (let (group-1 group-3 pos)
799 (setq group-1 (emerge-get-diff3-group "1"))
801 (setq group-3 (emerge-get-diff3-group "3"))
802 (vector (car group-1) (car (cdr group-1))
803 (car group-3) (car (cdr group-3))
804 (cond ((string-equal agreement "1") 'prefer-A)
805 ((string-equal agreement "3") 'prefer-B)
810 (defun emerge-get-diff3-group (file)
811 ;; This save-excursion allows emerge-get-diff3-group to be called for the
812 ;; various groups of lines (1, 2, 3) in any order, and for the lines to
813 ;; appear in any order. The reason this is necessary is that Gnu diff3
814 ;; can produce the groups in the order 1, 2, 3 or 1, 3, 2.
817 (concat "^" file ":\\([0-9]+\\)\\(,\\([0-9]+\\)\\)?\\([ac]\\)$"))
818 (beginning-of-line 2)
819 ;; treatment depends on whether it is an "a" group or a "c" group
820 (if (string-equal (buffer-substring (match-beginning 4) (match-end 4)) "c")
822 (if (match-beginning 2)
823 ;; it has two numbers
825 (buffer-substring (match-beginning 1) (match-end 1)))
827 (buffer-substring (match-beginning 3) (match-end 3)))))
829 (let ((x (string-to-int
830 (buffer-substring (match-beginning 1) (match-end 1)))))
832 ;; it is an "a" group
833 (let ((x (1+ (string-to-int
834 (buffer-substring (match-beginning 1) (match-end 1))))))
837 ;;; Functions to start Emerge on files
840 (defun emerge-files (arg file-A file-B file-out &optional startup-hooks
842 "Run Emerge on two files."
845 (list current-prefix-arg
846 (setq f (emerge-read-file-name "File A to merge" emerge-last-dir-A
848 (emerge-read-file-name "File B to merge" emerge-last-dir-B nil f)
849 (and current-prefix-arg
850 (emerge-read-file-name "Output file" emerge-last-dir-output
852 (emerge-files-internal
853 file-A file-B startup-hooks
855 (cons (` (lambda () (emerge-files-exit (, file-out))))
861 (defun emerge-files-with-ancestor (arg file-A file-B file-ancestor file-out
862 &optional startup-hooks quit-hooks)
863 "Run Emerge on two files, giving another file as the ancestor."
866 (list current-prefix-arg
867 (setq f (emerge-read-file-name "File A to merge" emerge-last-dir-A
869 (emerge-read-file-name "File B to merge" emerge-last-dir-B nil f)
870 (emerge-read-file-name "Ancestor file" emerge-last-dir-ancestor
872 (and current-prefix-arg
873 (emerge-read-file-name "Output file" emerge-last-dir-output
875 (emerge-files-with-ancestor-internal
876 file-A file-B file-ancestor startup-hooks
878 (cons (` (lambda () (emerge-files-exit (, file-out))))
883 ;; Write the merge buffer out in place of the file the A buffer is visiting.
884 (defun emerge-files-exit (file-out)
885 ;; if merge was successful was given, save to disk
886 (if (not emerge-prefix-argument)
887 (emerge-write-and-delete file-out)))
889 ;;; Functions to start Emerge on buffers
892 (defun emerge-buffers (buffer-A buffer-B &optional startup-hooks quit-hooks)
893 "Run Emerge on two buffers."
894 (interactive "bBuffer A to merge: \nbBuffer B to merge: ")
895 (let ((emerge-file-A (emerge-make-temp-file "A"))
896 (emerge-file-B (emerge-make-temp-file "B")))
897 (emerge-eval-in-buffer
899 (write-region (point-min) (point-max) emerge-file-A nil 'no-message))
900 (emerge-eval-in-buffer
902 (write-region (point-min) (point-max) emerge-file-B nil 'no-message))
903 (emerge-setup (get-buffer buffer-A) emerge-file-A
904 (get-buffer buffer-B) emerge-file-B
906 (delete-file (, emerge-file-A))
907 (delete-file (, emerge-file-B))))
913 (defun emerge-buffers-with-ancestor (buffer-A buffer-B buffer-ancestor
914 &optional startup-hooks
916 "Run Emerge on two buffers, giving another buffer as the ancestor."
918 "bBuffer A to merge: \nbBuffer B to merge: \nbAncestor buffer: ")
919 (let ((emerge-file-A (emerge-make-temp-file "A"))
920 (emerge-file-B (emerge-make-temp-file "B"))
921 (emerge-file-ancestor (emerge-make-temp-file "anc")))
922 (emerge-eval-in-buffer
924 (write-region (point-min) (point-max) emerge-file-A nil 'no-message))
925 (emerge-eval-in-buffer
927 (write-region (point-min) (point-max) emerge-file-B nil 'no-message))
928 (emerge-eval-in-buffer
930 (write-region (point-min) (point-max) emerge-file-ancestor nil
932 (emerge-setup-with-ancestor (get-buffer buffer-A) emerge-file-A
933 (get-buffer buffer-B) emerge-file-B
934 (get-buffer buffer-ancestor)
937 (delete-file (, emerge-file-A))
938 (delete-file (, emerge-file-B))
940 (, emerge-file-ancestor))))
945 ;;; Functions to start Emerge from the command line
948 (defun emerge-files-command ()
949 (let ((file-a (nth 0 command-line-args-left))
950 (file-b (nth 1 command-line-args-left))
951 (file-out (nth 2 command-line-args-left)))
952 (setq command-line-args-left (nthcdr 3 command-line-args-left))
953 (emerge-files-internal
955 (list (` (lambda () (emerge-command-exit (, file-out))))))))
958 (defun emerge-files-with-ancestor-command ()
959 (let (file-a file-b file-anc file-out)
960 ;; check for a -a flag, for filemerge compatibility
961 (if (string= (car command-line-args-left) "-a")
962 ;; arguments are "-a ancestor file-a file-b file-out"
964 (setq file-a (nth 2 command-line-args-left))
965 (setq file-b (nth 3 command-line-args-left))
966 (setq file-anc (nth 1 command-line-args-left))
967 (setq file-out (nth 4 command-line-args-left))
968 (setq command-line-args-left (nthcdr 5 command-line-args-left)))
969 ;; arguments are "file-a file-b ancestor file-out"
970 (setq file-a (nth 0 command-line-args-left))
971 (setq file-b (nth 1 command-line-args-left))
972 (setq file-anc (nth 2 command-line-args-left))
973 (setq file-out (nth 3 command-line-args-left))
974 (setq command-line-args-left (nthcdr 4 command-line-args-left)))
975 (emerge-files-with-ancestor-internal
976 file-a file-b file-anc nil
977 (list (` (lambda () (emerge-command-exit (, file-out))))))))
979 (defun emerge-command-exit (file-out)
980 (emerge-write-and-delete file-out)
981 (kill-emacs (if emerge-prefix-argument 1 0)))
983 ;;; Functions to start Emerge via remote request
986 (defun emerge-files-remote (file-a file-b file-out)
987 (setq emerge-file-out file-out)
988 (emerge-files-internal
990 (list (` (lambda () (emerge-remote-exit (, file-out) '(, emerge-exit-func)))))
992 (throw 'client-wait nil))
995 (defun emerge-files-with-ancestor-remote (file-a file-b file-anc file-out)
996 (setq emerge-file-out file-out)
997 (emerge-files-with-ancestor-internal
998 file-a file-b file-anc nil
999 (list (` (lambda () (emerge-remote-exit (, file-out) '(, emerge-exit-func)))))
1001 (throw 'client-wait nil))
1003 (defun emerge-remote-exit (file-out emerge-exit-func)
1004 (emerge-write-and-delete file-out)
1005 (kill-buffer emerge-merge-buffer)
1006 (funcall emerge-exit-func (if emerge-prefix-argument 1 0)))
1008 ;;; Functions to start Emerge on RCS versions
1010 (defun emerge-revisions (arg file revision-A revision-B
1011 &optional startup-hooks quit-hooks)
1012 "Emerge two RCS revisions of a file."
1014 (list current-prefix-arg
1015 (read-file-name "File to merge: " nil nil 'confirm)
1016 (read-string "Revision A to merge: " emerge-last-revision-A)
1017 (read-string "Revision B to merge: " emerge-last-revision-B)))
1018 (setq emerge-last-revision-A revision-A
1019 emerge-last-revision-B revision-B)
1020 (emerge-revisions-internal
1021 file revision-A revision-B startup-hooks
1025 (, (format "%s %s" emerge-rcs-ci-program file)))))
1029 (defun emerge-revisions-with-ancestor (arg file revision-A
1032 startup-hooks quit-hooks)
1033 "Emerge two RCS revisions of a file, with another revision as ancestor."
1035 (list current-prefix-arg
1036 (read-file-name "File to merge: " nil nil 'confirm)
1037 (read-string "Revision A to merge: " emerge-last-revision-A)
1038 (read-string "Revision B to merge: " emerge-last-revision-B)
1039 (read-string "Ancestor: " emerge-last-revision-ancestor)))
1040 (setq emerge-last-revision-A revision-A
1041 emerge-last-revision-B revision-B
1042 emerge-last-revision-ancestor ancestor)
1043 (emerge-revision-with-ancestor-internal
1044 file revision-A revision-B ancestor startup-hooks
1049 (, (format "%s %s" emerge-rcs-ci-program file)))))
1053 (defun emerge-revisions-internal (file revision-A revision-B &optional
1054 startup-hooks quit-hooks output-file)
1055 (let ((buffer-A (get-buffer-create (format "%s,%s" file revision-A)))
1056 (buffer-B (get-buffer-create (format "%s,%s" file revision-B)))
1057 (emerge-file-A (emerge-make-temp-file "A"))
1058 (emerge-file-B (emerge-make-temp-file "B")))
1059 ;; Get the revisions into buffers
1060 (emerge-eval-in-buffer
1064 (format "%s -q -p%s %s" emerge-rcs-co-program revision-A file)
1066 (write-region (point-min) (point-max) emerge-file-A nil 'no-message)
1067 (set-buffer-modified-p nil))
1068 (emerge-eval-in-buffer
1072 (format "%s -q -p%s %s" emerge-rcs-co-program revision-B file)
1074 (write-region (point-min) (point-max) emerge-file-B nil 'no-message)
1075 (set-buffer-modified-p nil))
1077 (emerge-setup buffer-A emerge-file-A
1078 buffer-B emerge-file-B
1080 (delete-file (, emerge-file-A))
1081 (delete-file (, emerge-file-B))))
1083 (cons (` (lambda () (emerge-files-exit (, file))))
1087 (defun emerge-revision-with-ancestor-internal (file revision-A revision-B
1089 &optional startup-hooks
1090 quit-hooks output-file)
1091 (let ((buffer-A (get-buffer-create (format "%s,%s" file revision-A)))
1092 (buffer-B (get-buffer-create (format "%s,%s" file revision-B)))
1093 (buffer-ancestor (get-buffer-create (format "%s,%s" file ancestor)))
1094 (emerge-file-A (emerge-make-temp-file "A"))
1095 (emerge-file-B (emerge-make-temp-file "B"))
1096 (emerge-ancestor (emerge-make-temp-file "ancestor")))
1097 ;; Get the revisions into buffers
1098 (emerge-eval-in-buffer
1102 (format "%s -q -p%s %s" emerge-rcs-co-program
1105 (write-region (point-min) (point-max) emerge-file-A nil 'no-message)
1106 (set-buffer-modified-p nil))
1107 (emerge-eval-in-buffer
1111 (format "%s -q -p%s %s" emerge-rcs-co-program revision-B file)
1113 (write-region (point-min) (point-max) emerge-file-B nil 'no-message)
1114 (set-buffer-modified-p nil))
1115 (emerge-eval-in-buffer
1119 (format "%s -q -p%s %s" emerge-rcs-co-program ancestor file)
1121 (write-region (point-min) (point-max) emerge-ancestor nil 'no-message)
1122 (set-buffer-modified-p nil))
1124 (emerge-setup-with-ancestor
1125 buffer-A emerge-file-A buffer-B emerge-file-B
1126 buffer-ancestor emerge-ancestor
1128 (delete-file (, emerge-file-A))
1129 (delete-file (, emerge-file-B))
1130 (delete-file (, emerge-ancestor))))
1132 (cons (` (lambda () (emerge-files-exit (, file))))
1136 ;;; Function to start Emerge based on a line in a file
1138 (defun emerge-execute-line ()
1139 "Run Emerge using files named in current text line.
1140 Looks in that line for whitespace-separated entries of these forms:
1145 to specify the files to use in Emerge.
1147 In addition, if only one of `a=file' or `b=file' is present, and `output=file'
1149 If `emerge-execute-line-deletions' is non-nil and `ancestor=file' is present,
1150 it is assumed that the file in question has been deleted, and it is
1151 not copied to the output file.
1152 Otherwise, the A or B file present is copied to the output file."
1154 (let (file-A file-B file-ancestor file-out
1155 (case-fold-search t))
1156 ;; Stop if at end of buffer (even though we might be in a line, if
1157 ;; the line does not end with newline)
1159 (error "At end of buffer"))
1160 ;; Go to the beginning of the line
1162 ;; Skip any initial whitespace
1163 (if (looking-at "[ \t]*")
1164 (goto-char (match-end 0)))
1165 ;; Process the entire line
1167 ;; Get the next entry
1168 (if (looking-at "\\([a-z]+\\)=\\([^ \t\n]+\\)[ \t]*")
1169 ;; Break apart the tab (before =) and the filename (after =)
1170 (let ((tag (downcase
1171 (buffer-substring (match-beginning 1) (match-end 1))))
1172 (file (buffer-substring (match-beginning 2) (match-end 2))))
1173 ;; Move point after the entry
1174 (goto-char (match-end 0))
1175 ;; Store the filename in the right variable
1177 ((string-equal tag "a")
1179 (error "This line has two `A' entries"))
1181 ((string-equal tag "b")
1183 (error "This line has two `B' entries"))
1185 ((or (string-equal tag "anc") (string-equal tag "ancestor"))
1187 (error "This line has two `ancestor' entries"))
1188 (setq file-ancestor file))
1189 ((or (string-equal tag "out") (string-equal tag "output"))
1191 (error "This line has two `output' entries"))
1192 (setq file-out file))
1194 (error "Unrecognized entry"))))
1195 ;; If the match on the entry pattern failed
1196 (error "Unparsable entry")))
1197 ;; Make sure that file-A and file-B are present
1198 (if (not (or (and file-A file-B) file-out))
1199 (error "Must have both `A' and `B' entries"))
1200 (if (not (or file-A file-B))
1201 (error "Must have `A' or `B' entry"))
1202 ;; Go to the beginning of the next line, so next execution will use
1203 ;; next line in buffer.
1204 (beginning-of-line 2)
1205 ;; Execute the correct command
1207 ;; Merge of two files with ancestor
1208 ((and file-A file-B file-ancestor)
1209 (message "Merging %s and %s..." file-A file-B)
1210 (emerge-files-with-ancestor (not (not file-out)) file-A file-B
1211 file-ancestor file-out
1213 ;; When done, return to this buffer.
1216 (switch-to-buffer (, (current-buffer)))
1217 (message "Merge done."))))))
1218 ;; Merge of two files without ancestor
1219 ((and file-A file-B)
1220 (message "Merging %s and %s..." file-A file-B)
1221 (emerge-files (not (not file-out)) file-A file-B file-out
1223 ;; When done, return to this buffer.
1226 (switch-to-buffer (, (current-buffer)))
1227 (message "Merge done."))))))
1228 ;; There is an output file (or there would have been an error above),
1229 ;; but only one input file.
1230 ;; The file appears to have been deleted in one version; do nothing.
1231 ((and file-ancestor emerge-execute-line-deletions)
1232 (message "No action."))
1233 ;; The file should be copied from the version that contains it
1234 (t (let ((input-file (or file-A file-B)))
1235 (message "Copying...")
1236 (copy-file input-file file-out)
1237 (message "%s copied to %s." input-file file-out))))))
1239 ;;; Sample function for creating information for emerge-execute-line
1241 (defvar emerge-merge-directories-filename-regexp "[^.]"
1242 "Regexp describing files to be processed by `emerge-merge-directories'.")
1244 (defun emerge-merge-directories (a-dir b-dir ancestor-dir output-dir)
1247 (read-file-name "A directory: " nil nil 'confirm)
1248 (read-file-name "B directory: " nil nil 'confirm)
1249 (read-file-name "Ancestor directory (null for none): " nil nil 'confirm)
1250 (read-file-name "Output directory (null for none): " nil nil 'confirm)))
1251 ;; Check that we're not on a line
1252 (if (not (and (bolp) (eolp)))
1253 (error "There is text on this line"))
1254 ;; Turn null strings into nil to indicate directories not used.
1255 (if (and ancestor-dir (string-equal ancestor-dir ""))
1256 (setq ancestor-dir nil))
1257 (if (and output-dir (string-equal output-dir ""))
1258 (setq output-dir nil))
1259 ;; Canonicalize the directory names
1260 (setq a-dir (expand-file-name a-dir))
1261 (if (not (string-equal (substring a-dir -1) "/"))
1262 (setq a-dir (concat a-dir "/")))
1263 (setq b-dir (expand-file-name b-dir))
1264 (if (not (string-equal (substring b-dir -1) "/"))
1265 (setq b-dir (concat b-dir "/")))
1268 (setq ancestor-dir (expand-file-name ancestor-dir))
1269 (if (not (string-equal (substring ancestor-dir -1) "/"))
1270 (setq ancestor-dir (concat ancestor-dir "/")))))
1273 (setq output-dir (expand-file-name output-dir))
1274 (if (not (string-equal (substring output-dir -1) "/"))
1275 (setq output-dir (concat output-dir "/")))))
1276 ;; Set the mark to where we start
1278 ;; Find out what files are in the directories.
1280 (directory-files a-dir nil emerge-merge-directories-filename-regexp))
1282 (directory-files b-dir nil emerge-merge-directories-filename-regexp))
1285 (directory-files ancestor-dir nil
1286 emerge-merge-directories-filename-regexp)))
1287 (all-files (sort (nconc (copy-sequence a-dir-files)
1288 (copy-sequence b-dir-files)
1289 (copy-sequence ancestor-dir-files))
1290 (function string-lessp))))
1291 ;; Remove duplicates from all-files.
1292 (let ((p all-files))
1294 (if (and (cdr p) (string-equal (car p) (car (cdr p))))
1295 (setcdr p (cdr (cdr p)))
1297 ;; Generate the control lines for the various files.
1299 (let ((f (car all-files)))
1300 (setq all-files (cdr all-files))
1301 (if (and a-dir-files (string-equal (car a-dir-files) f))
1303 (insert "A=" a-dir f "\t")
1304 (setq a-dir-files (cdr a-dir-files))))
1305 (if (and b-dir-files (string-equal (car b-dir-files) f))
1307 (insert "B=" b-dir f "\t")
1308 (setq b-dir-files (cdr b-dir-files))))
1309 (if (and ancestor-dir-files (string-equal (car ancestor-dir-files) f))
1311 (insert "ancestor=" ancestor-dir f "\t")
1312 (setq ancestor-dir-files (cdr ancestor-dir-files))))
1314 (insert "output=" output-dir f "\t"))
1315 (backward-delete-char 1)
1318 ;;; Common setup routines
1320 ;; Set up the window configuration. If POS is given, set the points to
1321 ;; the beginnings of the buffers.
1322 (defun emerge-setup-windows (buffer-A buffer-B merge-buffer &optional pos)
1323 ;; Make sure we are not in the minibuffer window when we try to delete
1324 ;; all other windows.
1325 (if (eq (selected-window) (minibuffer-window))
1327 (delete-other-windows)
1328 (switch-to-buffer merge-buffer)
1329 (emerge-refresh-mode-line)
1330 (split-window-vertically)
1331 (split-window-horizontally)
1332 (switch-to-buffer buffer-A)
1334 (goto-char (point-min)))
1336 (switch-to-buffer buffer-B)
1338 (goto-char (point-min)))
1341 (goto-char (point-min)))
1342 ;; If diff/diff3 reports errors, display them rather than the merge buffer.
1343 (if (/= 0 (emerge-eval-in-buffer emerge-diff-error-buffer (buffer-size)))
1346 (message "Errors found in diff/diff3 output. Merge buffer is %s."
1347 (buffer-name emerge-merge-buffer))
1348 (switch-to-buffer emerge-diff-error-buffer))))
1350 ;; Set up the keymap in the merge buffer
1351 (defun emerge-set-keys ()
1352 ;; Set up fixed keymaps if necessary
1353 (if (not emerge-basic-keymap)
1354 (emerge-setup-fixed-keymaps))
1355 ;; Save the old local map
1356 (setq emerge-old-keymap (current-local-map))
1357 ;; Construct the edit keymap
1358 (setq emerge-edit-keymap (if emerge-old-keymap
1359 (copy-keymap emerge-old-keymap)
1360 (make-sparse-keymap)))
1361 ;; Install the Emerge commands
1362 (emerge-force-define-key emerge-edit-keymap emerge-command-prefix
1363 'emerge-basic-keymap)
1364 (define-key emerge-edit-keymap [menu-bar] (make-sparse-keymap))
1366 ;; Create the additional menu bar items.
1367 (define-key emerge-edit-keymap [menu-bar options]
1368 (cons "Options" emerge-options-menu))
1369 (define-key emerge-edit-keymap [menu-bar merge]
1370 (cons "Merge" emerge-merge-menu))
1371 (define-key emerge-edit-keymap [menu-bar move]
1372 (cons "Move" emerge-move-menu))
1374 ;; Suppress write-file and save-buffer
1375 (substitute-key-definition 'write-file
1376 'emerge-query-write-file
1378 (substitute-key-definition 'save-buffer
1379 'emerge-query-save-buffer
1381 (substitute-key-definition 'write-file 'emerge-query-write-file
1382 emerge-edit-keymap (current-global-map))
1383 (substitute-key-definition 'save-buffer 'emerge-query-save-buffer
1384 emerge-edit-keymap (current-global-map))
1385 (use-local-map emerge-fast-keymap)
1386 (setq emerge-edit-mode nil)
1387 (setq emerge-fast-mode t))
1389 (defun emerge-remember-buffer-characteristics ()
1390 "Record certain properties of the buffers being merged.
1391 Must be called in the merge buffer. Remembers read-only, modified,
1392 auto-save, and saves them in buffer local variables. Sets the buffers
1393 read-only and turns off `auto-save-mode'.
1394 These characteristics are restored by `emerge-restore-buffer-characteristics'."
1395 ;; force auto-save, because we will turn off auto-saving in buffers for the
1398 ;; remember and alter buffer characteristics
1399 (setq emerge-A-buffer-values
1400 (emerge-eval-in-buffer
1403 (emerge-save-variables emerge-saved-variables)
1404 (emerge-restore-variables emerge-saved-variables
1405 emerge-merging-values))))
1406 (setq emerge-B-buffer-values
1407 (emerge-eval-in-buffer
1410 (emerge-save-variables emerge-saved-variables)
1411 (emerge-restore-variables emerge-saved-variables
1412 emerge-merging-values)))))
1414 (defun emerge-restore-buffer-characteristics ()
1415 "Restores characteristics saved by `emerge-remember-buffer-characteristics'."
1416 (let ((A-values emerge-A-buffer-values)
1417 (B-values emerge-B-buffer-values))
1418 (emerge-eval-in-buffer emerge-A-buffer
1419 (emerge-restore-variables emerge-saved-variables
1421 (emerge-eval-in-buffer emerge-B-buffer
1422 (emerge-restore-variables emerge-saved-variables
1425 (defun emerge-convert-diffs-to-markers (A-buffer
1430 (A-point-min (emerge-eval-in-buffer A-buffer (point-min)))
1431 (offset (1- A-point-min))
1432 (A-hidden-lines (emerge-eval-in-buffer
1436 (count-lines 1 A-point-min))))
1437 (B-point-min (emerge-eval-in-buffer B-buffer (point-min)))
1438 (B-hidden-lines (emerge-eval-in-buffer
1442 (count-lines 1 B-point-min)))))
1444 (let* ((list-element (car lineno-list))
1451 (a-begin (aref list-element 0))
1452 (a-end (aref list-element 1))
1453 (b-begin (aref list-element 2))
1454 (b-end (aref list-element 3))
1455 (state (aref list-element 4)))
1456 ;; place markers at the appropriate places in the buffers
1457 (emerge-eval-in-buffer
1459 (goto-line (+ a-begin A-hidden-lines))
1460 (setq a-begin-marker (point-marker))
1461 (goto-line (+ a-end A-hidden-lines))
1462 (setq a-end-marker (point-marker)))
1463 (emerge-eval-in-buffer
1465 (goto-line (+ b-begin B-hidden-lines))
1466 (setq b-begin-marker (point-marker))
1467 (goto-line (+ b-end B-hidden-lines))
1468 (setq b-end-marker (point-marker)))
1469 (setq merge-begin-marker (set-marker
1471 (- (marker-position a-begin-marker)
1474 (setq merge-end-marker (set-marker
1476 (- (marker-position a-end-marker)
1479 ;; record all the markers for this difference
1480 (setq marker-list (cons (vector a-begin-marker a-end-marker
1481 b-begin-marker b-end-marker
1482 merge-begin-marker merge-end-marker
1485 (setq lineno-list (cdr lineno-list)))
1486 ;; convert the list of difference information into a vector for
1488 (setq emerge-difference-list (apply 'vector (nreverse marker-list)))))
1490 ;; If we have an ancestor, select all B variants that we prefer
1491 (defun emerge-select-prefer-Bs ()
1493 (while (< n emerge-number-of-differences)
1494 (if (eq (aref (aref emerge-difference-list n) 6) 'prefer-B)
1496 (emerge-unselect-and-select-difference n t)
1498 (aset (aref emerge-difference-list n) 6 'prefer-B)))
1500 (emerge-unselect-and-select-difference -1))
1502 ;; Process the local-variables list at the end of the merged file, if
1504 (defun emerge-handle-local-variables ()
1505 (if emerge-process-local-variables
1507 (hack-local-variables)
1508 (error (message "Local-variables error in merge buffer: %s"
1509 (prin1-to-string err))))))
1511 ;;; Common exit routines
1513 (defun emerge-write-and-delete (file-out)
1514 ;; clear screen format
1515 (delete-other-windows)
1516 ;; delete A, B, and ancestor buffers, if they haven't been changed
1517 (if (not (buffer-modified-p emerge-A-buffer))
1518 (kill-buffer emerge-A-buffer))
1519 (if (not (buffer-modified-p emerge-B-buffer))
1520 (kill-buffer emerge-B-buffer))
1521 (if (and emerge-ancestor-buffer
1522 (not (buffer-modified-p emerge-ancestor-buffer)))
1523 (kill-buffer emerge-ancestor-buffer))
1524 ;; Write merge buffer to file
1526 (write-file file-out)))
1530 (defun emerge-recenter (&optional arg)
1531 "Bring the highlighted region of all three merge buffers into view.
1532 This brings the buffers into view if they are in windows.
1533 With an argument, reestablish the default three-window display."
1535 ;; If there is an argument, rebuild the window structure
1537 (emerge-setup-windows emerge-A-buffer emerge-B-buffer
1538 emerge-merge-buffer))
1539 ;; Redisplay whatever buffers are showing, if there is a selected difference
1540 (if (and (>= emerge-current-difference 0)
1541 (< emerge-current-difference emerge-number-of-differences))
1542 (let* ((merge-buffer emerge-merge-buffer)
1543 (buffer-A emerge-A-buffer)
1544 (buffer-B emerge-B-buffer)
1545 (window-A (get-buffer-window buffer-A))
1546 (window-B (get-buffer-window buffer-B))
1547 (merge-window (get-buffer-window merge-buffer))
1549 (aref emerge-difference-list emerge-current-difference)))
1551 (select-window window-A)
1552 (emerge-position-region
1553 (- (aref diff-vector 0)
1554 (1- emerge-before-flag-length))
1555 (+ (aref diff-vector 1)
1556 (1- emerge-after-flag-length))
1557 (1+ (aref diff-vector 0)))))
1559 (select-window window-B)
1560 (emerge-position-region
1561 (- (aref diff-vector 2)
1562 (1- emerge-before-flag-length))
1563 (+ (aref diff-vector 3)
1564 (1- emerge-after-flag-length))
1565 (1+ (aref diff-vector 2)))))
1566 (if merge-window (progn
1567 (select-window merge-window)
1568 (emerge-position-region
1569 (- (aref diff-vector 4)
1570 (1- emerge-before-flag-length))
1571 (+ (aref diff-vector 5)
1572 (1- emerge-after-flag-length))
1573 (1+ (aref diff-vector 4))))))))
1575 ;;; Window scrolling operations
1576 ;; These operations are designed to scroll all three windows the same amount,
1577 ;; so as to keep the text in them aligned.
1579 ;; Perform some operation on all three windows (if they are showing).
1580 ;; Catches all errors on the operation in the A and B windows, but not
1581 ;; in the merge window. Usually, errors come from scrolling off the
1582 ;; beginning or end of the buffer, and this gives a nice error message:
1583 ;; End of buffer is reported in the merge buffer, but if the scroll was
1584 ;; possible in the A or B windows, it is performed there before the error
1586 (defun emerge-operate-on-windows (operation arg)
1587 (let* ((merge-buffer emerge-merge-buffer)
1588 (buffer-A emerge-A-buffer)
1589 (buffer-B emerge-B-buffer)
1590 (window-A (get-buffer-window buffer-A))
1591 (window-B (get-buffer-window buffer-B))
1592 (merge-window (get-buffer-window merge-buffer)))
1594 (select-window window-A)
1596 (funcall operation arg)
1599 (select-window window-B)
1601 (funcall operation arg)
1603 (if merge-window (progn
1604 (select-window merge-window)
1605 (funcall operation arg)))))
1607 (defun emerge-scroll-up (&optional arg)
1608 "Scroll up all three merge buffers, if they are in windows.
1609 With argument N, scroll N lines; otherwise scroll by nearly
1610 the height of the merge window.
1611 `C-u -' alone as argument scrolls half the height of the merge window."
1613 (emerge-operate-on-windows
1615 ;; calculate argument to scroll-up
1616 ;; if there is an explicit argument
1617 (if (and arg (not (equal arg '-)))
1619 (prefix-numeric-value arg)
1620 ;; if not, see if we can determine a default amount (the window height)
1621 (let ((merge-window (get-buffer-window emerge-merge-buffer)))
1622 (if (null merge-window)
1623 ;; no window, use nil
1625 (let ((default-amount
1626 (- (window-height merge-window) 1 next-screen-context-lines)))
1627 ;; the window was found
1629 ;; C-u as argument means half of default amount
1630 (/ default-amount 2)
1631 ;; no argument means default amount
1632 default-amount)))))))
1634 (defun emerge-scroll-down (&optional arg)
1635 "Scroll down all three merge buffers, if they are in windows.
1636 With argument N, scroll N lines; otherwise scroll by nearly
1637 the height of the merge window.
1638 `C-u -' alone as argument scrolls half the height of the merge window."
1640 (emerge-operate-on-windows
1642 ;; calculate argument to scroll-down
1643 ;; if there is an explicit argument
1644 (if (and arg (not (equal arg '-)))
1646 (prefix-numeric-value arg)
1647 ;; if not, see if we can determine a default amount (the window height)
1648 (let ((merge-window (get-buffer-window emerge-merge-buffer)))
1649 (if (null merge-window)
1650 ;; no window, use nil
1652 (let ((default-amount
1653 (- (window-height merge-window) 1 next-screen-context-lines)))
1654 ;; the window was found
1656 ;; C-u as argument means half of default amount
1657 (/ default-amount 2)
1658 ;; no argument means default amount
1659 default-amount)))))))
1661 (defun emerge-scroll-left (&optional arg)
1662 "Scroll left all three merge buffers, if they are in windows.
1663 If an argument is given, that is how many columns are scrolled, else nearly
1664 the width of the A and B windows. `C-u -' alone as argument scrolls half the
1665 width of the A and B windows."
1667 (emerge-operate-on-windows
1669 ;; calculate argument to scroll-left
1670 ;; if there is an explicit argument
1671 (if (and arg (not (equal arg '-)))
1673 (prefix-numeric-value arg)
1674 ;; if not, see if we can determine a default amount
1675 ;; (half the window width)
1676 (let ((merge-window (get-buffer-window emerge-merge-buffer)))
1677 (if (null merge-window)
1678 ;; no window, use nil
1680 (let ((default-amount
1681 (- (/ (window-width merge-window) 2) 3)))
1682 ;; the window was found
1684 ;; C-u as argument means half of default amount
1685 (/ default-amount 2)
1686 ;; no argument means default amount
1687 default-amount)))))))
1689 (defun emerge-scroll-right (&optional arg)
1690 "Scroll right all three merge buffers, if they are in windows.
1691 If an argument is given, that is how many columns are scrolled, else nearly
1692 the width of the A and B windows. `C-u -' alone as argument scrolls half the
1693 width of the A and B windows."
1695 (emerge-operate-on-windows
1697 ;; calculate argument to scroll-right
1698 ;; if there is an explicit argument
1699 (if (and arg (not (equal arg '-)))
1701 (prefix-numeric-value arg)
1702 ;; if not, see if we can determine a default amount
1703 ;; (half the window width)
1704 (let ((merge-window (get-buffer-window emerge-merge-buffer)))
1705 (if (null merge-window)
1706 ;; no window, use nil
1708 (let ((default-amount
1709 (- (/ (window-width merge-window) 2) 3)))
1710 ;; the window was found
1712 ;; C-u as argument means half of default amount
1713 (/ default-amount 2)
1714 ;; no argument means default amount
1715 default-amount)))))))
1717 (defun emerge-scroll-reset ()
1718 "Reset horizontal scrolling in Emerge.
1719 This resets the horizontal scrolling of all three merge buffers
1720 to the left margin, if they are in windows."
1722 (emerge-operate-on-windows
1723 (function (lambda (x) (set-window-hscroll (selected-window) 0)))
1726 ;; Attempt to show the region nicely.
1727 ;; If there are min-lines lines above and below the region, then don't do
1729 ;; If not, recenter the region to make it so.
1730 ;; If that isn't possible, remove context lines balancedly from top and botton
1731 ;; so the entire region shows.
1732 ;; If that isn't possible, show the top of the region.
1733 ;; BEG must be at the beginning of a line.
1734 (defun emerge-position-region (beg end pos)
1735 ;; First test whether the entire region is visible with
1736 ;; emerge-min-visible-lines above and below it
1737 (if (not (and (<= (progn
1738 (move-to-window-line emerge-min-visible-lines)
1742 (move-to-window-line
1743 (- (1+ emerge-min-visible-lines)))
1745 ;; We failed that test, see if it fits at all
1746 ;; Meanwhile positioning it correctly in case it doesn't fit
1748 (set-window-start (selected-window) beg)
1749 (if (pos-visible-in-window-p end)
1750 ;; Determine the number of lines that the region occupies
1752 (while (> end (progn
1753 (move-to-window-line lines)
1755 (setq lines (1+ lines)))
1756 ;; And position the beginning on the right line
1758 (recenter (/ (1+ (- (1- (window-height (selected-window)))
1763 (defun emerge-next-difference ()
1764 "Advance to the next difference."
1766 (if (< emerge-current-difference emerge-number-of-differences)
1767 (let ((n (1+ emerge-current-difference)))
1768 (while (and emerge-skip-prefers
1769 (< n emerge-number-of-differences)
1770 (memq (aref (aref emerge-difference-list n) 6)
1771 '(prefer-A prefer-B)))
1773 (let ((buffer-read-only nil))
1774 (emerge-unselect-and-select-difference n)))
1777 (defun emerge-previous-difference ()
1778 "Go to the previous difference."
1780 (if (> emerge-current-difference -1)
1781 (let ((n (1- emerge-current-difference)))
1782 (while (and emerge-skip-prefers
1784 (memq (aref (aref emerge-difference-list n) 6)
1785 '(prefer-A prefer-B)))
1787 (let ((buffer-read-only nil))
1788 (emerge-unselect-and-select-difference n)))
1789 (error "At beginning")))
1791 (defun emerge-jump-to-difference (difference-number)
1792 "Go to the N-th difference."
1794 (let ((buffer-read-only nil))
1795 (setq difference-number (1- difference-number))
1796 (if (and (>= difference-number -1)
1797 (< difference-number (1+ emerge-number-of-differences)))
1798 (emerge-unselect-and-select-difference difference-number)
1799 (error "Bad difference number"))))
1801 (defun emerge-abort ()
1802 "Abort the Emerge session."
1806 (defun emerge-quit (arg)
1807 "Finish the Emerge session and exit Emerge.
1808 Prefix argument means to abort rather than successfully finish.
1809 The difference depends on how the merge was started,
1810 but usually means to not write over one of the original files, or to signal
1811 to some process which invoked Emerge a failure code.
1813 Unselects the selected difference, if any, restores the read-only and modified
1814 flags of the merged file buffers, restores the local keymap of the merge
1815 buffer, and sets off various emerge flags. Using Emerge commands in this
1816 buffer after this will cause serious problems."
1821 "Do you really want to successfully finish this merge? "
1822 "Do you really want to abort this merge? "))
1824 (emerge-really-quit arg)))
1826 ;; Perform the quit operations.
1827 (defun emerge-really-quit (arg)
1828 (setq buffer-read-only nil)
1829 (emerge-unselect-and-select-difference -1)
1830 (emerge-restore-buffer-characteristics)
1831 ;; null out the difference markers so they don't slow down future editing
1833 (mapcar (function (lambda (d)
1834 (set-marker (aref d 0) nil)
1835 (set-marker (aref d 1) nil)
1836 (set-marker (aref d 2) nil)
1837 (set-marker (aref d 3) nil)
1838 (set-marker (aref d 4) nil)
1839 (set-marker (aref d 5) nil)))
1840 emerge-difference-list)
1841 ;; allow them to be garbage collected
1842 (setq emerge-difference-list nil)
1843 ;; restore the local map
1844 (use-local-map emerge-old-keymap)
1845 ;; turn off all the emerge modes
1846 (setq emerge-mode nil)
1847 (setq emerge-fast-mode nil)
1848 (setq emerge-edit-mode nil)
1849 (setq emerge-auto-advance nil)
1850 (setq emerge-skip-prefers nil)
1851 ;; restore mode line
1852 (kill-local-variable 'mode-line-buffer-identification)
1853 (let ((emerge-prefix-argument arg))
1854 (run-hooks 'emerge-quit-hook)))
1856 (defun emerge-select-A (&optional force)
1857 "Select the A variant of this difference.
1858 Refuses to function if this difference has been edited, i.e., if it
1859 is neither the A nor the B variant.
1860 A prefix argument forces the variant to be selected
1861 even if the difference has been edited."
1864 (function (lambda ()
1865 (emerge-select-A-edit merge-begin merge-end A-begin A-end)
1866 (if emerge-auto-advance
1867 (emerge-next-difference)))))
1869 (function (lambda ()
1870 (if emerge-auto-advance
1871 (emerge-next-difference))))))
1872 (emerge-select-version force operate-no-change operate operate)))
1874 ;; Actually select the A variant
1875 (defun emerge-select-A-edit (merge-begin merge-end A-begin A-end)
1876 (emerge-eval-in-buffer
1878 (delete-region merge-begin merge-end)
1879 (goto-char merge-begin)
1880 (insert-buffer-substring emerge-A-buffer A-begin A-end)
1881 (goto-char merge-begin)
1882 (aset diff-vector 6 'A)
1883 (emerge-refresh-mode-line)))
1885 (defun emerge-select-B (&optional force)
1886 "Select the B variant of this difference.
1887 Refuses to function if this difference has been edited, i.e., if it
1888 is neither the A nor the B variant.
1889 A prefix argument forces the variant to be selected
1890 even if the difference has been edited."
1893 (function (lambda ()
1894 (emerge-select-B-edit merge-begin merge-end B-begin B-end)
1895 (if emerge-auto-advance
1896 (emerge-next-difference)))))
1898 (function (lambda ()
1899 (if emerge-auto-advance
1900 (emerge-next-difference))))))
1901 (emerge-select-version force operate operate-no-change operate)))
1903 ;; Actually select the B variant
1904 (defun emerge-select-B-edit (merge-begin merge-end B-begin B-end)
1905 (emerge-eval-in-buffer
1907 (delete-region merge-begin merge-end)
1908 (goto-char merge-begin)
1909 (insert-buffer-substring emerge-B-buffer B-begin B-end)
1910 (goto-char merge-begin)
1911 (aset diff-vector 6 'B)
1912 (emerge-refresh-mode-line)))
1914 (defun emerge-default-A ()
1915 "Make the A variant the default from here down.
1916 This selects the A variant for all differences from here down in the buffer
1917 which are still defaulted, i.e., which the user has not selected and for
1918 which there is no preference."
1920 (let ((buffer-read-only nil))
1921 (let ((selected-difference emerge-current-difference)
1922 (n (max emerge-current-difference 0)))
1923 (while (< n emerge-number-of-differences)
1924 (let ((diff-vector (aref emerge-difference-list n)))
1925 (if (eq (aref diff-vector 6) 'default-B)
1927 (emerge-unselect-and-select-difference n t)
1929 (aset diff-vector 6 'default-A))))
1931 (if (zerop (% n 10))
1932 (message "Setting default to A...%d" n)))
1933 (emerge-unselect-and-select-difference selected-difference)))
1934 (message "Default choice is now A"))
1936 (defun emerge-default-B ()
1937 "Make the B variant the default from here down.
1938 This selects the B variant for all differences from here down in the buffer
1939 which are still defaulted, i.e., which the user has not selected and for
1940 which there is no preference."
1942 (let ((buffer-read-only nil))
1943 (let ((selected-difference emerge-current-difference)
1944 (n (max emerge-current-difference 0)))
1945 (while (< n emerge-number-of-differences)
1946 (let ((diff-vector (aref emerge-difference-list n)))
1947 (if (eq (aref diff-vector 6) 'default-A)
1949 (emerge-unselect-and-select-difference n t)
1951 (aset diff-vector 6 'default-B))))
1953 (if (zerop (% n 10))
1954 (message "Setting default to B...%d" n)))
1955 (emerge-unselect-and-select-difference selected-difference)))
1956 (message "Default choice is now B"))
1958 (defun emerge-fast-mode ()
1959 "Set fast mode, for Emerge.
1960 In this mode ordinary Emacs commands are disabled, and Emerge commands
1961 need not be prefixed with \\<emerge-fast-keymap>\\[emerge-basic-keymap]."
1963 (setq buffer-read-only t)
1964 (use-local-map emerge-fast-keymap)
1965 (setq emerge-mode t)
1966 (setq emerge-fast-mode t)
1967 (setq emerge-edit-mode nil)
1968 (message "Fast mode set")
1969 ;; force mode line redisplay
1970 (set-buffer-modified-p (buffer-modified-p)))
1972 (defun emerge-edit-mode ()
1973 "Set edit mode, for Emerge.
1974 In this mode ordinary Emacs commands are available, and Emerge commands
1975 must be prefixed with \\<emerge-fast-keymap>\\[emerge-basic-keymap]."
1977 (setq buffer-read-only nil)
1978 (use-local-map emerge-edit-keymap)
1979 (setq emerge-mode t)
1980 (setq emerge-fast-mode nil)
1981 (setq emerge-edit-mode t)
1982 (message "Edit mode set")
1983 ;; force mode line redisplay
1984 (set-buffer-modified-p (buffer-modified-p)))
1986 (defun emerge-auto-advance (arg)
1987 "Toggle Auto-Advance mode, for Emerge.
1988 This mode causes `emerge-select-A' and `emerge-select-B' to automatically
1989 advance to the next difference.
1990 With a positive argument, turn on Auto-Advance mode.
1991 With a negative argument, turn off Auto-Advance mode."
1993 (setq emerge-auto-advance (if (null arg)
1994 (not emerge-auto-advance)
1995 (> (prefix-numeric-value arg) 0)))
1996 (message (if emerge-skip-prefers
1998 "Auto-advance cleared"))
1999 ;; force mode line redisplay
2000 (set-buffer-modified-p (buffer-modified-p)))
2002 (defun emerge-skip-prefers (arg)
2003 "Toggle Skip-Prefers mode, for Emerge.
2004 This mode causes `emerge-next-difference' and `emerge-previous-difference'
2005 to automatically skip over differences for which there is a preference.
2006 With a positive argument, turn on Skip-Prefers mode.
2007 With a negative argument, turn off Skip-Prefers mode."
2009 (setq emerge-skip-prefers (if (null arg)
2010 (not emerge-skip-prefers)
2011 (> (prefix-numeric-value arg) 0)))
2012 (message (if emerge-skip-prefers
2014 "Skip-prefers cleared"))
2015 ;; force mode line redisplay
2016 (set-buffer-modified-p (buffer-modified-p)))
2018 (defun emerge-copy-as-kill-A ()
2019 "Put the A variant of this difference in the kill ring."
2021 (emerge-validate-difference)
2023 (aref emerge-difference-list emerge-current-difference))
2024 (A-begin (1+ (aref diff-vector 0)))
2025 (A-end (1- (aref diff-vector 1)))
2026 ;; so further kills don't append
2029 (set-buffer emerge-A-buffer)
2030 (copy-region-as-kill A-begin A-end))))
2032 (defun emerge-copy-as-kill-B ()
2033 "Put the B variant of this difference in the kill ring."
2035 (emerge-validate-difference)
2037 (aref emerge-difference-list emerge-current-difference))
2038 (B-begin (1+ (aref diff-vector 2)))
2039 (B-end (1- (aref diff-vector 3)))
2040 ;; so further kills don't append
2043 (set-buffer emerge-B-buffer)
2044 (copy-region-as-kill B-begin B-end))))
2046 (defun emerge-insert-A (arg)
2047 "Insert the A variant of this difference at the point.
2048 Leaves point after text, mark before.
2049 With prefix argument, puts point before, mark after."
2051 (emerge-validate-difference)
2053 (aref emerge-difference-list emerge-current-difference))
2054 (A-begin (1+ (aref diff-vector 0)))
2055 (A-end (1- (aref diff-vector 1)))
2057 (buffer-read-only nil))
2058 (insert-buffer-substring emerge-A-buffer A-begin A-end)
2062 (goto-char opoint))))
2064 (defun emerge-insert-B (arg)
2065 "Insert the B variant of this difference at the point.
2066 Leaves point after text, mark before.
2067 With prefix argument, puts point before, mark after."
2069 (emerge-validate-difference)
2071 (aref emerge-difference-list emerge-current-difference))
2072 (B-begin (1+ (aref diff-vector 2)))
2073 (B-end (1- (aref diff-vector 3)))
2075 (buffer-read-only nil))
2076 (insert-buffer-substring emerge-B-buffer B-begin B-end)
2080 (goto-char opoint))))
2082 (defun emerge-mark-difference (arg)
2083 "Leaves the point before this difference and the mark after it.
2084 With prefix argument, puts mark before, point after."
2086 (emerge-validate-difference)
2088 (aref emerge-difference-list emerge-current-difference))
2089 (merge-begin (1+ (aref diff-vector 4)))
2090 (merge-end (1- (aref diff-vector 5))))
2093 (goto-char merge-begin)
2094 (set-mark merge-end))
2095 (goto-char merge-end)
2096 (set-mark merge-begin))))
2098 (defun emerge-file-names ()
2099 "Show the names of the buffers or files being operated on by Emerge.
2100 Use C-u l to reset the windows afterward."
2102 (delete-other-windows)
2103 (let ((temp-buffer-show-function
2104 (function (lambda (buf)
2105 (split-window-vertically)
2106 (switch-to-buffer buf)
2107 (other-window 1)))))
2108 (with-output-to-temp-buffer "*Help*"
2109 (emerge-eval-in-buffer emerge-A-buffer
2110 (if buffer-file-name
2112 (princ "File A is: ")
2113 (princ buffer-file-name))
2115 (princ "Buffer A is: ")
2116 (princ (buffer-name))))
2118 (emerge-eval-in-buffer emerge-B-buffer
2119 (if buffer-file-name
2121 (princ "File B is: ")
2122 (princ buffer-file-name))
2124 (princ "Buffer B is: ")
2125 (princ (buffer-name))))
2127 (if emerge-ancestor-buffer
2128 (emerge-eval-in-buffer emerge-ancestor-buffer
2129 (if buffer-file-name
2131 (princ "Ancestor file is: ")
2132 (princ buffer-file-name))
2134 (princ "Ancestor buffer is: ")
2135 (princ (buffer-name))))
2137 (princ emerge-output-description))))
2139 (defun emerge-join-differences (arg)
2140 "Join the selected difference with the following one.
2141 With a prefix argument, join with the preceding one."
2143 (let ((n emerge-current-difference))
2144 ;; adjust n to be first difference to join
2147 ;; n and n+1 are the differences to join
2148 ;; check that they are both differences
2149 (if (or (< n 0) (>= n (1- emerge-number-of-differences)))
2150 (error "Incorrect differences to join"))
2152 (emerge-unselect-difference emerge-current-difference)
2153 ;; decrement total number of differences
2154 (setq emerge-number-of-differences (1- emerge-number-of-differences))
2155 ;; build new differences vector
2157 (new-differences (make-vector emerge-number-of-differences nil)))
2158 (while (< i emerge-number-of-differences)
2159 (aset new-differences i
2161 ((< i n) (aref emerge-difference-list i))
2162 ((> i n) (aref emerge-difference-list (1+ i)))
2163 (t (let ((prev (aref emerge-difference-list i))
2164 (next (aref emerge-difference-list (1+ i))))
2165 (vector (aref prev 0)
2171 (let ((ps (aref prev 6))
2176 ((and (or (eq ps 'B) (eq ps 'prefer-B))
2177 (or (eq ns 'B) (eq ns 'prefer-B)))
2181 (setq emerge-difference-list new-differences))
2182 ;; set the current difference correctly
2183 (setq emerge-current-difference n)
2184 ;; fix the mode line
2185 (emerge-refresh-mode-line)
2186 ;; reinsert the flags
2187 (emerge-select-difference emerge-current-difference)
2190 (defun emerge-split-difference ()
2191 "Split the current difference where the points are in the three windows."
2193 (let ((n emerge-current-difference))
2194 ;; check that this is a valid difference
2195 (emerge-validate-difference)
2196 ;; get the point values and old difference
2197 (let ((A-point (emerge-eval-in-buffer emerge-A-buffer
2199 (B-point (emerge-eval-in-buffer emerge-B-buffer
2201 (merge-point (point-marker))
2202 (old-diff (aref emerge-difference-list n)))
2203 ;; check location of the points, give error if they aren't in the
2205 (if (or (< A-point (aref old-diff 0))
2206 (> A-point (aref old-diff 1)))
2207 (error "Point outside of difference in A buffer"))
2208 (if (or (< B-point (aref old-diff 2))
2209 (> B-point (aref old-diff 3)))
2210 (error "Point outside of difference in B buffer"))
2211 (if (or (< merge-point (aref old-diff 4))
2212 (> merge-point (aref old-diff 5)))
2213 (error "Point outside of difference in merge buffer"))
2215 (emerge-unselect-difference emerge-current-difference)
2216 ;; increment total number of differences
2217 (setq emerge-number-of-differences (1+ emerge-number-of-differences))
2218 ;; build new differences vector
2220 (new-differences (make-vector emerge-number-of-differences nil)))
2221 (while (< i emerge-number-of-differences)
2222 (aset new-differences i
2225 (aref emerge-difference-list i))
2227 (aref emerge-difference-list (1- i)))
2229 (vector (aref old-diff 0)
2237 (vector (copy-marker A-point)
2239 (copy-marker B-point)
2241 (copy-marker merge-point)
2243 (aref old-diff 6)))))
2245 (setq emerge-difference-list new-differences))
2246 ;; set the current difference correctly
2247 (setq emerge-current-difference n)
2248 ;; fix the mode line
2249 (emerge-refresh-mode-line)
2250 ;; reinsert the flags
2251 (emerge-select-difference emerge-current-difference)
2252 (emerge-recenter))))
2254 (defun emerge-trim-difference ()
2255 "Trim lines off top and bottom of difference that are the same.
2256 If lines are the same in both the A and the B versions, strip them off.
2257 \(This can happen when the A and B versions have common lines that the
2258 ancestor version does not share.)"
2260 ;; make sure we are in a real difference
2261 (emerge-validate-difference)
2263 (emerge-unselect-difference emerge-current-difference)
2264 (let* ((diff (aref emerge-difference-list emerge-current-difference))
2265 (top-a (marker-position (aref diff 0)))
2266 (bottom-a (marker-position (aref diff 1)))
2267 (top-b (marker-position (aref diff 2)))
2268 (bottom-b (marker-position (aref diff 3)))
2269 (top-m (marker-position (aref diff 4)))
2270 (bottom-m (marker-position (aref diff 5)))
2271 size success sa sb sm)
2272 ;; move down the tops of the difference regions as much as possible
2273 ;; Try advancing comparing 1000 chars at a time.
2274 ;; When that fails, go 500 chars at a time, and so on.
2279 (setq size (min size (- bottom-a top-a) (- bottom-b top-b)
2280 (- bottom-m top-m)))
2281 (setq sa (emerge-eval-in-buffer emerge-A-buffer
2282 (buffer-substring top-a
2284 (setq sb (emerge-eval-in-buffer emerge-B-buffer
2285 (buffer-substring top-b
2287 (setq sm (buffer-substring top-m (+ size top-m)))
2288 (setq success (and (> size 0) (equal sa sb) (equal sb sm)))
2290 (setq top-a (+ top-a size)
2291 top-b (+ top-b size)
2292 top-m (+ top-m size))))
2293 (setq size (/ size 2)))
2294 ;; move up the bottoms of the difference regions as much as possible
2295 ;; Try advancing comparing 1000 chars at a time.
2296 ;; When that fails, go 500 chars at a time, and so on.
2301 (setq size (min size (- bottom-a top-a) (- bottom-b top-b)
2302 (- bottom-m top-m)))
2303 (setq sa (emerge-eval-in-buffer emerge-A-buffer
2304 (buffer-substring (- bottom-a size)
2306 (setq sb (emerge-eval-in-buffer emerge-B-buffer
2307 (buffer-substring (- bottom-b size)
2309 (setq sm (buffer-substring (- bottom-m size) bottom-m))
2310 (setq success (and (> size 0) (equal sa sb) (equal sb sm)))
2312 (setq bottom-a (- bottom-a size)
2313 bottom-b (- bottom-b size)
2314 bottom-m (- bottom-m size))))
2315 (setq size (/ size 2)))
2316 ;; {top,bottom}-{a,b,m} are now set at the new beginnings and ends
2317 ;; of the difference regions. Move them to the beginning of lines, as
2319 (emerge-eval-in-buffer emerge-A-buffer
2322 (aset diff 0 (point-marker))
2323 (goto-char bottom-a)
2324 (beginning-of-line 2)
2325 (aset diff 1 (point-marker)))
2326 (emerge-eval-in-buffer emerge-B-buffer
2329 (aset diff 2 (point-marker))
2330 (goto-char bottom-b)
2331 (beginning-of-line 2)
2332 (aset diff 3 (point-marker)))
2335 (aset diff 4 (point-marker))
2336 (goto-char bottom-m)
2337 (beginning-of-line 2)
2338 (aset diff 5 (point-marker))
2339 ;; put the flags back in, recenter the display
2340 (emerge-select-difference emerge-current-difference)
2343 (defun emerge-find-difference (arg)
2344 "Find the difference containing the current position of the point.
2345 If there is no containing difference and the prefix argument is positive,
2346 it finds the nearest following difference. A negative prefix argument finds
2347 the nearest previous difference."
2349 (cond ((eq (current-buffer) emerge-A-buffer)
2350 (emerge-find-difference-A arg))
2351 ((eq (current-buffer) emerge-B-buffer)
2352 (emerge-find-difference-B arg))
2353 (t (emerge-find-difference-merge arg))))
2355 (defun emerge-find-difference-merge (arg)
2356 "Find the difference containing point, in the merge buffer.
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."
2361 ;; search for the point in the merge buffer, using the markers
2362 ;; for the beginning and end of the differences in the merge buffer
2363 (emerge-find-difference1 arg (point) 4 5))
2365 (defun emerge-find-difference-A (arg)
2366 "Find the difference containing point, in the A buffer.
2367 This command must be executed in the merge buffer.
2368 If there is no containing difference and the prefix argument is positive,
2369 it finds the nearest following difference. A negative prefix argument finds
2370 the nearest previous difference."
2372 ;; search for the point in the A buffer, using the markers
2373 ;; for the beginning and end of the differences in the A buffer
2374 (emerge-find-difference1 arg
2375 (emerge-eval-in-buffer emerge-A-buffer (point))
2378 (defun emerge-find-difference-B (arg)
2379 "Find the difference containing point, in the B buffer.
2380 This command must be executed in the merge buffer.
2381 If there is no containing difference and the prefix argument is positive,
2382 it finds the nearest following difference. A negative prefix argument finds
2383 the nearest previous difference."
2385 ;; search for the point in the B buffer, using the markers
2386 ;; for the beginning and end of the differences in the B buffer
2387 (emerge-find-difference1 arg
2388 (emerge-eval-in-buffer emerge-B-buffer (point))
2391 (defun emerge-find-difference1 (arg location begin end)
2393 ;; find first difference containing or after the current position
2396 (while (< n emerge-number-of-differences)
2397 (let ((diff-vector (aref emerge-difference-list n)))
2398 (if (<= location (marker-position (aref diff-vector end)))
2401 emerge-number-of-differences))
2403 ;; whether the found difference contains the current position
2404 (and (< index emerge-number-of-differences)
2405 (<= (marker-position (aref (aref emerge-difference-list index)
2409 ;; numeric value of prefix argument
2410 (prefix-numeric-value arg)))
2411 (emerge-unselect-and-select-difference
2413 ;; if the point is in a difference, select it
2415 ;; if the arg is nil and the point is not in a difference, error
2416 ((null arg) (error "No difference contains point"))
2417 ;; if the arg is positive, select the following difference
2419 (if (< index emerge-number-of-differences)
2421 (error "No difference contains or follows point")))
2422 ;; if the arg is negative, select the preceding difference
2426 (error "No difference contains or precedes point")))))))
2428 (defun emerge-line-numbers ()
2429 "Display the current line numbers.
2430 This function displays the line numbers of the points in the A, B, and
2434 (and (>= emerge-current-difference 0)
2435 (< emerge-current-difference emerge-number-of-differences)))
2436 (diff (and valid-diff
2437 (aref emerge-difference-list emerge-current-difference)))
2438 (merge-line (emerge-line-number-in-buf 4 5))
2439 (A-line (emerge-eval-in-buffer emerge-A-buffer
2440 (emerge-line-number-in-buf 0 1)))
2441 (B-line (emerge-eval-in-buffer emerge-B-buffer
2442 (emerge-line-number-in-buf 2 3))))
2443 (message "At lines: merge = %d, A = %d, B = %d"
2444 merge-line A-line B-line)))
2446 (defun emerge-line-number-in-buf (begin-marker end-marker)
2448 (setq temp (save-excursion
2450 (1+ (count-lines 1 (point)))))
2453 (if (> (point) (aref diff begin-marker))
2454 (setq temp (- temp emerge-before-flag-lines)))
2455 (if (> (point) (aref diff end-marker))
2456 (setq temp (- temp emerge-after-flag-lines)))))
2459 (defun emerge-set-combine-template (string &optional localize)
2460 "Set `emerge-combine-versions-template' to STRING.
2461 This value controls how `emerge-combine-versions' combines the two versions.
2462 With prefix argument, `emerge-combine-versions-template' is made local to this
2463 merge buffer. Localization is permanent for any particular merge buffer."
2464 (interactive "s\nP")
2466 (make-local-variable 'emerge-combine-versions-template))
2467 (setq emerge-combine-versions-template string)
2469 (if (assq 'emerge-combine-versions-template (buffer-local-variables))
2470 "emerge-set-combine-versions-template set locally"
2471 "emerge-set-combine-versions-template set")))
2473 (defun emerge-set-combine-versions-template (start end &optional localize)
2474 "Copy region into `emerge-combine-versions-template'.
2475 This controls how `emerge-combine-versions' will combine the two versions.
2476 With prefix argument, `emerge-combine-versions-template' is made local to this
2477 merge buffer. Localization is permanent for any particular merge buffer."
2478 (interactive "r\nP")
2480 (make-local-variable 'emerge-combine-versions-template))
2481 (setq emerge-combine-versions-template (buffer-substring start end))
2483 (if (assq 'emerge-combine-versions-template (buffer-local-variables))
2484 "emerge-set-combine-versions-template set locally."
2485 "emerge-set-combine-versions-template set.")))
2487 (defun emerge-combine-versions (&optional force)
2488 "Combine versions using the template in `emerge-combine-versions-template'.
2489 Refuses to function if this difference has been edited, i.e., if it is
2490 neither the A nor the B variant.
2491 An argument forces the variant to be selected even if the difference has
2494 (emerge-combine-versions-internal emerge-combine-versions-template force))
2496 (defun emerge-combine-versions-register (char &optional force)
2497 "Combine the two versions using the template in register REG.
2498 See documentation of the variable `emerge-combine-versions-template'
2499 for how the template is interpreted.
2500 Refuses to function if this difference has been edited, i.e., if it is
2501 neither the A nor the B variant.
2502 An argument forces the variant to be selected even if the difference has
2504 (interactive "cRegister containing template: \nP")
2505 (let ((template (get-register char)))
2506 (if (not (stringp template))
2507 (error "Register does not contain text"))
2508 (emerge-combine-versions-internal template force)))
2510 (defun emerge-combine-versions-internal (template force)
2512 (function (lambda ()
2513 (emerge-combine-versions-edit merge-begin merge-end
2514 A-begin A-end B-begin B-end)
2515 (if emerge-auto-advance
2516 (emerge-next-difference))))))
2517 (emerge-select-version force operate operate operate)))
2519 (defun emerge-combine-versions-edit (merge-begin merge-end
2520 A-begin A-end B-begin B-end)
2521 (emerge-eval-in-buffer
2523 (delete-region merge-begin merge-end)
2524 (goto-char merge-begin)
2526 (while (< i (length template))
2527 (let ((c (aref template i)))
2536 (insert-buffer-substring emerge-A-buffer A-begin A-end))
2538 (insert-buffer-substring emerge-B-buffer B-begin B-end))
2545 (goto-char merge-begin)
2546 (aset diff-vector 6 'combined)
2547 (emerge-refresh-mode-line)))
2549 (defun emerge-set-merge-mode (mode)
2550 "Set the major mode in a merge buffer.
2551 Overrides any change that the mode might make to the mode line or local
2552 keymap. Leaves merge in fast mode."
2554 (list (intern (completing-read "New major mode for merge buffer: "
2555 obarray 'commandp t nil))))
2557 (emerge-refresh-mode-line)
2558 (if emerge-fast-mode
2560 (emerge-edit-mode)))
2562 (defun emerge-one-line-window ()
2564 (let ((window-min-height 1))
2565 (shrink-window (- (window-height) 2))))
2567 ;;; Support routines
2569 ;; Select a difference by placing the visual flags around the appropriate
2570 ;; group of lines in the A, B, and merge buffers
2571 (defun emerge-select-difference (n)
2572 (let ((emerge-globalized-difference-list emerge-difference-list)
2573 (emerge-globalized-number-of-differences emerge-number-of-differences))
2574 (emerge-place-flags-in-buffer emerge-A-buffer n 0 1)
2575 (emerge-place-flags-in-buffer emerge-B-buffer n 2 3)
2576 (emerge-place-flags-in-buffer nil n 4 5))
2577 (run-hooks 'emerge-select-hook))
2579 (defun emerge-place-flags-in-buffer (buffer difference before-index
2582 (emerge-eval-in-buffer
2584 (emerge-place-flags-in-buffer1 difference before-index after-index))
2585 (emerge-place-flags-in-buffer1 difference before-index after-index)))
2587 (defun emerge-place-flags-in-buffer1 (difference before-index after-index)
2588 (let ((buffer-read-only nil))
2589 ;; insert the flag before the difference
2590 (let ((before (aref (aref emerge-globalized-difference-list difference)
2594 ;; insert the flag itself
2595 (insert-before-markers emerge-before-flag)
2597 ;; Put the marker(s) referring to this position 1 character before the
2598 ;; end of the flag, so it won't be damaged by the user.
2599 ;; This gets a bit tricky, as there could be a number of markers
2600 ;; that have to be moved.
2601 (set-marker before (1- before))
2602 (let ((n (1- difference)) after-marker before-marker diff-list)
2606 (setq diff-list (aref emerge-globalized-difference-list n)
2607 after-marker (aref diff-list after-index))
2608 (= after-marker here)))
2609 (set-marker after-marker (1- after-marker))
2610 (setq before-marker (aref diff-list before-index))
2611 (if (= before-marker here)
2612 (setq before-marker (1- before-marker)))
2614 ;; insert the flag after the difference
2615 (let* ((after (aref (aref emerge-globalized-difference-list difference)
2617 (here (marker-position after)))
2619 ;; insert the flag itself
2620 (insert emerge-after-flag)
2621 ;; Put the marker(s) referring to this position 1 character after the
2622 ;; beginning of the flag, so it won't be damaged by the user.
2623 ;; This gets a bit tricky, as there could be a number of markers
2624 ;; that have to be moved.
2625 (set-marker after (1+ after))
2626 (let ((n (1+ difference)) before-marker after-marker diff-list)
2628 (< n emerge-globalized-number-of-differences)
2630 (setq diff-list (aref emerge-globalized-difference-list n)
2631 before-marker (aref diff-list before-index))
2632 (= before-marker here)))
2633 (set-marker before-marker (1+ before-marker))
2634 (setq after-marker (aref diff-list after-index))
2635 (if (= after-marker here)
2636 (setq after-marker (1+ after-marker)))
2637 (setq n (1+ n)))))))
2639 ;; Unselect a difference by removing the visual flags in the buffers.
2640 (defun emerge-unselect-difference (n)
2641 (let ((diff-vector (aref emerge-difference-list n)))
2642 (emerge-remove-flags-in-buffer emerge-A-buffer
2643 (aref diff-vector 0) (aref diff-vector 1))
2644 (emerge-remove-flags-in-buffer emerge-B-buffer
2645 (aref diff-vector 2) (aref diff-vector 3))
2646 (emerge-remove-flags-in-buffer emerge-merge-buffer
2647 (aref diff-vector 4) (aref diff-vector 5)))
2648 (run-hooks 'emerge-unselect-hook))
2650 (defun emerge-remove-flags-in-buffer (buffer before after)
2651 (emerge-eval-in-buffer
2653 (let ((buffer-read-only nil))
2654 ;; remove the flags, if they're there
2655 (goto-char (- before (1- emerge-before-flag-length)))
2656 (if (looking-at emerge-before-flag-match)
2657 (delete-char emerge-before-flag-length)
2658 ;; the flag isn't there
2660 (message "Trouble removing flag"))
2661 (goto-char (1- after))
2662 (if (looking-at emerge-after-flag-match)
2663 (delete-char emerge-after-flag-length)
2664 ;; the flag isn't there
2666 (message "Trouble removing flag")))))
2668 ;; Select a difference, removing any flags that exist now.
2669 (defun emerge-unselect-and-select-difference (n &optional suppress-display)
2670 (if (and (>= emerge-current-difference 0)
2671 (< emerge-current-difference emerge-number-of-differences))
2672 (emerge-unselect-difference emerge-current-difference))
2673 (if (and (>= n 0) (< n emerge-number-of-differences))
2675 (emerge-select-difference n)
2676 (let* ((diff-vector (aref emerge-difference-list n))
2677 (selection-type (aref diff-vector 6)))
2678 (if (eq selection-type 'default-A)
2679 (aset diff-vector 6 'A)
2680 (if (eq selection-type 'default-B)
2681 (aset diff-vector 6 'B))))))
2682 (setq emerge-current-difference n)
2683 (if (not suppress-display)
2686 (emerge-refresh-mode-line))))
2688 ;; Perform tests to see whether user should be allowed to select a version
2689 ;; of this difference:
2690 ;; a valid difference has been selected; and
2691 ;; the difference text in the merge buffer is:
2692 ;; the A version (execute a-version), or
2693 ;; the B version (execute b-version), or
2694 ;; empty (execute neither-version), or
2695 ;; argument FORCE is true (execute neither-version)
2696 ;; Otherwise, signal an error.
2697 (defun emerge-select-version (force a-version b-version neither-version)
2698 (emerge-validate-difference)
2699 (let ((buffer-read-only nil))
2701 (aref emerge-difference-list emerge-current-difference))
2702 (A-begin (1+ (aref diff-vector 0)))
2703 (A-end (1- (aref diff-vector 1)))
2704 (B-begin (1+ (aref diff-vector 2)))
2705 (B-end (1- (aref diff-vector 3)))
2706 (merge-begin (1+ (aref diff-vector 4)))
2707 (merge-end (1- (aref diff-vector 5))))
2708 (if (emerge-compare-buffers emerge-A-buffer A-begin A-end
2709 emerge-merge-buffer merge-begin
2712 (if (emerge-compare-buffers emerge-B-buffer B-begin B-end
2713 emerge-merge-buffer merge-begin
2716 (if (or force (= merge-begin merge-end))
2717 (funcall neither-version)
2718 (error "This difference region has been edited")))))))
2720 ;; Read a file name, handling all of the various defaulting rules.
2722 (defun emerge-read-file-name (prompt alternative-default-dir default-file
2724 ;; `prompt' should not have trailing ": ", so that it can be modified
2725 ;; according to context.
2726 ;; If alternative-default-dir is non-nil, it should be used as the default
2727 ;; directory instead if default-directory, if emerge-default-last-directories
2729 ;; If default-file is set, it should be used as the default value.
2730 ;; If A-file is set, and its directory is different from
2731 ;; alternative-default-dir, and if emerge-default-last-directories is set,
2732 ;; the default file should be the last part of A-file in the default
2733 ;; directory. (Overriding default-file.)
2735 ;; If this is not the A-file argument (shown by non-nil A-file), and
2736 ;; if emerge-default-last-directories is set, and
2737 ;; the default directory exists but is not the same as the directory of the
2739 ;; then make the default file have the same name as the A-file, but in
2740 ;; the default directory.
2741 ((and emerge-default-last-directories
2743 alternative-default-dir
2744 (not (string-equal alternative-default-dir
2745 (file-name-directory A-file))))
2746 (read-file-name (format "%s (default %s): "
2747 prompt (file-name-nondirectory A-file))
2748 alternative-default-dir
2749 (concat alternative-default-dir
2750 (file-name-nondirectory A-file))
2752 ;; If there is a default file, use it.
2754 (read-file-name (format "%s (default %s): " prompt default-file)
2755 ;; If emerge-default-last-directories is set, use the
2756 ;; directory from the same argument of the last call of
2757 ;; Emerge as the default for this argument.
2758 (and emerge-default-last-directories
2759 alternative-default-dir)
2760 default-file 'confirm))
2762 (read-file-name (concat prompt ": ")
2763 ;; If emerge-default-last-directories is set, use the
2764 ;; directory from the same argument of the last call of
2765 ;; Emerge as the default for this argument.
2766 (and emerge-default-last-directories
2767 alternative-default-dir)
2770 ;; Revise the mode line to display which difference we have selected
2772 (defun emerge-refresh-mode-line ()
2773 (setq mode-line-buffer-identification
2774 (list (format "Emerge: %%b diff %d of %d%s"
2775 (1+ emerge-current-difference)
2776 emerge-number-of-differences
2777 (if (and (>= emerge-current-difference 0)
2778 (< emerge-current-difference
2779 emerge-number-of-differences))
2780 (cdr (assq (aref (aref emerge-difference-list
2781 emerge-current-difference)
2785 (prefer-A . " - A*")
2786 (prefer-B . " - B*")
2787 (combined . " - comb"))))
2789 ;; Force mode-line redisplay
2790 (set-buffer-modified-p (buffer-modified-p)))
2792 ;; compare two regions in two buffers for containing the same text
2793 (defun emerge-compare-buffers (buffer-x x-begin x-end buffer-y y-begin y-end)
2794 ;; first check that the two regions are the same length
2795 (if (not (and (= (- x-end x-begin) (- y-end y-begin))))
2798 (while (< x-begin x-end)
2799 ;; bite off and compare no more than 1000 characters at a time
2800 (let* ((compare-length (min (- x-end x-begin) 1000))
2801 (x-string (emerge-eval-in-buffer
2803 (buffer-substring x-begin
2804 (+ x-begin compare-length))))
2805 (y-string (emerge-eval-in-buffer
2807 (buffer-substring y-begin
2808 (+ y-begin compare-length)))))
2809 (if (not (string-equal x-string y-string))
2811 (setq x-begin (+ x-begin compare-length))
2812 (setq y-begin (+ y-begin compare-length)))))
2815 ;; Construct a unique buffer name.
2816 ;; The first one tried is prefixsuffix, then prefix<2>suffix,
2817 ;; prefix<3>suffix, etc.
2818 (defun emerge-unique-buffer-name (prefix suffix)
2819 (if (null (get-buffer (concat prefix suffix)))
2820 (concat prefix suffix)
2822 (while (get-buffer (format "%s<%d>%s" prefix n suffix))
2824 (format "%s<%d>%s" prefix n suffix))))
2826 ;; Verify that we have a difference selected.
2827 (defun emerge-validate-difference ()
2828 (if (not (and (>= emerge-current-difference 0)
2829 (< emerge-current-difference emerge-number-of-differences)))
2830 (error "No difference selected")))
2832 ;;; Functions for saving and restoring a batch of variables
2834 ;; These functions save (get the values of) and restore (set the values of)
2835 ;; a list of variables. The argument is a list of symbols (the names of
2836 ;; the variables). A list element can also be a list of two functions,
2837 ;; the first of which (when called with no arguments) gets the value, and
2838 ;; the second (when called with a value as an argment) sets the value.
2839 ;; A "function" is anything that funcall can handle as an argument.
2841 (defun emerge-save-variables (vars)
2842 (mapcar (function (lambda (v) (if (symbolp v)
2844 (funcall (car v)))))
2847 (defun emerge-restore-variables (vars values)
2849 (let ((var (car vars))
2850 (value (car values)))
2853 (funcall (car (cdr var)) value)))
2854 (setq vars (cdr vars))
2855 (setq values (cdr values))))
2857 ;; Make a temporary file that only we have access to.
2858 ;; PREFIX is appended to emerge-temp-file-prefix to make the filename prefix.
2859 (defun emerge-make-temp-file (prefix)
2860 (let ((f (make-temp-name (concat emerge-temp-file-prefix prefix))))
2862 (write-region (point-min) (point-min) f nil 'no-message)
2863 (set-file-modes f emerge-temp-file-mode)
2866 ;;; Functions that query the user before he can write out the current buffer.
2868 (defun emerge-query-write-file ()
2869 "Ask the user whether to write out an incomplete merge.
2870 If answer is yes, call `write-file' to do so. See `emerge-query-and-call'
2871 for details of the querying process."
2873 (emerge-query-and-call 'write-file))
2875 (defun emerge-query-save-buffer ()
2876 "Ask the user whether to save an incomplete merge.
2877 If answer is yes, call `save-buffer' to do so. See `emerge-query-and-call'
2878 for details of the querying process."
2880 (emerge-query-and-call 'save-buffer))
2882 (defun emerge-query-and-call (command)
2883 "Ask the user whether to save or write out the incomplete merge.
2884 If answer is yes, call COMMAND interactively. During the call, the flags
2885 around the current difference are removed."
2886 (if (yes-or-no-p "Do you really write to write out this unfinished merge? ")
2887 ;; He really wants to do it -- unselect the difference for the duration
2889 (if (and (>= emerge-current-difference 0)
2890 (< emerge-current-difference emerge-number-of-differences))
2891 (emerge-unselect-difference emerge-current-difference))
2892 ;; call-interactively takes the value of current-prefix-arg as the
2893 ;; prefix argument value to be passed to the command. Thus, we have
2894 ;; to do nothing special to make sure the prefix argument is
2895 ;; transmitted to the command.
2896 (call-interactively command)
2897 (if (and (>= emerge-current-difference 0)
2898 (< emerge-current-difference emerge-number-of-differences))
2900 (emerge-select-difference emerge-current-difference)
2901 (emerge-recenter))))
2902 ;; He's being smart and not doing it
2903 (message "Not written")))
2905 ;; Make sure the current buffer (for a file) has the same contents as the
2906 ;; file on disk, and attempt to remedy the situation if not.
2907 ;; Signal an error if we can't make them the same, or the user doesn't want
2908 ;; to do what is necessary to make them the same.
2909 (defun emerge-verify-file-buffer ()
2910 ;; First check if the file has been modified since the buffer visited it.
2911 (if (verify-visited-file-modtime (current-buffer))
2912 (if (buffer-modified-p)
2913 ;; If buffer is not obsolete and is modified, offer to save
2914 (if (yes-or-no-p (format "Save file %s? " buffer-file-name))
2916 (error "Buffer out of sync for file %s" buffer-file-name))
2917 ;; If buffer is not obsolete and is not modified, do nothing
2919 (if (buffer-modified-p)
2920 ;; If buffer is obsolete and is modified, give error
2921 (error "Buffer out of sync for file %s" buffer-file-name)
2922 ;; If buffer is obsolete and is not modified, offer to revert
2923 (if (yes-or-no-p (format "Revert file %s? " buffer-file-name))
2925 (error "Buffer out of sync for file %s" buffer-file-name)))))
2927 ;; Utilities that might have value outside of Emerge.
2929 ;; Set up the mode in the current buffer to duplicate the mode in another
2931 (defun emerge-copy-modes (buffer)
2932 ;; Set the major mode
2933 (funcall (emerge-eval-in-buffer buffer major-mode)))
2935 ;; Define a key, even if a prefix of it is defined
2936 (defun emerge-force-define-key (keymap key definition)
2937 "Like `define-key', but forcibly creates prefix characters as needed.
2938 If some prefix of KEY has a non-prefix definition, it is redefined."
2939 ;; Find out if a prefix of key is defined
2940 (let ((v (lookup-key keymap key)))
2941 ;; If so, undefine it
2943 (define-key keymap (substring key 0 v) nil)))
2944 ;; Now define the key
2945 (define-key keymap key definition))
2947 ;;;;; Improvements to describe-mode, so that it describes minor modes as well
2948 ;;;;; as the major mode
2949 ;;(defun describe-mode (&optional minor)
2950 ;; "Display documentation of current major mode.
2951 ;;If optional arg MINOR is non-nil (or prefix argument is given if interactive),
2952 ;;display documentation of active minor modes as well.
2953 ;;For this to work correctly for a minor mode, the mode's indicator variable
2954 ;;\(listed in `minor-mode-alist') must also be a function whose documentation
2955 ;;describes the minor mode."
2957 ;; (with-output-to-temp-buffer "*Help*"
2958 ;; (princ mode-name)
2959 ;; (princ " Mode:\n")
2960 ;; (princ (documentation major-mode))
2961 ;; (let ((minor-modes minor-mode-alist)
2962 ;; (locals (buffer-local-variables)))
2963 ;; (while minor-modes
2964 ;; (let* ((minor-mode (car (car minor-modes)))
2965 ;; (indicator (car (cdr (car minor-modes))))
2966 ;; (local-binding (assq minor-mode locals)))
2967 ;; ;; Document a minor mode if it is listed in minor-mode-alist,
2968 ;; ;; bound locally in this buffer, non-nil, and has a function
2970 ;; (if (and local-binding
2971 ;; (cdr local-binding)
2972 ;; (fboundp minor-mode))
2974 ;; (princ (format "\n\n\n%s minor mode (indicator%s):\n"
2975 ;; minor-mode indicator))
2976 ;; (princ (documentation minor-mode)))))
2977 ;; (setq minor-modes (cdr minor-modes))))
2978 ;; (print-help-return-message)))
2980 ;; This goes with the redefinition of describe-mode.
2981 ;;;; Adjust things so that keyboard macro definitions are documented correctly.
2982 ;;(fset 'defining-kbd-macro (symbol-function 'start-kbd-macro))
2984 ;; substitute-key-definition should work now.
2985 ;;;; Function to shadow a definition in a keymap with definitions in another.
2986 ;;(defun emerge-shadow-key-definition (olddef newdef keymap shadowmap)
2987 ;; "Shadow OLDDEF with NEWDEF for any keys in KEYMAP with entries in SHADOWMAP.
2988 ;;In other words, SHADOWMAP will now shadow all definitions of OLDDEF in KEYMAP
2989 ;;with NEWDEF. Does not affect keys that are already defined in SHADOWMAP,
2990 ;;including those whose definition is OLDDEF."
2991 ;; ;; loop through all keymaps accessible from keymap
2992 ;; (let ((maps (accessible-keymaps keymap)))
2994 ;; (let ((prefix (car (car maps)))
2995 ;; (map (cdr (car maps))))
2996 ;; ;; examine a keymap
2999 ;; (let ((len (length map))
3002 ;; (if (eq (aref map i) olddef)
3003 ;; ;; set the shadowing definition
3004 ;; (let ((key (concat prefix (char-to-string i))))
3005 ;; (emerge-define-key-if-possible shadowmap key newdef)))
3006 ;; (setq i (1+ i))))
3009 ;; (if (eq (cdr-safe (car-safe map)) olddef)
3010 ;; ;; set the shadowing definition
3012 ;; (concat prefix (char-to-string (car (car map))))))
3013 ;; (emerge-define-key-if-possible shadowmap key newdef)))
3014 ;; (setq map (cdr map)))))
3015 ;; (setq maps (cdr maps)))))
3017 ;; Define a key if it (or a prefix) is not already defined in the map.
3018 (defun emerge-define-key-if-possible (keymap key definition)
3019 ;; look up the present definition of the key
3020 (let ((present (lookup-key keymap key)))
3021 (if (integerp present)
3022 ;; if it is "too long", look up the valid prefix
3023 (if (not (lookup-key keymap (substring key 0 present)))
3024 ;; if the prefix isn't defined, define it
3025 (define-key keymap key definition))
3026 ;; if there is no present definition, define it
3028 (define-key keymap key definition)))))
3030 ;; Ordinary substitute-key-definition should do this now.
3031 ;;(defun emerge-recursively-substitute-key-definition (olddef newdef keymap)
3032 ;; "Like `substitute-key-definition', but act recursively on subkeymaps.
3033 ;;Make sure that subordinate keymaps aren't shared with other keymaps!
3034 ;;\(`copy-keymap' will suffice.)"
3035 ;; ;; Loop through all keymaps accessible from keymap
3036 ;; (let ((maps (accessible-keymaps keymap)))
3038 ;; ;; Substitute in this keymap
3039 ;; (substitute-key-definition olddef newdef (cdr (car maps)))
3040 ;; (setq maps (cdr maps)))))
3042 ;; Show the name of the file in the buffer.
3043 (defun emerge-show-file-name ()
3044 "Displays the name of the file loaded into the current buffer.
3045 If the name won't fit on one line, the minibuffer is expanded to hold it,
3046 and the command waits for a keystroke from the user. If the keystroke is
3047 SPC, it is ignored; if it is anything else, it is processed as a command."
3049 (let ((name (buffer-file-name)))
3051 (setq name "Buffer has no file name."))
3052 (save-window-excursion
3053 (select-window (minibuffer-window))
3056 (if (not (pos-visible-in-window-p))
3057 (let ((echo-keystrokes 0))
3058 (while (and (not (pos-visible-in-window-p))
3059 (> (1- (screen-height)) (window-height)))
3061 (let ((c (read-event)))
3063 (setq unread-command-events (list c)))))))))
3065 ;; Improved auto-save file names.
3066 ;; This function fixes many problems with the standard auto-save file names:
3067 ;; Auto-save files for non-file buffers get put in the default directory
3068 ;; for the buffer, whether that makes sense or not.
3069 ;; Auto-save files for file buffers get put in the directory of the file,
3070 ;; regardless of whether we can write into it or not.
3071 ;; Auto-save files for non-file buffers don't use the process id, so if a
3072 ;; user runs more than on Emacs, they can make auto-save files that overwrite
3074 ;; To use this function, do:
3075 ;; (fset 'make-auto-save-file-name
3076 ;; (symbol-function 'emerge-make-auto-save-file-name))
3077 (defun emerge-make-auto-save-file-name ()
3078 "Return file name to use for auto-saves of current buffer.
3079 Does not consider `auto-save-visited-file-name';
3080 that is checked before calling this function.
3081 You can redefine this for customization.
3082 See also `auto-save-file-name-p'."
3083 (if buffer-file-name
3084 ;; if buffer has a file, try the format <file directory>/#<file name>#
3085 (let ((f (concat (file-name-directory buffer-file-name)
3087 (file-name-nondirectory buffer-file-name)
3089 (if (file-writable-p f)
3090 ;; the file is writable, so use it
3092 ;; the file isn't writable, so use the format
3093 ;; ~/#&<file name>&<hash of directory>#
3094 (concat (getenv "HOME")
3096 (file-name-nondirectory buffer-file-name)
3098 (emerge-hash-string-into-string
3099 (file-name-directory buffer-file-name))
3101 ;; if buffer has no file, use the format ~/#%<buffer name>%<process id>#
3102 (expand-file-name (concat (getenv "HOME")
3104 ;; quote / into \! and \ into \\
3105 (emerge-unslashify-name (buffer-name))
3110 ;; Hash a string into five characters more-or-less suitable for use in a file
3111 ;; name. (Allowed characters are ! through ~, except /.)
3112 (defun emerge-hash-string-into-string (s)
3113 (let ((bins (vector 0 0 0 0 0))
3115 (while (< i (length s))
3116 (aset bins (% i 5) (% (+ (* (aref bins (% i 5)) 35)
3120 (mapconcat (function (lambda (b)
3121 (setq b (+ (% b 93) ?!))
3124 (char-to-string b)))
3127 ;; Quote any /s in a string by replacing them with \!.
3128 ;; Also, replace any \s by \\, to make it one-to-one.
3129 (defun emerge-unslashify-name (s)
3131 (while (string-match "[/\\]" s limit)
3132 (setq s (concat (substring s 0 (match-beginning 0))
3133 (if (string= (substring s (match-beginning 0)
3138 (substring s (match-end 0))))
3139 (setq limit (1+ (match-end 0)))))
3142 ;; Metacharacters that have to be protected from the shell when executing
3143 ;; a diff/diff3 command.
3144 (defvar emerge-metachars "[ \t\n!\"#$&'()*;<=>?[\\^`{|~]"
3145 "Characters that must be quoted with \\ when used in a shell command line.
3146 More precisely, a [...] regexp to match any one such character.")
3148 ;; Quote metacharacters (using \) when executing a diff/diff3 command.
3149 (defun emerge-protect-metachars (s)
3151 (while (string-match emerge-metachars s limit)
3152 (setq s (concat (substring s 0 (match-beginning 0))
3154 (substring s (match-beginning 0))))
3155 (setq limit (1+ (match-end 0)))))
3160 ;;; emerge.el ends here