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