1 ;;; ediff-util.el --- the core commands and utilities of ediff
3 ;; Copyright (C) 1994, 1995, 1996 Free Software Foundation, Inc.
5 ;; Author: Michael Kifer <kifer@cs.sunysb.edu>
7 ;; This file is part of GNU Emacs.
9 ;; GNU Emacs is free software; you can redistribute it and/or modify
10 ;; it under the terms of the GNU General Public License as published by
11 ;; the Free Software Foundation; either version 2, or (at your option)
14 ;; GNU Emacs is distributed in the hope that it will be useful,
15 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
16 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 ;; GNU General Public License for more details.
19 ;; You should have received a copy of the GNU General Public License
20 ;; along with GNU Emacs; see the file COPYING. If not, write to the
21 ;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
22 ;; Boston, MA 02111-1307, USA.
30 ;; Pacify compiler and avoid the need in checking for boundp
31 (defvar ediff-patch-diagnostics nil)
32 (defvar ediff-patchbufer nil)
35 (let ((load-path (cons (expand-file-name ".") load-path)))
36 (load-file "ediff-init.el")
37 (load-file "ediff-help.el"))))
44 "Ediff mode controls all operations in a single Ediff session.
45 This mode is entered through one of the following commands:
56 `ediff-merge-files-with-ancestor'
58 `ediff-merge-buffers-with-ancestor'
59 `ediff-merge-revisions'
60 `ediff-merge-revisions-with-ancestor'
61 `ediff-windows-wordwise'
62 `ediff-windows-linewise'
63 `ediff-regions-wordwise'
64 `ediff-regions-linewise'
73 (kill-all-local-variables)
74 (setq major-mode 'ediff-mode)
75 (setq mode-name "Ediff")
76 (run-hooks 'ediff-mode-hook))
85 (ediff-defvar-local ediff-mode-map nil
86 "Local keymap used in Ediff mode.
87 This is local to each Ediff Control Panel, so they may vary from invocation
90 ;; Set up the keymap in the control buffer
91 (defun ediff-set-keys ()
92 "Set up Ediff keymap, if necessary."
93 (if (null ediff-mode-map)
95 (use-local-map ediff-mode-map))
97 ;; Reload Ediff keymap. For debugging only.
98 (defun ediff-reload-keymap ()
100 (setq ediff-mode-map nil)
104 (defun ediff-setup-keymap ()
105 "Set up the keymap used in the control buffer of Ediff."
106 (setq ediff-mode-map (make-sparse-keymap))
107 (suppress-keymap ediff-mode-map)
109 (define-key ediff-mode-map
110 (if ediff-emacs-p [mouse-2] [button2]) 'ediff-help-for-quick-help)
111 (define-key ediff-mode-map "\C-m" 'ediff-help-for-quick-help)
113 (define-key ediff-mode-map "p" 'ediff-previous-difference)
114 (define-key ediff-mode-map "\C-?" 'ediff-previous-difference)
115 (define-key ediff-mode-map [backspace] 'ediff-previous-difference)
116 (define-key ediff-mode-map [delete] 'ediff-previous-difference)
117 (define-key ediff-mode-map "\C-h" (if ediff-no-emacs-help-in-control-buffer
118 'ediff-previous-difference nil))
119 (define-key ediff-mode-map "n" 'ediff-next-difference)
120 (define-key ediff-mode-map " " 'ediff-next-difference)
121 (define-key ediff-mode-map "j" 'ediff-jump-to-difference)
122 (define-key ediff-mode-map "g" nil)
123 (define-key ediff-mode-map "ga" 'ediff-jump-to-difference-at-point)
124 (define-key ediff-mode-map "gb" 'ediff-jump-to-difference-at-point)
125 (define-key ediff-mode-map "q" 'ediff-quit)
126 (define-key ediff-mode-map "D" 'ediff-show-diff-output)
127 (define-key ediff-mode-map "z" 'ediff-suspend)
128 (define-key ediff-mode-map "\C-l" 'ediff-recenter)
129 (define-key ediff-mode-map "|" 'ediff-toggle-split)
130 (define-key ediff-mode-map "h" 'ediff-toggle-hilit)
132 (define-key ediff-mode-map "@" 'ediff-toggle-autorefine))
134 (define-key ediff-mode-map "%" 'ediff-toggle-narrow-region))
135 (define-key ediff-mode-map "~" 'ediff-swap-buffers)
136 (define-key ediff-mode-map "v" 'ediff-scroll-vertically)
137 (define-key ediff-mode-map "\C-v" 'ediff-scroll-vertically)
138 (define-key ediff-mode-map "^" 'ediff-scroll-vertically)
139 (define-key ediff-mode-map "\M-v" 'ediff-scroll-vertically)
140 (define-key ediff-mode-map "V" 'ediff-scroll-vertically)
141 (define-key ediff-mode-map "<" 'ediff-scroll-horizontally)
142 (define-key ediff-mode-map ">" 'ediff-scroll-horizontally)
143 (define-key ediff-mode-map "i" 'ediff-status-info)
144 (define-key ediff-mode-map "E" 'ediff-documentation)
145 (define-key ediff-mode-map "?" 'ediff-toggle-help)
146 (define-key ediff-mode-map "!" 'ediff-update-diffs)
147 (define-key ediff-mode-map "M" 'ediff-show-meta-buffer)
148 (define-key ediff-mode-map "R" 'ediff-show-registry)
150 (define-key ediff-mode-map "*" 'ediff-make-or-kill-fine-diffs))
151 (define-key ediff-mode-map "a" nil)
152 (define-key ediff-mode-map "b" nil)
153 (define-key ediff-mode-map "r" nil)
154 (cond (ediff-merge-job
155 ;; Will barf if no ancestor
156 (define-key ediff-mode-map "/" 'ediff-show-ancestor)
157 ;; In merging, we allow only A->C and B->C copying.
158 (define-key ediff-mode-map "a" 'ediff-copy-A-to-C)
159 (define-key ediff-mode-map "b" 'ediff-copy-B-to-C)
160 (define-key ediff-mode-map "r" 'ediff-restore-diff-in-merge-buffer)
161 (define-key ediff-mode-map "s" 'ediff-shrink-window-C)
162 (define-key ediff-mode-map "+" 'ediff-combine-diffs)
163 (define-key ediff-mode-map "$" 'ediff-toggle-show-clashes-only)
164 (define-key ediff-mode-map "&" 'ediff-re-merge))
165 (ediff-3way-comparison-job
166 (define-key ediff-mode-map "ab" 'ediff-copy-A-to-B)
167 (define-key ediff-mode-map "ba" 'ediff-copy-B-to-A)
168 (define-key ediff-mode-map "ac" 'ediff-copy-A-to-C)
169 (define-key ediff-mode-map "bc" 'ediff-copy-B-to-C)
170 (define-key ediff-mode-map "c" nil)
171 (define-key ediff-mode-map "ca" 'ediff-copy-C-to-A)
172 (define-key ediff-mode-map "cb" 'ediff-copy-C-to-B)
173 (define-key ediff-mode-map "ra" 'ediff-restore-diff)
174 (define-key ediff-mode-map "rb" 'ediff-restore-diff)
175 (define-key ediff-mode-map "rc" 'ediff-restore-diff)
176 (define-key ediff-mode-map "C" 'ediff-toggle-read-only))
177 (t ; 2-way comparison
178 (define-key ediff-mode-map "a" 'ediff-copy-A-to-B)
179 (define-key ediff-mode-map "b" 'ediff-copy-B-to-A)
180 (define-key ediff-mode-map "ra" 'ediff-restore-diff)
181 (define-key ediff-mode-map "rb" 'ediff-restore-diff))
183 (define-key ediff-mode-map "G" 'ediff-submit-report)
184 (define-key ediff-mode-map "#" nil)
185 (define-key ediff-mode-map "#h" 'ediff-toggle-regexp-match)
186 (define-key ediff-mode-map "#f" 'ediff-toggle-regexp-match)
188 (define-key ediff-mode-map "##" 'ediff-toggle-skip-similar))
189 (define-key ediff-mode-map "o" nil)
190 (define-key ediff-mode-map "A" 'ediff-toggle-read-only)
191 (define-key ediff-mode-map "B" 'ediff-toggle-read-only)
192 (define-key ediff-mode-map "w" nil)
193 (define-key ediff-mode-map "wa" 'ediff-save-buffer)
194 (define-key ediff-mode-map "wb" 'ediff-save-buffer)
195 (define-key ediff-mode-map "wd" 'ediff-save-buffer)
196 (define-key ediff-mode-map "=" 'ediff-inferior-compare-regions)
197 (if (fboundp 'ediff-show-patch-diagnostics)
198 (define-key ediff-mode-map "P" 'ediff-show-patch-diagnostics))
201 (define-key ediff-mode-map "wc" 'ediff-save-buffer)
202 (define-key ediff-mode-map "gc" 'ediff-jump-to-difference-at-point)
205 (define-key ediff-mode-map "m" 'ediff-toggle-wide-display)
207 ;; Allow ediff-mode-map to be referenced indirectly
208 (fset 'ediff-mode-map ediff-mode-map)
209 (run-hooks 'ediff-keymap-setup-hook))
214 (require 'ediff-wind)
216 ;; No longer needed: XEmacs has surrogate minibuffers now.
217 ;;(or (boundp 'synchronize-minibuffers)
218 ;; (defvar synchronize-minibuffers nil))
220 ;; Common startup entry for all Ediff functions
221 ;; It now returns control buffer so other functions can do post-processing
222 (defun ediff-setup (buffer-A file-A buffer-B file-B buffer-C file-C
223 startup-hooks setup-parameters)
224 ;; ediff-convert-standard-filename puts file names in the form appropriate
225 ;; for the OS at hand.
226 (setq file-A (ediff-convert-standard-filename (expand-file-name file-A)))
227 (setq file-B (ediff-convert-standard-filename (expand-file-name file-B)))
230 (ediff-convert-standard-filename (expand-file-name file-C))))
231 (let* ((control-buffer-name
232 (ediff-unique-buffer-name "*Ediff Control Panel" "*"))
233 (control-buffer (ediff-eval-in-buffer buffer-A
234 (get-buffer-create control-buffer-name))))
235 (ediff-eval-in-buffer control-buffer
238 ;; unwrap set up parameters passed as argument
239 (while setup-parameters
240 (set (car (car setup-parameters)) (cdr (car setup-parameters)))
241 (setq setup-parameters (cdr setup-parameters)))
243 ;; set variables classifying the current ediff job
244 (setq ediff-3way-comparison-job (ediff-3way-comparison-job)
245 ediff-merge-job (ediff-merge-job)
246 ediff-merge-with-ancestor-job (ediff-merge-with-ancestor-job)
247 ediff-3way-job (ediff-3way-job)
248 ediff-diff3-job (ediff-diff3-job)
249 ediff-narrow-job (ediff-narrow-job)
250 ediff-windows-job (ediff-windows-job)
251 ediff-word-mode-job (ediff-word-mode-job))
253 (make-local-variable 'ediff-use-long-help-message)
254 (make-local-variable 'ediff-prefer-iconified-control-frame)
255 (make-local-variable 'ediff-split-window-function)
256 (make-local-variable 'ediff-default-variant)
257 (make-local-variable 'ediff-merge-window-share)
258 (make-local-variable 'ediff-window-setup-function)
259 (make-local-variable 'ediff-keep-variants)
261 ;; Don't delete variants in case of ediff-buffer-* jobs without asking.
262 ;; This is because u may loose work---dangerous.
263 (if (string-match "buffer" (symbol-name ediff-job-name))
264 (setq ediff-keep-variants t))
266 (make-local-hook 'pre-command-hook)
267 (if (ediff-window-display-p)
268 (add-hook 'pre-command-hook 'ediff-spy-after-mouse nil t))
269 (setq ediff-mouse-pixel-position (mouse-pixel-position))
271 ;; adjust for merge jobs
274 ;; If default variant is `combined', the right stuff is
275 ;; inserted by ediff-do-merge
276 ;; Note: at some point, we tried to put ancestor buffer here
277 ;; (which is currently buffer C. This didn't work right
278 ;; because the merge buffer will contain lossage: diff regions
279 ;; in the ancestor, which correspond to revisions that agree
280 ;; in both buf A and B.
281 (cond ((eq ediff-default-variant 'default-B)
285 (setq ediff-split-window-function
286 ediff-merge-split-window-function)
288 ;; remember the ancestor buffer, if any
289 (setq ediff-ancestor-buffer buffer-C)
293 (ediff-unique-buffer-name "*ediff-merge" "*")))
295 (set-buffer buffer-C)
297 (funcall (ediff-eval-in-buffer buf major-mode))
298 ;; after Stig@hackvan.com
299 (add-hook 'local-write-file-hooks 'ediff-set-merge-mode nil t)
301 (setq buffer-read-only nil
302 ediff-buffer-A buffer-A
303 ediff-buffer-B buffer-B
304 ediff-buffer-C buffer-C
305 ediff-control-buffer control-buffer)
307 (setq ediff-control-buffer-suffix
308 (if (string-match "<[0-9]*>" control-buffer-name)
309 (substring control-buffer-name
310 (match-beginning 0) (match-end 0))
312 ediff-control-buffer-number
318 ediff-control-buffer-suffix
320 (string-match "[0-9]+" ediff-control-buffer-suffix)
323 (setq ediff-error-buffer
324 (get-buffer-create (ediff-unique-buffer-name "*ediff-errors" "*")))
326 (ediff-eval-in-buffer buffer-A (ediff-strip-mode-line-format))
327 (ediff-eval-in-buffer buffer-B (ediff-strip-mode-line-format))
329 (ediff-eval-in-buffer buffer-C (ediff-strip-mode-line-format)))
330 (if (ediff-buffer-live-p ediff-ancestor-buffer)
331 (ediff-eval-in-buffer ediff-ancestor-buffer
332 (ediff-strip-mode-line-format)))
334 (ediff-save-protected-variables) ; save variables to be restored on exit
336 ;; ediff-setup-diff-regions-function must be set after setup
337 ;; parameters are processed.
338 (setq ediff-setup-diff-regions-function
340 'ediff-setup-diff-regions3
341 'ediff-setup-diff-regions))
343 (setq ediff-wide-bounds
344 (list (ediff-make-bullet-proof-overlay
345 '(point-min) '(point-max) ediff-buffer-A)
346 (ediff-make-bullet-proof-overlay
347 '(point-min) '(point-max) ediff-buffer-B)
348 (ediff-make-bullet-proof-overlay
349 '(point-min) '(point-max) ediff-buffer-C)))
351 ;; This has effect only on ediff-windows/regions
352 ;; In all other cases, ediff-visible-region sets visibility bounds to
353 ;; ediff-wide-bounds, and ediff-narrow-bounds are ignored.
354 (if ediff-start-narrowed
355 (setq ediff-visible-bounds ediff-narrow-bounds)
356 (setq ediff-visible-bounds ediff-wide-bounds))
358 (ediff-set-keys) ; comes after parameter setup
360 ;; set up ediff-narrow-bounds, if not set
361 (or ediff-narrow-bounds
362 (setq ediff-narrow-bounds ediff-wide-bounds))
364 ;; All these must be inside ediff-eval-in-buffer control-buffer,
365 ;; since these vars are local to control-buffer
366 ;; These won't run if there are errors in diff
367 (ediff-eval-in-buffer ediff-buffer-A
368 (ediff-nuke-selective-display)
369 (run-hooks 'ediff-prepare-buffer-hook)
370 (if (ediff-eval-in-buffer control-buffer ediff-merge-job)
371 (setq buffer-read-only t))
372 ;; add control-buffer to the list of sessions--no longer used, but may
373 ;; be used again in the future
374 (or (memq control-buffer ediff-this-buffer-ediff-sessions)
375 (setq ediff-this-buffer-ediff-sessions
376 (cons control-buffer ediff-this-buffer-ediff-sessions)))
378 (ediff-eval-in-buffer ediff-buffer-B
379 (ediff-nuke-selective-display)
380 (run-hooks 'ediff-prepare-buffer-hook)
381 (if (ediff-eval-in-buffer control-buffer ediff-merge-job)
382 (setq buffer-read-only t))
383 ;; add control-buffer to the list of sessions
384 (or (memq control-buffer ediff-this-buffer-ediff-sessions)
385 (setq ediff-this-buffer-ediff-sessions
386 (cons control-buffer ediff-this-buffer-ediff-sessions)))
389 (ediff-eval-in-buffer ediff-buffer-C
390 (ediff-nuke-selective-display)
391 (run-hooks 'ediff-prepare-buffer-hook)
392 ;; add control-buffer to the list of sessions
393 (or (memq control-buffer ediff-this-buffer-ediff-sessions)
394 (setq ediff-this-buffer-ediff-sessions
396 ediff-this-buffer-ediff-sessions)))
399 (if (ediff-buffer-live-p ediff-ancestor-buffer)
400 (ediff-eval-in-buffer ediff-ancestor-buffer
401 (ediff-nuke-selective-display)
402 (setq buffer-read-only t)
403 (run-hooks 'ediff-prepare-buffer-hook)
404 (or (memq control-buffer ediff-this-buffer-ediff-sessions)
405 (setq ediff-this-buffer-ediff-sessions
407 ediff-this-buffer-ediff-sessions)))
410 ;; must come after setting up ediff-narrow-bounds AND after
411 ;; nuking selective display
412 (funcall ediff-setup-diff-regions-function file-A file-B file-C)
413 (setq ediff-number-of-differences (length ediff-difference-vector-A))
414 (setq ediff-current-difference -1)
416 (ediff-make-current-diff-overlay 'A)
417 (ediff-make-current-diff-overlay 'B)
419 (ediff-make-current-diff-overlay 'C))
420 (if ediff-merge-with-ancestor-job
421 (ediff-make-current-diff-overlay 'Ancestor))
423 (ediff-setup-windows buffer-A buffer-B buffer-C control-buffer)
425 (let ((shift-A (ediff-overlay-start
426 (ediff-get-value-according-to-buffer-type
427 'A ediff-narrow-bounds)))
428 (shift-B (ediff-overlay-start
429 (ediff-get-value-according-to-buffer-type
430 'B ediff-narrow-bounds)))
431 (shift-C (ediff-overlay-start
432 (ediff-get-value-according-to-buffer-type
433 'C ediff-narrow-bounds))))
434 ;; position point in buf A
436 (select-window ediff-window-A)
438 ;; position point in buf B
440 (select-window ediff-window-B)
444 (select-window ediff-window-C)
445 (goto-char shift-C)))
448 (select-window ediff-control-window)
449 (ediff-visible-region)
451 (run-hooks 'startup-hooks)
452 (ediff-refresh-mode-lines)
453 (setq buffer-read-only t)
454 (setq ediff-session-registry
455 (cons control-buffer ediff-session-registry))
456 (ediff-update-registry)
457 (if (ediff-buffer-live-p ediff-meta-buffer)
458 (ediff-update-meta-buffer ediff-meta-buffer))
459 (run-hooks 'ediff-startup-hook)
460 ) ; eval in control-buffer
464 ;; This function assumes that we are in the window where control buffer is
466 (defun ediff-setup-control-buffer (ctl-buf)
467 "Set up window for control buffer."
468 (if (window-dedicated-p (selected-window))
469 (set-buffer ctl-buf) ; we are in control frame but just in case
470 (switch-to-buffer ctl-buf))
471 (let ((window-min-height 2))
473 (ediff-set-help-message)
474 (insert ediff-help-message)
475 (shrink-window-if-larger-than-buffer)
476 (or (ediff-multiframe-setup-p)
477 (ediff-indent-help-message))
478 (ediff-set-help-overlays)
480 (set-buffer-modified-p nil)
481 (ediff-refresh-mode-lines)
482 (setq ediff-control-window (selected-window))
483 (setq ediff-window-config-saved
484 (format "%S%S%S%S%S%S%S"
489 ediff-split-window-function
490 (ediff-multiframe-setup-p)
491 ediff-wide-display-p))
492 (goto-char (point-min))
493 (skip-chars-forward ediff-whitespace)))
498 ;;; Commands for working with Ediff
500 (defun ediff-update-diffs ()
501 "Recompute difference regions in buffers A, B, and C.
502 Buffers are not synchronized with their respective files, so changes done
503 to these buffers are not saved at this point---the user can do this later,
506 (ediff-barf-if-not-control-buffer)
507 (if (and (ediff-buffer-live-p ediff-ancestor-buffer)
508 (not (y-or-n-p "Recompute differences during merge, really? ")))
509 (error "God forbid!"))
511 (let ((point-A (ediff-eval-in-buffer ediff-buffer-A (point)))
512 ;;(point-B (ediff-eval-in-buffer ediff-buffer-B (point)))
513 (tmp-buffer (get-buffer-create ediff-tmp-buffer))
515 (file-name-nondirectory (or (buffer-file-name ediff-buffer-A)
516 (buffer-name ediff-buffer-A)
519 (file-name-nondirectory (or (buffer-file-name ediff-buffer-B)
520 (buffer-name ediff-buffer-B)
523 (file-name-nondirectory (or (buffer-file-name ediff-buffer-C)
524 ;; if (null ediff-buffer-C), there is
525 ;; no danger, since we later check if
526 ;; ediff-buffer-C is alive
527 (buffer-name ediff-buffer-C)
529 (overl-A (ediff-get-value-according-to-buffer-type
530 'A ediff-narrow-bounds))
531 (overl-B (ediff-get-value-according-to-buffer-type
532 'B ediff-narrow-bounds))
533 (overl-C (ediff-get-value-according-to-buffer-type
534 'C ediff-narrow-bounds))
535 beg-A end-A beg-B end-B beg-C end-C
536 file-A file-B file-C)
537 (ediff-unselect-and-select-difference -1)
539 (setq beg-A (ediff-overlay-start overl-A)
540 beg-B (ediff-overlay-start overl-B)
541 beg-C (ediff-overlay-start overl-C)
542 end-A (ediff-overlay-end overl-A)
543 end-B (ediff-overlay-end overl-B)
544 end-C (ediff-overlay-end overl-C))
548 (ediff-wordify beg-A end-A ediff-buffer-A tmp-buffer)
549 (setq file-A (ediff-make-temp-file tmp-buffer "regA"))
550 (ediff-wordify beg-B end-B ediff-buffer-B tmp-buffer)
551 (setq file-B (ediff-make-temp-file tmp-buffer "regB"))
554 (ediff-wordify beg-C end-C ediff-buffer-C tmp-buffer)
555 (setq file-C (ediff-make-temp-file tmp-buffer "regC"))))
558 (setq file-A (ediff-make-temp-file ediff-buffer-A buf-A-file-name))
559 (setq file-B (ediff-make-temp-file ediff-buffer-B buf-B-file-name))
561 (setq file-C (ediff-make-temp-file ediff-buffer-C buf-C-file-name)))
564 (ediff-clear-diff-vector 'ediff-difference-vector-A 'fine-diffs-also)
565 (ediff-clear-diff-vector 'ediff-difference-vector-B 'fine-diffs-also)
566 (ediff-clear-diff-vector 'ediff-difference-vector-C 'fine-diffs-also)
567 (ediff-clear-diff-vector
568 'ediff-difference-vector-Ancestor 'fine-diffs-also)
569 ;; let them garbage collect. we can't use the ancestor after recomputing
571 (setq ediff-difference-vector-Ancestor nil
572 ediff-ancestor-buffer nil
573 ediff-state-of-merge nil)
575 (setq ediff-killed-diffs-alist nil) ; invalidate saved killed diff regions
577 ;; In case of merge job, fool it into thinking that it is just doing
579 (let ((ediff-setup-diff-regions-function ediff-setup-diff-regions-function)
580 (ediff-3way-comparison-job ediff-3way-comparison-job)
581 (ediff-merge-job ediff-merge-job)
582 (ediff-merge-with-ancestor-job ediff-merge-with-ancestor-job)
583 (ediff-job-name ediff-job-name))
585 (setq ediff-setup-diff-regions-function 'ediff-setup-diff-regions3
586 ediff-3way-comparison-job t
588 ediff-merge-with-ancestor-job nil
589 ediff-job-name 'ediff-files3))
590 (funcall ediff-setup-diff-regions-function file-A file-B file-C))
592 (setq ediff-number-of-differences (length ediff-difference-vector-A))
596 (delete-file file-C))
599 (ediff-set-state-of-all-diffs-in-all-buffers ediff-control-buffer))
601 (ediff-jump-to-difference (ediff-diff-at-point 'A point-A))
605 ;; Not bound to any key---to dangerous. A user can do it if necessary.
606 (defun ediff-revert-buffers-then-recompute-diffs (noconfirm)
607 "Revert buffers A, B and C. Then rerun Ediff on file A and file B."
609 (ediff-barf-if-not-control-buffer)
610 (let ((bufA ediff-buffer-A)
611 (bufB ediff-buffer-B)
612 (bufC ediff-buffer-C)
613 (ctl-buf ediff-control-buffer)
614 (keep-variants ediff-keep-variants)
615 (ancestor-buf ediff-ancestor-buffer)
616 (ancestor-job ediff-merge-with-ancestor-job)
617 (merge ediff-merge-job)
618 (comparison ediff-3way-comparison-job))
619 (ediff-eval-in-buffer bufA
620 (revert-buffer t noconfirm))
621 (ediff-eval-in-buffer bufB
622 (revert-buffer t noconfirm))
623 ;; this should only be executed in a 3way comparison, not in merge
625 (ediff-eval-in-buffer bufC
626 (revert-buffer t noconfirm)))
630 ;; the argument says whether to reverse the meaning of
631 ;; ediff-keep-variants, i.e., ediff-really-quit runs here with
633 (ediff-really-quit (not keep-variants))
636 (ediff-merge-buffers-with-ancestor bufA bufB ancestor-buf)
637 (ediff-merge-buffers bufA bufB)))
638 (ediff-update-diffs))))
641 ;; optional NO-REHIGHLIGHT says to not rehighlight buffers
642 (defun ediff-recenter (&optional no-rehighlight)
643 "Bring the highlighted region of all buffers being compared into view.
644 Reestablish the default three-window display."
646 (ediff-barf-if-not-control-buffer)
648 ;; ;; No longer needed: XEmacs has surrogate minibuffers now.
649 ;; (if ediff-xemacs-p (setq synchronize-minibuffers t))
651 (let (buffer-read-only)
652 (if (and (ediff-buffer-live-p ediff-buffer-A)
653 (ediff-buffer-live-p ediff-buffer-B)
654 (or (not ediff-3way-job)
655 (ediff-buffer-live-p ediff-buffer-C)))
657 ediff-buffer-A ediff-buffer-B ediff-buffer-C ediff-control-buffer)
658 (or (eq this-command 'ediff-quit)
659 (message ediff-KILLED-VITAL-BUFFER
663 ;; set visibility range appropriate to this invocation of Ediff.
664 (ediff-visible-region)
666 (if (and (ediff-window-display-p)
667 (symbolp this-command)
668 (symbolp last-command)
669 ;; Either one of the display-changing commands
670 (or (memq this-command
672 ediff-dir-action ediff-registry-action
674 ediff-toggle-wide-display ediff-toggle-multiframe))
675 ;; Or one of the movement cmds and prev cmd was an Ediff cmd
676 ;; This avoids raising frames unnecessarily.
677 (and (memq this-command
678 '(ediff-next-difference
679 ediff-previous-difference
680 ediff-jump-to-difference
681 ediff-jump-to-difference-at-point))
682 (not (string-match "^ediff-" (symbol-name last-command)))
685 (if (window-live-p ediff-window-A)
686 (raise-frame (window-frame ediff-window-A)))
687 (if (window-live-p ediff-window-B)
688 (raise-frame (window-frame ediff-window-B)))
689 (if (window-live-p ediff-window-C)
690 (raise-frame (window-frame ediff-window-C)))))
691 (if (and (ediff-window-display-p)
692 (frame-live-p ediff-control-frame)
693 (not ediff-use-long-help-message)
694 (not (ediff-frame-iconified-p ediff-control-frame)))
695 (raise-frame ediff-control-frame))
697 ;; Redisplay whatever buffers are showing, if there is a selected difference
698 (let ((control-frame ediff-control-frame)
699 (control-buf ediff-control-buffer))
700 (if (and (ediff-buffer-live-p ediff-buffer-A)
701 (ediff-buffer-live-p ediff-buffer-B)
702 (or (not ediff-3way-job)
703 (ediff-buffer-live-p ediff-buffer-C)))
706 (ediff-select-difference ediff-current-difference))
708 (ediff-recenter-one-window 'A)
709 (ediff-recenter-one-window 'B)
711 (ediff-recenter-one-window 'C))
713 (ediff-eval-in-buffer control-buf
714 (ediff-recenter-ancestor) ; check if ancestor is alive
716 (if (and (ediff-multiframe-setup-p)
717 (not ediff-use-long-help-message)
718 (not (ediff-frame-iconified-p ediff-control-frame)))
719 ;; never grab mouse on quit in this place
722 (eq this-command 'ediff-quit))))
725 (ediff-restore-highlighting)
726 (ediff-eval-in-buffer control-buf (ediff-refresh-mode-lines))
729 ;; this function returns to the window it was called from
730 ;; (which was the control window)
731 (defun ediff-recenter-one-window (buf-type)
732 (if (ediff-valid-difference-p)
733 ;; context must be saved before switching to windows A/B/C
734 (let* ((ctl-wind (selected-window))
735 (shift (ediff-overlay-start
736 (ediff-get-value-according-to-buffer-type
737 buf-type ediff-narrow-bounds)))
738 (job-name ediff-job-name)
739 (control-buf ediff-control-buffer)
740 (window-name (intern (format "ediff-window-%S" buf-type)))
741 (window (if (window-live-p (symbol-value window-name))
742 (symbol-value window-name))))
744 (if (and window ediff-windows-job)
745 (set-window-start window shift))
748 (select-window window)
749 (ediff-deactivate-mark)
750 (ediff-position-region
751 (ediff-get-diff-posn buf-type 'beg nil control-buf)
752 (ediff-get-diff-posn buf-type 'end nil control-buf)
753 (ediff-get-diff-posn buf-type 'beg nil control-buf)
756 (select-window ctl-wind)
759 (defun ediff-recenter-ancestor ()
760 ;; do half-hearted job by recentering the ancestor buffer, if it is alive and
762 (if (and (ediff-buffer-live-p ediff-ancestor-buffer)
763 (ediff-valid-difference-p))
764 (let ((window (ediff-get-visible-buffer-window ediff-ancestor-buffer))
765 (ctl-wind (selected-window))
766 (job-name ediff-job-name)
767 (ctl-buf ediff-control-buffer))
768 (ediff-eval-in-buffer ediff-ancestor-buffer
769 (goto-char (ediff-get-diff-posn 'Ancestor 'beg nil ctl-buf))
772 (select-window window)
773 (ediff-position-region
774 (ediff-get-diff-posn 'Ancestor 'beg nil ctl-buf)
775 (ediff-get-diff-posn 'Ancestor 'end nil ctl-buf)
776 (ediff-get-diff-posn 'Ancestor 'beg nil ctl-buf)
778 (select-window ctl-wind)
782 ;; This will have to be refined for 3way jobs
783 (defun ediff-toggle-split ()
784 "Toggle vertical/horizontal window split.
785 Does nothing if file-A and file-B are in different frames."
787 (ediff-barf-if-not-control-buffer)
788 (let* ((wind-A (if (window-live-p ediff-window-A) ediff-window-A))
789 (wind-B (if (window-live-p ediff-window-B) ediff-window-B))
790 (wind-C (if (window-live-p ediff-window-C) ediff-window-C))
791 (frame-A (if wind-A (window-frame wind-A)))
792 (frame-B (if wind-B (window-frame wind-B)))
793 (frame-C (if wind-C (window-frame wind-C))))
794 (if (or (eq frame-A frame-B)
795 (not (frame-live-p frame-A))
796 (not (frame-live-p frame-B))
797 (if ediff-3way-comparison-job
798 (or (not (frame-live-p frame-C))
799 (eq frame-A frame-C) (eq frame-B frame-C))))
800 (setq ediff-split-window-function
801 (if (eq ediff-split-window-function 'split-window-vertically)
802 'split-window-horizontally
803 'split-window-vertically))
804 (message "Buffers being compared are in different frames"))
805 (ediff-recenter 'no-rehighlight)))
807 (defun ediff-toggle-hilit ()
808 "Switch between highlighting using ASCII flags and highlighting using faces.
809 On a dumb terminal, switches between ASCII highlighting and no highlighting."
811 (ediff-barf-if-not-control-buffer)
812 (if (not (ediff-has-face-support-p))
813 (if (eq ediff-highlighting-style 'ascii)
815 (message "ASCII highlighting flags removed")
816 (ediff-unselect-and-select-difference ediff-current-difference
818 (setq ediff-highlighting-style 'off))
819 (ediff-unselect-and-select-difference ediff-current-difference
821 (ediff-unselect-and-select-difference ediff-current-difference
823 ;; cycle through highlighting
824 (cond ((and ediff-use-faces ediff-highlight-all-diffs)
825 (message "Unhighlighting unselected difference regions")
826 (setq ediff-highlight-all-diffs nil))
828 (message "Highlighting with ASCII flags")
829 (setq ediff-use-faces nil))
831 (message "Re-highlighting all difference regions")
832 (setq ediff-use-faces t
833 ediff-highlight-all-diffs t)))
835 (if (and ediff-use-faces ediff-highlight-all-diffs)
836 (ediff-paint-background-regions)
837 (ediff-paint-background-regions 'unhighlight))
839 (ediff-unselect-and-select-difference
840 ediff-current-difference 'select-only))
844 (defun ediff-toggle-autorefine ()
845 "Toggle auto-refine mode."
847 (ediff-barf-if-not-control-buffer)
849 (error "No fine differences in this mode"))
850 (cond ((eq ediff-auto-refine 'nix)
851 (setq ediff-auto-refine 'on)
852 (ediff-make-fine-diffs ediff-current-difference 'noforce)
853 (message "Auto-refining is ON"))
854 ((eq ediff-auto-refine 'on)
855 (message "Auto-refining is OFF")
856 (setq ediff-auto-refine 'off))
858 (ediff-set-fine-diff-properties ediff-current-difference 'default)
859 (message "Refinements are HIDDEN")
860 (setq ediff-auto-refine 'nix))
863 (defun ediff-show-ancestor ()
864 "Show the ancestor buffer in a suitable window."
867 (or (ediff-buffer-live-p ediff-ancestor-buffer)
868 (if ediff-merge-with-ancestor-job
869 (error "Lost connection to ancestor buffer...sorry")
870 (error "Not merging with ancestor")))
872 (cond ((setq wind (ediff-get-visible-buffer-window ediff-ancestor-buffer))
873 (raise-frame (window-frame wind)))
874 (t (set-window-buffer ediff-window-C ediff-ancestor-buffer)))))
876 (defun ediff-make-or-kill-fine-diffs (arg)
877 "Compute fine diffs. With negative prefix arg, kill fine diffs.
878 In both cases, operates on the currrent difference region."
880 (ediff-barf-if-not-control-buffer)
882 (ediff-clear-fine-differences ediff-current-difference))
883 ((and (numberp arg) (< arg 0))
884 (ediff-clear-fine-differences ediff-current-difference))
885 (t (ediff-make-fine-diffs))))
888 (defun ediff-toggle-help ()
889 "Toggle short/long help message."
891 (ediff-barf-if-not-control-buffer)
892 (let (buffer-read-only)
894 (setq ediff-use-long-help-message (not ediff-use-long-help-message))
895 (ediff-set-help-message))
896 ;; remember the icon status of the control frame when the user requested
897 ;; full control message
898 (if (and ediff-use-long-help-message (ediff-multiframe-setup-p))
899 (setq ediff-prefer-iconified-control-frame
900 (ediff-frame-iconified-p ediff-control-frame)))
902 (setq ediff-window-config-saved "") ; force redisplay
903 (ediff-recenter 'no-rehighlight))
906 ;; If BUF, this is the buffer to toggle, not current buffer.
907 (defun ediff-toggle-read-only (&optional buf)
908 "Toggle read-only in current buffer.
909 If buffer is under version control and locked, check it out first.
910 If optional argument BUF is specified, toggle read-only in that buffer instead
911 of the current buffer."
913 (ediff-barf-if-not-control-buffer)
914 (let ((ctl-buf (if (null buf) (current-buffer)))
915 (buf-type (ediff-char-to-buftype last-command-char)))
916 (or buf (ediff-recenter))
918 (setq buf (ediff-get-buffer buf-type)))
920 (ediff-eval-in-buffer buf ; eval in buf A/B/C
921 (let* ((file (buffer-file-name buf))
922 (file-writable (and file
924 (file-writable-p file)))
925 (toggle-ro-cmd (cond (ediff-toggle-read-only-function)
926 ((ediff-file-checked-out-p file)
928 (file-writable 'toggle-read-only)
929 (t (key-binding "\C-x\C-q")))))
930 ;; If the file is checked in, make sure we don't make buffer modifiable
931 ;; without warning the user. The user can fool our checks by making the
932 ;; buffer non-RO without checking the file out. We regard this as a
934 (if (and (ediff-file-checked-in-p file)
935 ;; If ctl-buf is null, this means we called this
936 ;; non-interactively, in which case don't ask questions
938 (cond ((not buffer-read-only)
939 (setq toggle-ro-cmd 'toggle-read-only))
940 ((and (or (beep 1) t) ; always beep
943 "File %s is under version control. Check it out? "
944 (ediff-abbreviate-file-name file))))
945 ;; if we checked the file out, we should also change the
946 ;; original state of buffer-read-only to nil. If we don't
947 ;; do this, the mode line will show %%, since the file was
948 ;; RO before ediff started, so the user will think the file
950 (ediff-eval-in-buffer ctl-buf
951 (ediff-change-saved-variable
952 'buffer-read-only nil buf-type)))
954 (setq toggle-ro-cmd 'toggle-read-only)
957 "Boy, this is risky! Better don't change this file...")
958 (sit-for 3)))) ; let the user see the warning
959 (if (and toggle-ro-cmd
960 (string-match "toggle-read-only" (symbol-name toggle-ro-cmd)))
962 (save-window-excursion
963 (command-execute toggle-ro-cmd)))
964 (error "Don't know how to toggle read-only in buffer %S" buf))
966 ;; Check if we made the current buffer updatable, but its file is RO.
967 ;; Signal a warning in this case.
968 (if (and file (not buffer-read-only)
969 (eq this-command 'ediff-toggle-read-only)
971 (not (file-writable-p file)))
972 (message "Warning: file %s is read-only"
973 (ediff-abbreviate-file-name file) (beep 1)))
977 ;; This is a simple-minded check for whether a file is under version control
978 ;; and is checked out.
979 ;; If file,v exists but file doesn't, this file is considered to be not checked
980 ;; in and not checked out for the purpose of patching (since patch won't be
981 ;; able to read such a file anyway).
982 ;; FILE is a string representing file name
983 (defun ediff-file-checked-out-p (file)
986 (file-writable-p file)
988 (file-exists-p (concat file ",v"))
989 (file-exists-p (concat (file-name-directory file)
991 (file-name-nondirectory file)
994 (defun ediff-file-checked-in-p (file)
997 (not (file-writable-p file))
999 (file-exists-p (concat file ",v"))
1000 (file-exists-p (concat "RCS/" file ",v")))
1003 (defun ediff-swap-buffers ()
1004 "Rotate the display of buffers A, B, and C."
1006 (ediff-barf-if-not-control-buffer)
1007 (if (and (window-live-p ediff-window-A) (window-live-p ediff-window-B))
1008 (let ((buf ediff-buffer-A)
1009 (values ediff-buffer-values-orig-A)
1010 (diff-vec ediff-difference-vector-A)
1011 (hide-regexp ediff-regexp-hide-A)
1012 (focus-regexp ediff-regexp-focus-A)
1013 (wide-visibility-p (eq ediff-visible-bounds ediff-wide-bounds))
1014 (overlay (if (ediff-has-face-support-p)
1015 ediff-current-diff-overlay-A)))
1016 (if ediff-3way-comparison-job
1018 (set-window-buffer ediff-window-A ediff-buffer-C)
1019 (set-window-buffer ediff-window-B ediff-buffer-A)
1020 (set-window-buffer ediff-window-C ediff-buffer-B)
1022 (set-window-buffer ediff-window-A ediff-buffer-B)
1023 (set-window-buffer ediff-window-B ediff-buffer-A))
1024 ;; swap diff buffers
1025 (if ediff-3way-comparison-job
1026 (setq ediff-buffer-A ediff-buffer-C
1027 ediff-buffer-C ediff-buffer-B
1029 (setq ediff-buffer-A ediff-buffer-B
1030 ediff-buffer-B buf))
1032 ;; swap saved buffer characteristics
1033 (if ediff-3way-comparison-job
1034 (setq ediff-buffer-values-orig-A ediff-buffer-values-orig-C
1035 ediff-buffer-values-orig-C ediff-buffer-values-orig-B
1036 ediff-buffer-values-orig-B values)
1037 (setq ediff-buffer-values-orig-A ediff-buffer-values-orig-B
1038 ediff-buffer-values-orig-B values))
1040 ;; swap diff vectors
1041 (if ediff-3way-comparison-job
1042 (setq ediff-difference-vector-A ediff-difference-vector-C
1043 ediff-difference-vector-C ediff-difference-vector-B
1044 ediff-difference-vector-B diff-vec)
1045 (setq ediff-difference-vector-A ediff-difference-vector-B
1046 ediff-difference-vector-B diff-vec))
1048 ;; swap hide/focus regexp
1049 (if ediff-3way-comparison-job
1050 (setq ediff-regexp-hide-A ediff-regexp-hide-C
1051 ediff-regexp-hide-C ediff-regexp-hide-B
1052 ediff-regexp-hide-B hide-regexp
1053 ediff-regexp-focus-A ediff-regexp-focus-C
1054 ediff-regexp-focus-C ediff-regexp-focus-B
1055 ediff-regexp-focus-B focus-regexp)
1056 (setq ediff-regexp-hide-A ediff-regexp-hide-B
1057 ediff-regexp-hide-B hide-regexp
1058 ediff-regexp-focus-A ediff-regexp-focus-B
1059 ediff-regexp-focus-B focus-regexp))
1061 ;; The following is needed for XEmacs, since there one can't move
1062 ;; overlay to another buffer. In Emacs, this swap is redundant.
1063 (if (ediff-has-face-support-p)
1064 (if ediff-3way-comparison-job
1065 (setq ediff-current-diff-overlay-A ediff-current-diff-overlay-C
1066 ediff-current-diff-overlay-C ediff-current-diff-overlay-B
1067 ediff-current-diff-overlay-B overlay)
1068 (setq ediff-current-diff-overlay-A ediff-current-diff-overlay-B
1069 ediff-current-diff-overlay-B overlay)))
1072 (setq ediff-wide-bounds
1073 (cond (ediff-3way-comparison-job
1074 (list (nth 2 ediff-wide-bounds)
1075 (nth 0 ediff-wide-bounds)
1076 (nth 1 ediff-wide-bounds)))
1078 (list (nth 1 ediff-wide-bounds)
1079 (nth 0 ediff-wide-bounds)
1080 (nth 2 ediff-wide-bounds)))
1082 (list (nth 1 ediff-wide-bounds)
1083 (nth 0 ediff-wide-bounds)))))
1084 ;; swap narrow bounds
1085 (setq ediff-narrow-bounds
1086 (cond (ediff-3way-comparison-job
1087 (list (nth 2 ediff-narrow-bounds)
1088 (nth 0 ediff-narrow-bounds)
1089 (nth 1 ediff-narrow-bounds)))
1091 (list (nth 1 ediff-narrow-bounds)
1092 (nth 0 ediff-narrow-bounds)
1093 (nth 2 ediff-narrow-bounds)))
1095 (list (nth 1 ediff-narrow-bounds)
1096 (nth 0 ediff-narrow-bounds)))))
1097 (if wide-visibility-p
1098 (setq ediff-visible-bounds ediff-wide-bounds)
1099 (setq ediff-visible-bounds ediff-narrow-bounds))
1102 (ediff-set-state-of-all-diffs-in-all-buffers ediff-control-buffer))
1103 (ediff-recenter 'no-rehighlight)
1107 (defun ediff-toggle-wide-display ()
1108 "Toggle wide/regular display.
1109 This is especially useful when comparing buffers side-by-side."
1111 (ediff-barf-if-not-control-buffer)
1112 (or (ediff-window-display-p)
1113 (error "%sEmacs is not running as a window application"
1114 (if ediff-emacs-p "" "X")))
1115 (ediff-recenter 'no-rehighlight) ; make sure buffs are displayed in windows
1116 (let ((ctl-buf ediff-control-buffer))
1117 (setq ediff-wide-display-p (not ediff-wide-display-p))
1118 (if (not ediff-wide-display-p)
1119 (ediff-eval-in-buffer ctl-buf
1120 (modify-frame-parameters
1121 ediff-wide-display-frame ediff-wide-display-orig-parameters)
1122 ;;(sit-for (if ediff-xemacs-p 0.4 0))
1123 ;; restore control buf, since ctl window may have been deleted
1125 (set-buffer ctl-buf)
1126 (setq ediff-wide-display-orig-parameters nil
1127 ediff-window-B nil) ; force update of window config
1128 (ediff-recenter 'no-rehighlight))
1129 (funcall ediff-make-wide-display-function)
1130 ;;(sit-for (if ediff-xemacs-p 0.4 0))
1131 (ediff-eval-in-buffer ctl-buf
1132 (setq ediff-window-B nil) ; force update of window config
1133 (ediff-recenter 'no-rehighlight)))))
1135 (defun ediff-toggle-multiframe ()
1136 "Switch from the multiframe display to single-frame display and back.
1137 For a permanent change, set the variable `ediff-window-setup-function',
1140 (ediff-barf-if-not-control-buffer)
1141 (or (ediff-window-display-p)
1142 (error "%sEmacs is not running as a window application"
1143 (if ediff-emacs-p "" "X")))
1144 (cond ((eq ediff-window-setup-function 'ediff-setup-windows-multiframe)
1145 (setq ediff-window-setup-function 'ediff-setup-windows-plain))
1146 ((eq ediff-window-setup-function 'ediff-setup-windows-plain)
1147 (setq ediff-window-setup-function 'ediff-setup-windows-multiframe)))
1148 (setq ediff-window-B nil)
1149 (ediff-recenter 'no-rehighlight))
1153 (defun ediff-toggle-show-clashes-only ()
1154 "Toggle the mode where only the regions where both buffers differ with the ancestor are shown."
1156 (ediff-barf-if-not-control-buffer)
1157 (if (not ediff-merge-with-ancestor-job)
1158 (error "This command makes sense only when merging with an ancestor"))
1159 (setq ediff-show-clashes-only (not ediff-show-clashes-only))
1160 (if ediff-show-clashes-only
1161 (message "Focus on regions where both buffers differ from the ancestor")
1162 (message "Canceling focus on regions where changes clash")))
1164 ;; Widening/narrowing
1166 (defun ediff-toggle-narrow-region ()
1167 "Toggle narrowing in buffers A, B, and C.
1168 Used in ediff-windows/regions only."
1170 (if (eq ediff-buffer-A ediff-buffer-B)
1171 (error ediff-NO-DIFFERENCES))
1172 (if (eq ediff-visible-bounds ediff-wide-bounds)
1173 (setq ediff-visible-bounds ediff-narrow-bounds)
1174 (setq ediff-visible-bounds ediff-wide-bounds))
1175 (ediff-recenter 'no-rehighlight))
1177 ;; Narrow bufs A/B/C to ediff-visible-bounds. If this is currently set to
1178 ;; ediff-wide-bounds, then this actually widens.
1179 ;; This function does nothing if job-name is not
1180 ;; ediff-regions-wordwise/linewise or ediff-windows-wordwise/linewise.
1181 ;; Does nothing if buffer-A = buffer-B since we can't narrow
1182 ;; to two different regions in one buffer.
1183 (defun ediff-visible-region ()
1184 (if (or (eq ediff-buffer-A ediff-buffer-B)
1185 (eq ediff-buffer-A ediff-buffer-C)
1186 (eq ediff-buffer-C ediff-buffer-B))
1188 ;; If ediff-*-regions/windows, ediff-visible-bounds is already set
1189 ;; Otherwise, always use full range.
1190 (if (not ediff-narrow-job)
1191 (setq ediff-visible-bounds ediff-wide-bounds))
1192 (let ((overl-A (ediff-get-value-according-to-buffer-type
1193 'A ediff-visible-bounds))
1194 (overl-B (ediff-get-value-according-to-buffer-type
1195 'B ediff-visible-bounds))
1196 (overl-C (ediff-get-value-according-to-buffer-type
1197 'C ediff-visible-bounds))
1199 (ediff-eval-in-buffer ediff-buffer-A
1201 (ediff-overlay-start overl-A) (ediff-overlay-end overl-A)))
1202 (ediff-eval-in-buffer ediff-buffer-B
1204 (ediff-overlay-start overl-B) (ediff-overlay-end overl-B)))
1206 (if ediff-3way-comparison-job
1207 (ediff-eval-in-buffer ediff-buffer-C
1209 (ediff-overlay-start overl-C) (ediff-overlay-end overl-C))))
1213 ;; Window scrolling operations
1215 ;; Performs some operation on the two file windows (if they are showing).
1216 ;; Traps all errors on the operation in windows A/B/C.
1217 ;; Usually, errors come from scrolling off the
1218 ;; beginning or end of the buffer, and this gives error messages.
1219 (defun ediff-operate-on-windows (operation arg)
1221 ;; make sure windows aren't dead
1222 (if (not (and (window-live-p ediff-window-A) (window-live-p ediff-window-B)))
1223 (ediff-recenter 'no-rehighlight))
1224 (if (not (and (ediff-buffer-live-p ediff-buffer-A)
1225 (ediff-buffer-live-p ediff-buffer-B)
1226 (or (not ediff-3way-job) ediff-buffer-C)
1228 (error ediff-KILLED-VITAL-BUFFER))
1230 (let* ((wind (selected-window))
1231 (wind-A ediff-window-A)
1232 (wind-B ediff-window-B)
1233 (wind-C ediff-window-C)
1234 (coefA (ediff-get-region-size-coefficient 'A operation))
1235 (coefB (ediff-get-region-size-coefficient 'B operation))
1236 (three-way ediff-3way-job)
1237 (coefC (if three-way
1238 (ediff-get-region-size-coefficient 'C operation))))
1240 (select-window wind-A)
1242 (funcall operation (round (* coefA arg)))
1244 (select-window wind-B)
1246 (funcall operation (round (* coefB arg)))
1250 (select-window wind-C)
1252 (funcall operation (round (* coefC arg)))
1254 (select-window wind)))
1256 (defun ediff-scroll-vertically (&optional arg)
1257 "Vertically scroll buffers A, B \(and C if appropriate\).
1258 With optional argument ARG, scroll ARG lines; otherwise scroll by nearly
1259 the one half of the height of window-A."
1261 (ediff-barf-if-not-control-buffer)
1263 ;; make sure windows aren't dead
1264 (if (not (and (window-live-p ediff-window-A) (window-live-p ediff-window-B)))
1265 (ediff-recenter 'no-rehighlight))
1266 (if (not (and (ediff-buffer-live-p ediff-buffer-A)
1267 (ediff-buffer-live-p ediff-buffer-B)
1268 (or (not ediff-3way-job)
1269 (ediff-buffer-live-p ediff-buffer-C))
1271 (error ediff-KILLED-VITAL-BUFFER))
1273 (ediff-operate-on-windows
1274 (if (memq last-command-char '(?v ?\C-v))
1277 ;; calculate argument to scroll-up/down
1278 ;; if there is an explicit argument
1279 (if (and arg (not (equal arg '-)))
1281 (prefix-numeric-value arg)
1282 ;; if not, see if we can determine a default amount (the window height)
1283 (let (default-amount)
1284 (setq default-amount
1285 (- (/ (min (window-height ediff-window-A)
1286 (window-height ediff-window-B)
1288 (window-height ediff-window-C)
1289 500)) ; some large number
1291 1 next-screen-context-lines))
1294 ;; C-u as argument means half of default amount
1295 (/ default-amount 2)
1296 ;; no argument means default amount
1300 (defun ediff-scroll-horizontally (&optional arg)
1301 "Horizontally scroll buffers A, B \(and C if appropriate\).
1302 If an argument is given, that is how many columns are scrolled, else nearly
1303 the width of the A/B/C windows."
1305 (ediff-barf-if-not-control-buffer)
1307 ;; make sure windows aren't dead
1308 (if (not (and (window-live-p ediff-window-A) (window-live-p ediff-window-B)))
1309 (ediff-recenter 'no-rehighlight))
1310 (if (not (and (ediff-buffer-live-p ediff-buffer-A)
1311 (ediff-buffer-live-p ediff-buffer-B)
1312 (or (not ediff-3way-job)
1313 (ediff-buffer-live-p ediff-buffer-C))
1315 (error ediff-KILLED-VITAL-BUFFER))
1317 (ediff-operate-on-windows
1318 (if (= last-command-char ?<)
1321 ;; calculate argument to scroll-left/right
1322 ;; if there is an explicit argument
1323 (if (and arg (not (equal arg '-)))
1325 (prefix-numeric-value arg)
1326 ;; if not, see if we can determine a default amount
1327 ;; (half the window width)
1328 (if (null ediff-control-window)
1329 ;; no control window, use nil
1331 (let ((default-amount
1332 (- (/ (min (window-width ediff-window-A)
1333 (window-width ediff-window-B)
1334 (if ediff-3way-comparison-job
1335 (window-width ediff-window-C)
1336 500) ; some large number
1342 ;; C-u as argument means half of default amount
1343 (/ default-amount 2)
1344 ;; no argument means default amount
1345 default-amount))))))
1348 ;;BEG, END show the region to be positioned.
1349 ;;JOB-NAME holds ediff-job-name. The ediff-windows job positions regions
1351 (defun ediff-position-region (beg end pos job-name)
1352 (if (> end (point-max))
1353 (setq end (point-max)))
1354 (if ediff-windows-job
1355 (if (pos-visible-in-window-p end)
1356 () ; do nothing, wind is already positioned
1357 ;; at this point, windows are positioned at the beginning of the
1358 ;; file regions (not diff-regions) being compared.
1360 (move-to-window-line (- (window-height) 2))
1361 (let ((amount (+ 2 (count-lines (point) end))))
1362 (scroll-up amount))))
1363 (set-window-start (selected-window) beg)
1364 (if (pos-visible-in-window-p end)
1365 ;; Determine the number of lines that the region occupies
1368 (while ( and (> end (progn
1369 (move-to-window-line lines)
1371 ;; `end' may be beyond the window bottom, so check
1372 ;; that we are making progress
1373 (< prev-point (point)))
1374 (setq prev-point (point))
1375 (setq lines (1+ lines)))
1376 ;; And position the beginning on the right line
1378 (recenter (/ (1+ (max (- (1- (window-height (selected-window)))
1386 ;; get number of lines from window start to region end
1387 (defun ediff-get-lines-to-region-end (buf-type &optional n ctl-buf)
1388 (or n (setq n ediff-current-difference))
1389 (or ctl-buf (setq ctl-buf ediff-control-buffer))
1390 (ediff-eval-in-buffer ctl-buf
1391 (let* ((buf (ediff-get-buffer buf-type))
1392 (wind (eval (intern (format "ediff-window-%S" buf-type))))
1393 (beg (window-start wind))
1394 (end (ediff-get-diff-posn buf-type 'end))
1396 (ediff-eval-in-buffer buf
1398 (setq lines (count-lines beg end))
1403 ;; get number of lines from window end to region start
1404 (defun ediff-get-lines-to-region-start (buf-type &optional n ctl-buf)
1405 (or n (setq n ediff-current-difference))
1406 (or ctl-buf (setq ctl-buf ediff-control-buffer))
1407 (ediff-eval-in-buffer ctl-buf
1408 (let* ((buf (ediff-get-buffer buf-type))
1409 (wind (eval (intern (format "ediff-window-%S" buf-type))))
1410 (end (window-end wind))
1411 (beg (ediff-get-diff-posn buf-type 'beg)))
1412 (ediff-eval-in-buffer buf
1413 (if (< beg end) (count-lines beg end) 0))
1417 ;; region size coefficient is a coefficient by which to adjust scrolling
1418 ;; up/down of the window displaying buffer of type BUFTYPE.
1419 ;; The purpose of this coefficient is to make the windows scroll in sync, so
1420 ;; that it won't happen that one diff region is scrolled off while the other is
1423 ;; If the difference region is invalid, the coefficient is 1
1424 (defun ediff-get-region-size-coefficient (buf-type op &optional n ctl-buf)
1425 (ediff-eval-in-buffer (or ctl-buf ediff-control-buffer)
1426 (if (ediff-valid-difference-p n)
1427 (let* ((func (cond ((eq op 'scroll-down)
1428 'ediff-get-lines-to-region-start)
1430 'ediff-get-lines-to-region-end)
1431 (t '(lambda (a b c) 0))))
1432 (max-lines (max (funcall func 'A n ctl-buf)
1433 (funcall func 'B n ctl-buf)
1434 (if (ediff-buffer-live-p ediff-buffer-C)
1435 (funcall func 'C n ctl-buf)
1437 ;; this covers the horizontal coefficient as well:
1438 ;; if max-lines = 0 then coef = 1
1440 (/ (+ (funcall func buf-type n ctl-buf) 0.0)
1446 (defun ediff-next-difference (&optional arg)
1447 "Advance to the next difference.
1448 With a prefix argument, go forward that many differences."
1450 (ediff-barf-if-not-control-buffer)
1451 (if (< ediff-current-difference ediff-number-of-differences)
1452 (let ((n (min ediff-number-of-differences
1453 (+ ediff-current-difference arg)))
1456 (or (>= n ediff-number-of-differences)
1457 (setq regexp-skip (funcall ediff-skip-diff-region-function n))
1458 (ediff-install-fine-diff-if-necessary n))
1459 (while (and (< n ediff-number-of-differences)
1463 ;; skip clashes, if necessary
1464 (and ediff-show-clashes-only
1465 (string-match "prefer"
1466 (or (ediff-get-state-of-merge n) "")))
1467 ;; skip difference regions that differ in white space
1468 (and ediff-ignore-similar-regions
1469 (ediff-no-fine-diffs-p n))))
1471 (if (= 0 (mod n 20))
1472 (message "Skipped over region %d and counting ..." n))
1473 (or (>= n ediff-number-of-differences)
1474 (setq regexp-skip (funcall ediff-skip-diff-region-function n))
1475 (ediff-install-fine-diff-if-necessary n))
1478 (ediff-unselect-and-select-difference n)
1480 (ediff-visible-region)
1481 (error "At end of the difference list")))
1483 (defun ediff-previous-difference (&optional arg)
1484 "Go to the previous difference.
1485 With a prefix argument, go back that many differences."
1487 (ediff-barf-if-not-control-buffer)
1488 (if (> ediff-current-difference -1)
1489 (let ((n (max -1 (- ediff-current-difference arg)))
1493 (setq regexp-skip (funcall ediff-skip-diff-region-function n))
1494 (ediff-install-fine-diff-if-necessary n))
1495 (while (and (> n -1)
1499 ;; skip clashes, if necessary
1500 (and ediff-show-clashes-only
1501 (string-match "prefer"
1502 (or (ediff-get-state-of-merge n) "")))
1503 ;; skip difference regions that differ in white space
1504 (and ediff-ignore-similar-regions
1505 (ediff-no-fine-diffs-p n))))
1506 (if (= 0 (mod (1+ n) 20))
1507 (message "Skipped over region %d and counting ..." (1+ n)))
1510 (setq regexp-skip (funcall ediff-skip-diff-region-function n))
1511 (ediff-install-fine-diff-if-necessary n))
1514 (ediff-unselect-and-select-difference n)
1516 (ediff-visible-region)
1517 (error "At beginning of the difference list")))
1519 ;; The diff number is as perceived by the user (i.e., 1+ the internal
1521 (defun ediff-jump-to-difference (difference-number)
1522 "Go to the difference specified as a prefix argument.
1523 If the prefix is negative, count differences from the end."
1525 (ediff-barf-if-not-control-buffer)
1526 (setq difference-number
1527 (cond ((< difference-number 0)
1528 (+ ediff-number-of-differences difference-number))
1529 ((> difference-number 0) (1- difference-number))
1531 ;; -1 is allowed by ediff-unselect-and-select-difference --- it is the
1532 ;; position before the first one.
1533 (if (and (>= difference-number -1)
1534 (<= difference-number ediff-number-of-differences))
1535 (ediff-unselect-and-select-difference difference-number)
1536 (error ediff-BAD-DIFF-NUMBER
1537 this-command (1+ difference-number) ediff-number-of-differences)))
1539 (defun ediff-jump-to-difference-at-point (arg)
1540 "Go to difference closest to the point in buffer A, B, or C.
1541 The buffer depends on last command character \(a, b, or c\) that invoked this
1542 command. For instance, if the command was `ga' then the point value in buffer A
1544 With a prefix argument, synchronize all files around the current point position
1545 in the specified buffer."
1547 (ediff-barf-if-not-control-buffer)
1548 (let* ((buf-type (ediff-char-to-buftype last-command-char))
1549 (buffer (ediff-get-buffer buf-type))
1550 (pt (ediff-eval-in-buffer buffer (point)))
1551 (diff-no (ediff-diff-at-point buf-type nil (if arg 'after)))
1552 (past-last-diff (< ediff-number-of-differences diff-no))
1553 (beg (if past-last-diff
1554 (ediff-eval-in-buffer buffer (point-max))
1555 (ediff-get-diff-posn buf-type 'beg (1- diff-no))))
1556 ctl-wind wind-A wind-B wind-C
1559 (ediff-jump-to-difference -1)
1560 (ediff-jump-to-difference diff-no))
1561 (setq ctl-wind (selected-window)
1562 wind-A ediff-window-A
1563 wind-B ediff-window-B
1564 wind-C ediff-window-C)
1567 (ediff-eval-in-buffer buffer
1568 (setq shift (- beg pt)))
1569 (select-window wind-A)
1570 (if past-last-diff (goto-char (point-max)))
1572 (backward-char shift) ; noerror, if beginning of buffer
1575 (select-window wind-B)
1576 (if past-last-diff (goto-char (point-max)))
1578 (backward-char shift) ; noerror, if beginning of buffer
1581 (if (window-live-p wind-C)
1583 (select-window wind-C)
1584 (if past-last-diff (goto-char (point-max)))
1586 (backward-char shift) ; noerror, if beginning of buffer
1590 (select-window ctl-wind)
1595 ;; find region most related to the current point position (or POS, if given)
1596 ;; returns diff number as seen by the user (i.e., 1+ the internal
1598 ;; The optional argument WHICH-DIFF can be `after' or `before'. If `after',
1599 ;; find the diff after the point. If `before', find the diff before the
1600 ;; point. If the point is inside a diff, return that diff.
1601 (defun ediff-diff-at-point (buf-type &optional pos which-diff)
1602 (let ((buffer (ediff-get-buffer buf-type))
1603 (ctl-buffer ediff-control-buffer)
1604 (max-dif-num (1- ediff-number-of-differences))
1611 (ediff-eval-in-buffer buffer
1612 (setq pos (or pos (point)))
1613 (while (and (or (< pos prev-beg) (> pos beg))
1614 (< diff-no max-dif-num))
1615 (setq diff-no (1+ diff-no))
1618 (setq beg (ediff-get-diff-posn buf-type 'beg diff-no ctl-buffer)
1619 end (ediff-get-diff-posn buf-type 'end diff-no ctl-buffer))
1622 ;; boost diff-no by 1, if past the last diff region
1623 (if (and (memq which-diff '(after before))
1624 (> pos beg) (= diff-no max-dif-num))
1625 (setq diff-no (1+ diff-no)))
1627 (cond ((eq which-diff 'after) (1+ diff-no))
1628 ((eq which-diff 'before) diff-no)
1629 ((< (abs (count-lines pos (max 1 prev-end)))
1630 (abs (count-lines pos (max 1 beg))))
1631 diff-no) ; choose prev difference
1633 (1+ diff-no))) ; choose next difference
1639 (defun ediff-diff-to-diff (arg &optional keys)
1640 "Copy buffer-X'th difference region to buffer Y \(X,Y are A, B, or C\).
1641 If numerical prefix argument, copy the difference specified in the arg.
1642 Otherwise, copy the difference given by `ediff-current-difference'.
1643 This command assumes it is bound to a 2-character key sequence, `ab', `ba',
1644 `ac', etc., which is used to determine the types of buffers to be used for
1645 copying difference regions. The first character in the sequence specifies
1646 the source buffer and the second specifies the target.
1648 If the second optional argument, a 2-character string, is given, use it to
1649 determine the source and the target buffers instead of the command keys."
1651 (ediff-barf-if-not-control-buffer)
1652 (or keys (setq keys (this-command-keys)))
1653 (if (eq arg '-) (setq arg -1)) ; translate neg arg to -1
1654 (if (numberp arg) (ediff-jump-to-difference arg))
1656 (let* ((key1 (aref keys 0))
1657 (key2 (aref keys 1))
1658 (char1 (if (and ediff-xemacs-p (eventp key1)) (event-key key1) key1))
1659 (char2 (if (and ediff-xemacs-p (eventp key1)) (event-key key2) key2))
1661 (ediff-copy-diff ediff-current-difference
1662 (ediff-char-to-buftype char1)
1663 (ediff-char-to-buftype char2))
1664 ;; recenter with rehighlighting, but no messages
1667 (defun ediff-copy-A-to-B (arg)
1668 "Copy ARGth difference region from buffer A to B.
1669 ARG is a prefix argument. If nil, copy the current difference region."
1671 (ediff-diff-to-diff arg "ab"))
1673 (defun ediff-copy-B-to-A (arg)
1674 "Copy ARGth difference region from buffer B to A.
1675 ARG is a prefix argument. If nil, copy the current difference region."
1677 (ediff-diff-to-diff arg "ba"))
1679 (defun ediff-copy-A-to-C (arg)
1680 "Copy ARGth difference region from buffer A to buffer C.
1681 ARG is a prefix argument. If nil, copy the current difference region."
1683 (ediff-diff-to-diff arg "ac"))
1685 (defun ediff-copy-B-to-C (arg)
1686 "Copy ARGth difference region from buffer B to buffer C.
1687 ARG is a prefix argument. If nil, copy the current difference region."
1689 (ediff-diff-to-diff arg "bc"))
1691 (defun ediff-copy-C-to-B (arg)
1692 "Copy ARGth difference region from buffer C to B.
1693 ARG is a prefix argument. If nil, copy the current difference region."
1695 (ediff-diff-to-diff arg "cb"))
1697 (defun ediff-copy-C-to-A (arg)
1698 "Copy ARGth difference region from buffer C to A.
1699 ARG is a prefix argument. If nil, copy the current difference region."
1701 (ediff-diff-to-diff arg "ca"))
1705 ;; Copy diff N from FROM-BUF-TYPE \(given as A, B or C\) to TO-BUF-TYPE.
1706 ;; If optional DO-NOT-SAVE is non-nil, do not save the old value of the
1707 ;; target diff. This is used in merging, when constructing the merged
1709 (defun ediff-copy-diff (n from-buf-type to-buf-type
1710 &optional batch-invocation reg-to-copy)
1711 (let* ((to-buf (ediff-get-buffer to-buf-type))
1712 ;;(from-buf (if (not reg-to-copy) (ediff-get-buffer from-buf-type)))
1713 (ctrl-buf ediff-control-buffer)
1715 (three-way ediff-3way-job)
1718 reg-to-delete reg-to-delete-beg reg-to-delete-end)
1720 (setq reg-to-delete-beg
1721 (ediff-get-diff-posn to-buf-type 'beg n ctrl-buf))
1722 (setq reg-to-delete-end
1723 (ediff-get-diff-posn to-buf-type 'end n ctrl-buf))
1726 (setq from-buf-type nil)
1727 (setq reg-to-copy (ediff-get-region-contents n from-buf-type ctrl-buf)))
1729 (setq reg-to-delete (ediff-get-region-contents
1730 n to-buf-type ctrl-buf
1731 reg-to-delete-beg reg-to-delete-end))
1733 (if (string= reg-to-delete reg-to-copy)
1734 (setq saved-p nil) ; don't copy identical buffers
1736 (if (or batch-invocation (ediff-test-save-region n to-buf-type))
1737 (condition-case conds
1739 (ediff-eval-in-buffer to-buf
1740 ;; to prevent flags from interfering if buffer is writable
1741 (let ((inhibit-read-only (null buffer-read-only)))
1743 (goto-char reg-to-delete-end)
1744 (insert reg-to-copy)
1746 (if (> reg-to-delete-end reg-to-delete-beg)
1747 (kill-region reg-to-delete-beg reg-to-delete-end))
1749 (or batch-invocation
1752 (ediff-save-diff-region n to-buf-type reg-to-delete))))
1753 (error (message "ediff-copy-diff: %s %s"
1755 (mapconcat 'prin1-to-string (cdr conds) " "))
1757 (sit-for 2) ; let the user see the error msg
1762 ;; adjust state of difference in case 3-way and diff was copied ok
1763 (if (and saved-p three-way)
1764 (ediff-set-state-of-diff-in-all-buffers n ctrl-buf))
1766 (if batch-invocation
1767 (ediff-clear-fine-differences n)
1768 ;; If diff3 job, we should recompute fine diffs so we clear them
1769 ;; before reinserting flags (and thus before ediff-recenter).
1770 (if (and saved-p three-way)
1771 (ediff-clear-fine-differences n))
1773 (ediff-refresh-mode-lines)
1775 ;; For diff2 jobs, don't recompute fine diffs, since we know there
1776 ;; aren't any. So we clear diffs after ediff-recenter.
1777 (if (and saved-p (not three-way))
1778 (ediff-clear-fine-differences n))
1779 ;; Make sure that the message about saving and how to restore is seen
1784 ;; Save Nth diff of buffer BUF-TYPE \(A, B, or C\).
1785 ;; That is to say, the Nth diff on the `ediff-killed-diffs-alist'. REG
1786 ;; is the region to save. It is redundant here, but is passed anyway, for
1788 (defun ediff-save-diff-region (n buf-type reg)
1789 (let* ((n-th-diff-saved (assoc n ediff-killed-diffs-alist))
1790 (buf (ediff-get-buffer buf-type))
1791 (this-buf-n-th-diff-saved (assoc buf (cdr n-th-diff-saved))))
1793 (if this-buf-n-th-diff-saved
1794 ;; either nothing saved for n-th diff and buffer or we OK'ed
1796 (setcdr this-buf-n-th-diff-saved reg)
1797 (if n-th-diff-saved ;; n-th diff saved, but for another buffer
1798 (nconc n-th-diff-saved (list (cons buf reg)))
1799 (setq ediff-killed-diffs-alist ;; create record for n-th diff
1800 (cons (list n (cons buf reg))
1801 ediff-killed-diffs-alist))))
1802 (message "Saving old diff region #%d of buffer %S. To recover, type `r%s'"
1805 "" (downcase (symbol-name buf-type))))
1808 ;; Test if saving Nth difference region of buffer BUF-TYPE is possible.
1809 (defun ediff-test-save-region (n buf-type)
1810 (let* ((n-th-diff-saved (assoc n ediff-killed-diffs-alist))
1811 (buf (ediff-get-buffer buf-type))
1812 (this-buf-n-th-diff-saved (assoc buf (cdr n-th-diff-saved))))
1814 (if this-buf-n-th-diff-saved
1817 "You've previously copied diff region %d to buffer %S. Confirm "
1823 (defun ediff-pop-diff (n buf-type)
1824 "Pop last killed Nth diff region from buffer BUF-TYPE."
1825 (let* ((n-th-record (assoc n ediff-killed-diffs-alist))
1826 (buf (ediff-get-buffer buf-type))
1827 (saved-rec (assoc buf (cdr n-th-record)))
1828 (three-way ediff-3way-job)
1829 (ctl-buf ediff-control-buffer)
1831 saved-diff reg-beg reg-end recovered)
1834 (setq saved-diff (cdr saved-rec))
1835 (if (> ediff-number-of-differences 0)
1836 (error "Nothing saved for diff %d in buffer %S" (1+ n) buf-type)
1837 (error ediff-NO-DIFFERENCES)))
1839 (setq reg-beg (ediff-get-diff-posn buf-type 'beg n ediff-control-buffer))
1840 (setq reg-end (ediff-get-diff-posn buf-type 'end n ediff-control-buffer))
1842 (condition-case conds
1843 (ediff-eval-in-buffer buf
1844 (let ((inhibit-read-only (null buffer-read-only)))
1849 (if (> reg-end reg-beg)
1850 (kill-region reg-beg reg-end))
1854 (error (message "ediff-pop-diff: %s %s"
1856 (mapconcat 'prin1-to-string (cdr conds) " "))
1859 ;; Clearing fine diffs is necessary for
1860 ;; ediff-unselect-and-select-difference to properly recompute them. We
1861 ;; can't rely on ediff-copy-diff to clear this vector, as the user might
1862 ;; have modified diff regions after copying and, thus, may have recomputed
1865 (ediff-clear-fine-differences n))
1867 ;; adjust state of difference
1868 (if (and three-way recovered)
1869 (ediff-set-state-of-diff-in-all-buffers n ctl-buf))
1871 (ediff-refresh-mode-lines)
1875 (setq n-th-record (delq saved-rec n-th-record))
1876 (message "Diff region %d in buffer %S restored" (1+ n) buf-type)
1880 (defun ediff-restore-diff (arg &optional key)
1881 "Restore ARGth diff from `ediff-killed-diffs-alist'.
1882 ARG is a prefix argument. If ARG is nil, restore the current-difference.
1883 If the second optional argument, a character, is given, use it to
1884 determine the target buffer instead of last-command-char"
1886 (ediff-barf-if-not-control-buffer)
1888 (ediff-jump-to-difference arg))
1889 (ediff-pop-diff ediff-current-difference
1890 (ediff-char-to-buftype (or key last-command-char)))
1891 ;; recenter with rehighlighting, but no messages
1892 (let (ediff-verbose-p)
1895 (defun ediff-restore-diff-in-merge-buffer (arg)
1896 "Restore ARGth diff in the merge buffer.
1897 ARG is a prefix argument. If nil, restore the current diff."
1899 (ediff-restore-diff arg ?c))
1902 (defun ediff-toggle-regexp-match ()
1903 "Toggle between focusing and hiding of difference regions that match
1904 a regular expression typed in by the user."
1906 (ediff-barf-if-not-control-buffer)
1910 msg-connective alt-msg-connective alt-connective)
1912 ((or (and (eq ediff-skip-diff-region-function
1913 ediff-focus-on-regexp-matches-function)
1914 (eq last-command-char ?f))
1915 (and (eq ediff-skip-diff-region-function
1916 ediff-hide-regexp-matches-function)
1917 (eq last-command-char ?h)))
1918 (message "Selective browsing by regexp turned off")
1919 (setq ediff-skip-diff-region-function 'ediff-show-all-diffs))
1920 ((eq last-command-char ?h)
1921 (setq ediff-skip-diff-region-function ediff-hide-regexp-matches-function
1925 "Ignore A-regions matching this regexp (default \"%s\"): "
1926 ediff-regexp-hide-A))
1930 "Ignore B-regions matching this regexp (default \"%s\"): "
1931 ediff-regexp-hide-B)))
1932 (if ediff-3way-comparison-job
1936 "Ignore C-regions matching this regexp (default \"%s\"): "
1937 ediff-regexp-hide-C))))
1938 (if (eq ediff-hide-regexp-connective 'and)
1939 (setq msg-connective "BOTH"
1940 alt-msg-connective "ONE OF"
1942 (setq msg-connective "ONE OF"
1943 alt-msg-connective "BOTH"
1944 alt-connective 'and))
1947 "Ignore regions that match %s regexps, OK? "
1948 msg-connective alt-msg-connective))
1949 (message "Will ignore regions that match %s regexps" msg-connective)
1950 (setq ediff-hide-regexp-connective alt-connective)
1951 (message "Will ignore regions that match %s regexps"
1952 alt-msg-connective))
1954 (or (string= regexp-A "") (setq ediff-regexp-hide-A regexp-A))
1955 (or (string= regexp-B "") (setq ediff-regexp-hide-B regexp-B))
1956 (or (string= regexp-C "") (setq ediff-regexp-hide-C regexp-C)))
1958 ((eq last-command-char ?f)
1959 (setq ediff-skip-diff-region-function
1960 ediff-focus-on-regexp-matches-function
1964 "Focus on A-regions matching this regexp (default \"%s\"): "
1965 ediff-regexp-focus-A))
1969 "Focus on B-regions matching this regexp (default \"%s\"): "
1970 ediff-regexp-focus-B)))
1971 (if ediff-3way-comparison-job
1975 "Focus on C-regions matching this regexp (default \"%s\"): "
1976 ediff-regexp-focus-C))))
1977 (if (eq ediff-focus-regexp-connective 'and)
1978 (setq msg-connective "BOTH"
1979 alt-msg-connective "ONE OF"
1981 (setq msg-connective "ONE OF"
1982 alt-msg-connective "BOTH"
1983 alt-connective 'and))
1986 "Focus on regions that match %s regexps, OK? "
1987 msg-connective alt-msg-connective))
1988 (message "Will focus on regions that match %s regexps"
1990 (setq ediff-focus-regexp-connective alt-connective)
1991 (message "Will focus on regions that match %s regexps"
1992 alt-msg-connective))
1994 (or (string= regexp-A "") (setq ediff-regexp-focus-A regexp-A))
1995 (or (string= regexp-B "") (setq ediff-regexp-focus-B regexp-B))
1996 (or (string= regexp-C "") (setq ediff-regexp-focus-C regexp-C))))))
1998 (defun ediff-toggle-skip-similar ()
2000 (ediff-barf-if-not-control-buffer)
2001 (if (not (eq ediff-auto-refine 'on))
2003 "Can't skip over whitespace regions: first turn auto-refining on"))
2004 (setq ediff-ignore-similar-regions (not ediff-ignore-similar-regions))
2005 (if ediff-ignore-similar-regions
2007 "Skipping regions that differ only in white space & line breaks")
2008 (message "Skipping over white-space differences turned off")))
2010 (defun ediff-focus-on-regexp-matches (n)
2011 "Focus on diffs that match regexp `ediff-regexp-focus-A/B'.
2012 Regions to be ignored according to this function are those where
2013 buf A region doesn't match `ediff-regexp-focus-A' and buf B region
2014 doesn't match `ediff-regexp-focus-B'.
2015 This function returns nil if the region number N (specified as
2016 an argument) is not to be ignored and t if region N is to be ignored.
2018 N is a region number used by Ediff internally. It is 1 less
2019 the number seen by the user."
2020 (if (ediff-valid-difference-p n)
2021 (let* ((ctl-buf ediff-control-buffer)
2022 (regex-A ediff-regexp-focus-A)
2023 (regex-B ediff-regexp-focus-B)
2024 (regex-C ediff-regexp-focus-C)
2025 (reg-A-match (ediff-eval-in-buffer ediff-buffer-A
2028 (ediff-get-diff-posn 'A 'beg n ctl-buf)
2029 (ediff-get-diff-posn 'A 'end n ctl-buf))
2030 (goto-char (point-min))
2031 (re-search-forward regex-A nil t))))
2032 (reg-B-match (ediff-eval-in-buffer ediff-buffer-B
2035 (ediff-get-diff-posn 'B 'beg n ctl-buf)
2036 (ediff-get-diff-posn 'B 'end n ctl-buf))
2037 (re-search-forward regex-B nil t))))
2038 (reg-C-match (if ediff-3way-comparison-job
2039 (ediff-eval-in-buffer ediff-buffer-C
2042 (ediff-get-diff-posn 'C 'beg n ctl-buf)
2043 (ediff-get-diff-posn 'C 'end n ctl-buf))
2044 (re-search-forward regex-C nil t))))))
2045 (not (eval (if ediff-3way-comparison-job
2046 (list ediff-focus-regexp-connective
2047 reg-A-match reg-B-match reg-C-match)
2048 (list ediff-focus-regexp-connective
2049 reg-A-match reg-B-match))))
2052 (defun ediff-hide-regexp-matches (n)
2053 "Hide diffs that match regexp `ediff-regexp-hide-A/B/C'.
2054 Regions to be ignored are those where buf A region matches
2055 `ediff-regexp-hide-A' and buf B region matches `ediff-regexp-hide-B'.
2056 This function returns nil if the region number N (specified as
2057 an argument) is not to be ignored and t if region N is to be ignored.
2059 N is a region number used by Ediff internally. It is 1 less
2060 the number seen by the user."
2061 (if (ediff-valid-difference-p n)
2062 (let* ((ctl-buf ediff-control-buffer)
2063 (regex-A ediff-regexp-hide-A)
2064 (regex-B ediff-regexp-hide-B)
2065 (regex-C ediff-regexp-hide-C)
2066 (reg-A-match (ediff-eval-in-buffer ediff-buffer-A
2069 (ediff-get-diff-posn 'A 'beg n ctl-buf)
2070 (ediff-get-diff-posn 'A 'end n ctl-buf))
2071 (goto-char (point-min))
2072 (re-search-forward regex-A nil t))))
2073 (reg-B-match (ediff-eval-in-buffer ediff-buffer-B
2076 (ediff-get-diff-posn 'B 'beg n ctl-buf)
2077 (ediff-get-diff-posn 'B 'end n ctl-buf))
2078 (goto-char (point-min))
2079 (re-search-forward regex-B nil t))))
2080 (reg-C-match (if ediff-3way-comparison-job
2081 (ediff-eval-in-buffer ediff-buffer-C
2084 (ediff-get-diff-posn 'C 'beg n ctl-buf)
2085 (ediff-get-diff-posn 'C 'end n ctl-buf))
2086 (goto-char (point-min))
2087 (re-search-forward regex-C nil t))))))
2088 (eval (if ediff-3way-comparison-job
2089 (list ediff-hide-regexp-connective
2090 reg-A-match reg-B-match reg-C-match)
2091 (list ediff-hide-regexp-connective reg-A-match reg-B-match)))
2096 ;;; Quitting, suspending, etc.
2098 (defun ediff-quit (reverse-default-keep-variants)
2099 "Finish an Ediff session and exit Ediff.
2100 Unselects the selected difference, if any, restores the read-only and modified
2101 flags of the compared file buffers, kills Ediff buffers for this session
2102 \(but not buffers A, B, C\).
2104 If `ediff-keep-variants' is nil, the user will be asked whether the buffers
2105 containing the variants should be removed \(if they haven't been modified\).
2106 If it is t, they will be preserved unconditionally. A prefix argument,
2107 temporarily reverses the meaning of this variable."
2109 (ediff-barf-if-not-control-buffer)
2110 (if (y-or-n-p (format "Quit this Ediff session%s? "
2111 (if (ediff-buffer-live-p ediff-meta-buffer)
2112 " & show containing session group" "")))
2115 (ediff-really-quit reverse-default-keep-variants))
2119 ;; Perform the quit operations.
2120 (defun ediff-really-quit (reverse-default-keep-variants)
2121 (ediff-unhighlight-diffs-totally)
2122 (ediff-clear-diff-vector 'ediff-difference-vector-A 'fine-diffs-also)
2123 (ediff-clear-diff-vector 'ediff-difference-vector-B 'fine-diffs-also)
2124 (ediff-clear-diff-vector 'ediff-difference-vector-C 'fine-diffs-also)
2125 (ediff-clear-diff-vector 'ediff-difference-vector-Ancestor 'fine-diffs-also)
2127 (ediff-delete-temp-files)
2129 ;; Restore visibility range. This affects only ediff-*-regions/windows.
2130 ;; Since for other job names ediff-visible-region sets
2131 ;; ediff-visible-bounds to ediff-wide-bounds, the settings below are
2132 ;; ignored for such jobs.
2133 (if ediff-quit-widened
2134 (setq ediff-visible-bounds ediff-wide-bounds)
2135 (setq ediff-visible-bounds ediff-narrow-bounds))
2137 ;; Apply selective display to narrow or widen
2138 (ediff-visible-region)
2139 (mapcar (function (lambda (overl)
2140 (if (ediff-overlayp overl)
2141 (ediff-delete-overlay overl))))
2143 (mapcar (function (lambda (overl)
2144 (if (ediff-overlayp overl)
2145 (ediff-delete-overlay overl))))
2146 ediff-narrow-bounds)
2148 ;; restore buffer mode line id's in buffer-A/B/C
2149 (let ((control-buffer ediff-control-buffer)
2150 (meta-buffer ediff-meta-buffer)
2151 ;; suitable working frame
2152 (warp-frame (if (and (ediff-window-display-p) (eq ediff-grab-mouse t))
2153 (cond ((window-live-p ediff-window-A)
2154 (window-frame ediff-window-A))
2155 ((window-live-p ediff-window-B)
2156 (window-frame ediff-window-B))
2157 (t (next-frame))))))
2159 (ediff-eval-in-buffer ediff-buffer-A
2160 (setq ediff-this-buffer-ediff-sessions
2161 (delq control-buffer ediff-this-buffer-ediff-sessions))
2162 (kill-local-variable 'mode-line-buffer-identification)
2163 (kill-local-variable 'mode-line-format)
2168 (ediff-eval-in-buffer ediff-buffer-B
2169 (setq ediff-this-buffer-ediff-sessions
2170 (delq control-buffer ediff-this-buffer-ediff-sessions))
2171 (kill-local-variable 'mode-line-buffer-identification)
2172 (kill-local-variable 'mode-line-format)
2177 (ediff-eval-in-buffer ediff-buffer-C
2178 (setq ediff-this-buffer-ediff-sessions
2179 (delq control-buffer ediff-this-buffer-ediff-sessions))
2180 (kill-local-variable 'mode-line-buffer-identification)
2181 (kill-local-variable 'mode-line-format)
2186 (ediff-eval-in-buffer ediff-ancestor-buffer
2187 (setq ediff-this-buffer-ediff-sessions
2188 (delq control-buffer ediff-this-buffer-ediff-sessions))
2189 (kill-local-variable 'mode-line-buffer-identification)
2190 (kill-local-variable 'mode-line-format)
2194 (setq ediff-session-registry
2195 (delq ediff-control-buffer ediff-session-registry))
2196 (ediff-update-registry)
2197 ;; restore state of buffers to what it was before ediff
2198 (ediff-restore-protected-variables)
2200 ;; If the user interrupts (canceling saving the merge buffer), continue
2203 (if (ediff-merge-job)
2204 (run-hooks 'ediff-quit-merge-hook))
2207 ;; good place to kill buffers A/B/C
2208 (run-hooks 'ediff-cleanup-hook)
2209 (let ((ediff-keep-variants ediff-keep-variants))
2210 (if reverse-default-keep-variants
2211 (setq ediff-keep-variants (not ediff-keep-variants)))
2212 (or ediff-keep-variants (ediff-janitor 'ask)))
2214 (run-hooks 'ediff-quit-hook)
2215 (ediff-cleanup-meta-buffer meta-buffer)
2217 ;; warp mouse into a working window
2218 (setq warp-frame ; if mouse is over a reasonable frame, use it
2219 (cond ((and ediff-xemacs-p (window-live-p (car (mouse-position))))
2220 (window-frame (car (mouse-position))))
2221 ((frame-live-p (car (mouse-position)))
2222 (car (mouse-position)))
2224 (if (frame-live-p warp-frame)
2225 (set-mouse-position (if ediff-emacs-p
2227 (frame-selected-window warp-frame))
2230 (if (ediff-buffer-live-p meta-buffer)
2231 (ediff-show-meta-buffer meta-buffer))
2235 (defun ediff-delete-temp-files ()
2236 (if (stringp ediff-temp-file-A)
2237 (delete-file ediff-temp-file-A))
2238 (if (stringp ediff-temp-file-B)
2239 (delete-file ediff-temp-file-B))
2240 (if (stringp ediff-temp-file-C)
2241 (delete-file ediff-temp-file-C)))
2244 ;; Kill control buffer, other auxiliary Ediff buffers.
2245 ;; Leave one of the frames split between buffers A/B/C
2246 (defun ediff-cleanup-mess ()
2247 (let ((buff-A ediff-buffer-A)
2248 (buff-B ediff-buffer-B)
2249 (buff-C ediff-buffer-C)
2250 (ctl-buf ediff-control-buffer)
2251 (ctl-frame ediff-control-frame)
2252 (three-way-job ediff-3way-job))
2254 (ediff-kill-buffer-carefully ediff-diff-buffer)
2255 (ediff-kill-buffer-carefully ediff-custom-diff-buffer)
2256 (ediff-kill-buffer-carefully ediff-fine-diff-buffer)
2257 (ediff-kill-buffer-carefully ediff-tmp-buffer)
2258 (ediff-kill-buffer-carefully ediff-error-buffer)
2259 (ediff-kill-buffer-carefully ediff-patch-diagnostics)
2260 (ediff-kill-buffer-carefully ediff-msg-buffer)
2261 (ediff-kill-buffer-carefully ediff-debug-buffer)
2263 (if (and (ediff-window-display-p) (frame-live-p ctl-frame))
2264 (delete-frame ctl-frame))
2265 (ediff-kill-buffer-carefully ctl-buf)
2267 (delete-other-windows)
2269 ;; display only if not visible
2271 (or (ediff-get-visible-buffer-window buff-B)
2272 (switch-to-buffer buff-B))
2275 (or (ediff-get-visible-buffer-window buff-A)
2277 (if (ediff-get-visible-buffer-window buff-B)
2278 (funcall ediff-split-window-function))
2279 (switch-to-buffer buff-A)))
2283 (or (ediff-get-visible-buffer-window buff-C)
2285 (if (or (ediff-get-visible-buffer-window buff-A)
2286 (ediff-get-visible-buffer-window buff-B))
2287 (funcall ediff-split-window-function))
2288 (switch-to-buffer buff-C)
2294 (defun ediff-janitor (&optional ask)
2295 "Kill buffers A, B, and, possibly, C, if these buffers aren't modified.
2296 In merge jobs, buffer C is never deleted.
2297 However, the side effect of cleaning up may be that you cannot compare the same
2298 buffer in two separate Ediff sessions: quitting one of them will delete this
2299 buffer in another session as well."
2300 (or (not (ediff-buffer-live-p ediff-buffer-A))
2301 (buffer-modified-p ediff-buffer-A)
2303 (not (y-or-n-p (format "Kill buffer A [%s]? "
2304 (buffer-name ediff-buffer-A)))))
2305 (ediff-kill-buffer-carefully ediff-buffer-A))
2306 (or (not (ediff-buffer-live-p ediff-buffer-B))
2307 (buffer-modified-p ediff-buffer-B)
2309 (not (y-or-n-p (format "Kill buffer B [%s]? "
2310 (buffer-name ediff-buffer-B)))))
2311 (ediff-kill-buffer-carefully ediff-buffer-B))
2312 (if ediff-merge-job ; don't del buf C if merging--del ancestor buf instead
2313 (or (not (ediff-buffer-live-p ediff-ancestor-buffer))
2314 (buffer-modified-p ediff-ancestor-buffer)
2316 (not (y-or-n-p (format "Kill the ancestor buffer [%s]? "
2317 (buffer-name ediff-ancestor-buffer)))))
2318 (ediff-kill-buffer-carefully ediff-ancestor-buffer))
2319 (or (not (ediff-buffer-live-p ediff-buffer-C))
2320 (buffer-modified-p ediff-buffer-C)
2321 (and ask (not (y-or-n-p (format "Kill buffer C [%s]? "
2322 (buffer-name ediff-buffer-C)))))
2323 (ediff-kill-buffer-carefully ediff-buffer-C))))
2325 (defun ediff-maybe-save-and-delete-merge ()
2326 "Default hook to run on quitting a merge job.
2327 If `ediff-autostore-merges' is nil, this does nothing.
2328 If it is t, it saves the merge buffer in the file `ediff-merge-store-file'
2329 or asks the user, if the latter is nil. It then then asks the user whether to
2330 delete the merge buffer.
2331 If `ediff-autostore-merges' is neither nil nor t, the merge buffer is saved
2332 only if this merge job is part of a group, i.e., was invoked from within
2333 `ediff-merge-directories', `ediff-merge-directory-revisions', and such."
2334 (let ((merge-store-file ediff-merge-store-file))
2335 (if ediff-autostore-merges
2336 (cond ((stringp ediff-merge-store-file)
2337 ;; store, ask to delete
2338 (ediff-write-merge-buffer-then-kill
2339 ediff-buffer-C merge-store-file 'show-file))
2340 ((eq ediff-autostore-merges t)
2341 ;; ask for file name
2342 (setq merge-store-file
2343 (read-file-name "Save the result of the merge in: "))
2344 (ediff-write-merge-buffer-then-kill
2345 ediff-buffer-C merge-store-file))
2346 ((ediff-eval-in-buffer ediff-meta-buffer
2347 (ediff-merge-metajob))
2348 ;; This case shouldn't occur, as the parent metajob must pass on
2349 ;; a file name, ediff-merge-store-file, where to save the result
2351 ;; Ask where to save anyway--will decide what to do here later.
2352 (setq merge-store-file
2353 (read-file-name "The result of the merge goes into: "))
2354 (ediff-write-merge-buffer-then-kill
2355 ediff-buffer-C merge-store-file))))
2358 (defun ediff-write-merge-buffer-then-kill (buf file &optional show-file)
2359 (ediff-eval-in-buffer buf
2360 (if (or (not (file-exists-p file))
2361 (y-or-n-p (format "File %s exists, overwrite? " file)))
2363 (write-region (point-min) (point-max) file)
2366 (message "Merge buffer saved in: %s" file)
2368 (if (y-or-n-p "Merge buffer saved in file. Now kill the buffer? ")
2369 (ediff-kill-buffer-carefully buf))))))
2371 ;; The default way of suspending Ediff.
2372 ;; Buries Ediff buffers, kills all windows.
2373 (defun ediff-default-suspend-function ()
2374 (let* ((buf-A ediff-buffer-A)
2375 (buf-B ediff-buffer-B)
2376 (buf-C ediff-buffer-C)
2377 (buf-A-wind (ediff-get-visible-buffer-window buf-A))
2378 (buf-B-wind (ediff-get-visible-buffer-window buf-B))
2379 (buf-C-wind (ediff-get-visible-buffer-window buf-C))
2380 (buf-patch ediff-patchbufer)
2381 (buf-patch-diag ediff-patch-diagnostics)
2382 (buf-err ediff-error-buffer)
2383 (buf-diff ediff-diff-buffer)
2384 (buf-custom-diff ediff-custom-diff-buffer)
2385 (buf-fine-diff ediff-fine-diff-buffer))
2387 ;; hide the control panel
2388 (if (and (ediff-window-display-p) (frame-live-p ediff-control-frame))
2389 (iconify-frame ediff-control-frame)
2391 (if buf-err (bury-buffer buf-err))
2392 (if buf-diff (bury-buffer buf-diff))
2393 (if buf-custom-diff (bury-buffer buf-custom-diff))
2394 (if buf-fine-diff (bury-buffer buf-fine-diff))
2395 (if buf-patch (bury-buffer buf-patch))
2396 (if buf-patch-diag (bury-buffer buf-patch-diag))
2397 (if (window-live-p buf-A-wind)
2399 (select-window buf-A-wind)
2400 (delete-other-windows)
2402 (if (ediff-buffer-live-p buf-A) (bury-buffer buf-A)))
2403 (if (window-live-p buf-B-wind)
2405 (select-window buf-B-wind)
2406 (delete-other-windows)
2408 (if (ediff-buffer-live-p buf-B) (bury-buffer buf-B)))
2409 (if (window-live-p buf-C-wind)
2411 (select-window buf-C-wind)
2412 (delete-other-windows)
2414 (if (ediff-buffer-live-p buf-C) (bury-buffer buf-C)))
2419 (defun ediff-suspend ()
2421 To resume, switch to the appropriate `Ediff Control Panel'
2422 buffer and then type \\[ediff-recenter]. Ediff will automatically set
2423 up an appropriate window config."
2425 (ediff-barf-if-not-control-buffer)
2426 (run-hooks 'ediff-suspend-hook)
2428 "To resume, type M-x eregistry and select the desired Ediff session"))
2431 (defun ediff-status-info ()
2432 "Show the names of the buffers or files being operated on by Ediff.
2433 Hit \\[ediff-recenter] to reset the windows afterward."
2435 (ediff-barf-if-not-control-buffer)
2437 (ediff-skip-unsuitable-frames))
2438 (with-output-to-temp-buffer ediff-msg-buffer
2439 (raise-frame (selected-frame))
2440 (princ (ediff-version))
2442 (ediff-eval-in-buffer ediff-buffer-A
2443 (if buffer-file-name
2445 (format "File A = %S\n" buffer-file-name))
2447 (format "Buffer A = %S\n" (buffer-name)))))
2448 (ediff-eval-in-buffer ediff-buffer-B
2449 (if buffer-file-name
2451 (format "File B = %S\n" buffer-file-name))
2453 (format "Buffer B = %S\n" (buffer-name)))))
2455 (ediff-eval-in-buffer ediff-buffer-C
2456 (if buffer-file-name
2458 (format "File C = %S\n" buffer-file-name))
2460 (format "Buffer C = %S\n" (buffer-name))))))
2461 (princ (format "Customized diff output %s\n"
2462 (if (ediff-buffer-live-p ediff-custom-diff-buffer)
2463 (concat "\tin buffer "
2464 (buffer-name ediff-custom-diff-buffer))
2465 "is not available")))
2466 (princ (format "Plain diff output %s\n"
2467 (if (ediff-buffer-live-p ediff-diff-buffer)
2468 (concat "\tin buffer "
2469 (buffer-name ediff-diff-buffer))
2470 "is not available")))
2472 (let* ((A-line (ediff-eval-in-buffer ediff-buffer-A
2473 (1+ (count-lines (point-min) (point)))))
2474 (B-line (ediff-eval-in-buffer ediff-buffer-B
2475 (1+ (count-lines (point-min) (point)))))
2477 (princ (format "\Buffer A's point is on line %d\n" A-line))
2478 (princ (format "Buffer B's point is on line %d\n" B-line))
2481 (setq C-line (ediff-eval-in-buffer ediff-buffer-C
2482 (1+ (count-lines (point-min) (point)))))
2483 (princ (format "Buffer C's point is on line %d\n" C-line)))))
2485 (princ (format "\nCurrent difference number = %S\n"
2486 (cond ((< ediff-current-difference 0) 'start)
2487 ((>= ediff-current-difference
2488 ediff-number-of-differences) 'end)
2489 (t (1+ ediff-current-difference)))))
2492 (format "\n%s regions that differ only in white space & line breaks"
2493 (if ediff-ignore-similar-regions
2494 "Skipping" "Not skipping")))
2495 (if (and ediff-merge-job ediff-show-clashes-only)
2497 "\nFocusing on regions where both buffers differ from the ancestor"))
2499 (cond ((eq ediff-skip-diff-region-function 'ediff-show-all-diffs)
2500 (princ "\nSelective browsing by regexp is off\n"))
2501 ((eq ediff-skip-diff-region-function
2502 ediff-hide-regexp-matches-function)
2504 "\nIgnoring regions that match")
2507 "\n\t regexp `%s' in buffer A %S\n\t regexp `%s' in buffer B\n"
2508 ediff-regexp-hide-A ediff-hide-regexp-connective
2509 ediff-regexp-hide-B)))
2510 ((eq ediff-skip-diff-region-function
2511 ediff-focus-on-regexp-matches-function)
2513 "\nFocusing on regions that match")
2516 "\n\t regexp `%s' in buffer A %S\n\t regexp `%s' in buffer B\n"
2517 ediff-regexp-focus-A ediff-focus-regexp-connective
2518 ediff-regexp-focus-B)))
2519 (t (princ "\nSelective browsing via a user-defined method.\n")))
2522 (format "\nBugs/suggestions: type `%s' while in Ediff Control Panel."
2523 (substitute-command-keys "\\[ediff-submit-report]")))
2525 (if (frame-live-p ediff-control-frame)
2526 (ediff-reset-mouse ediff-control-frame))
2527 (if (window-live-p ediff-control-window)
2528 (select-window ediff-control-window)))
2533 ;;; Support routines
2535 ;; Select a difference by placing the ASCII flags around the appropriate
2536 ;; group of lines in the A, B buffers
2537 ;; This may have to be modified for buffer C, when it will be supported.
2538 (defun ediff-select-difference (n)
2539 (if (and (ediff-buffer-live-p ediff-buffer-A)
2540 (ediff-buffer-live-p ediff-buffer-B)
2541 (ediff-valid-difference-p n))
2543 (if (and (ediff-has-face-support-p) ediff-use-faces)
2545 (ediff-highlight-diff n)
2546 (setq ediff-highlighting-style 'face))
2547 (setq ediff-highlighting-style 'ascii)
2548 (ediff-place-flags-in-buffer
2549 'A ediff-buffer-A ediff-control-buffer n)
2550 (ediff-place-flags-in-buffer
2551 'B ediff-buffer-B ediff-control-buffer n)
2553 (ediff-place-flags-in-buffer
2554 'C ediff-buffer-C ediff-control-buffer n))
2555 (if (ediff-buffer-live-p ediff-ancestor-buffer)
2556 (ediff-place-flags-in-buffer
2557 'Ancestor ediff-ancestor-buffer
2558 ediff-control-buffer n))
2561 (ediff-install-fine-diff-if-necessary n)
2562 (run-hooks 'ediff-select-hook))))
2565 ;; Unselect a difference by removing the ASCII flags in the buffers.
2566 ;; This may have to be modified for buffer C, when it will be supported.
2567 (defun ediff-unselect-difference (n)
2568 (if (ediff-valid-difference-p n)
2570 (cond ((and (ediff-has-face-support-p) ediff-use-faces)
2571 (ediff-unhighlight-diff))
2572 ((eq ediff-highlighting-style 'ascii)
2573 (ediff-remove-flags-from-buffer
2575 (ediff-get-diff-overlay n 'A))
2576 (ediff-remove-flags-from-buffer
2578 (ediff-get-diff-overlay n 'B))
2580 (ediff-remove-flags-from-buffer
2582 (ediff-get-diff-overlay n 'C)))
2583 (if (ediff-buffer-live-p ediff-ancestor-buffer)
2584 (ediff-remove-flags-from-buffer
2585 ediff-ancestor-buffer
2586 (ediff-get-diff-overlay n 'Ancestor)))
2588 (setq ediff-highlighting-style nil)
2590 ;; unhighlight fine diffs
2591 (ediff-set-fine-diff-properties ediff-current-difference 'default)
2592 (run-hooks 'ediff-unselect-hook))))
2595 ;; Unselects prev diff and selects a new one, if FLAG has value other than
2596 ;; 'select-only or 'unselect-only. If FLAG is 'select-only, the
2597 ;; next difference is selected, but the current selection is not
2598 ;; unselected. If FLAG is 'unselect-only then the current selection is
2599 ;; unselected, but the next one is not selected. If NO-RECENTER is non-nil,
2600 ;; don't recenter buffers after selecting/unselecting.
2601 (defun ediff-unselect-and-select-difference (n &optional flag no-recenter)
2602 (let ((ediff-current-difference n))
2604 (ediff-recenter 'no-rehighlight)))
2606 (let ((control-buf ediff-control-buffer))
2609 (or (eq flag 'select-only)
2610 (ediff-unselect-difference ediff-current-difference))
2612 (or (eq flag 'unselect-only)
2613 (ediff-select-difference n))
2614 (setq ediff-current-difference n)
2615 ) ; end protected section
2617 (ediff-eval-in-buffer control-buf (ediff-refresh-mode-lines))
2621 (defun ediff-read-file-name (prompt default-dir default-file)
2622 ; This is a modified version of a similar function in `emerge.el'.
2623 ; PROMPT should not have trailing ': ', so that it can be modified
2624 ; according to context.
2625 ; If default-file is set, it should be used as the default value.
2626 ; If default-dir is non-nil, use it as the default directory.
2627 ; Otherwise, use the value of Emacs' variable `default-directory.'
2629 ;; hack default-dir if it is not set
2631 (file-name-as-directory
2632 (ediff-abbreviate-file-name
2633 (expand-file-name (or default-dir
2635 (file-name-directory default-file))
2636 default-directory)))))
2638 ;; strip the directory from default-file
2640 (setq default-file (file-name-nondirectory default-file)))
2641 (if (string= default-file "")
2642 (setq default-file nil))
2645 (setq f (expand-file-name
2650 (concat " (default " default-file "):"))
2651 (t (concat " (default " default-dir "):"))))
2653 (or default-file default-dir)
2654 t ; must match, no-confirm
2655 (if default-file (file-name-directory default-file))
2659 ;; If user enters a directory name, expand the default file in that
2660 ;; directory. This allows the user to enter a directory name for the
2661 ;; B-file and diff against the default-file in that directory instead
2662 ;; of a DIRED listing!
2663 (if (and (file-directory-p f) default-file)
2664 (setq f (expand-file-name
2665 (file-name-nondirectory default-file) f)))
2668 ;; If PREFIX is given, then it is used as a prefix for the temp file
2669 ;; name. Otherwise, `ediff_' is used. If FILE is given, use this
2670 ;; file and don't create a new one.
2671 ;; On MS-DOS, make sure the prefix isn't longer than 7 characters, or
2672 ;; else `make-temp-name' isn't guaranteed to return a unique filename.
2673 ;; Also, save buffer from START to END in the file.
2674 ;; START defaults to (point-min), END to (point-max)
2675 (defun ediff-make-temp-file (buff &optional prefix given-file start end)
2676 (let ((p (or prefix "ediff"))
2678 (if (and (eq system-type 'ms-dos) (> (length p) 7))
2679 (setq p (substring p 0 7)))
2681 (setq f (concat ediff-temp-file-prefix p)
2682 f (cond (given-file)
2683 ((find-file-name-handler f 'find-file-noselect)
2684 ;; to thwart file handlers in write-region, e.g., if file
2685 ;; name ends with .Z or .gz
2686 ;; This is needed so that patches produced by ediff will
2687 ;; have more meaningful names
2689 ;; Prefix is most often the same as the file name for the
2690 ;; variant. Here we are trying to use the original file name
2691 ;; but in the temp directory.
2692 ((and prefix (not (file-exists-p f))) f)
2693 ;; If a file with the orig name exists, add some random stuff
2695 (t (make-temp-name f))))
2698 (ediff-eval-in-buffer buff
2699 (write-region (if start start (point-min))
2700 (if end end (point-max))
2702 nil ; don't append---erase
2704 (set-file-modes f ediff-temp-file-mode)
2705 (ediff-convert-standard-filename (expand-file-name f)))))
2707 ;; Quote metacharacters (using \) when executing diff in Unix, but not in
2709 ;;(defun ediff-protect-metachars (str)
2710 ;; (or (memq system-type '(emx vax-vms axp-vms))
2712 ;; (while (string-match ediff-metachars str limit)
2713 ;; (setq str (concat (substring str 0 (match-beginning 0))
2715 ;; (substring str (match-beginning 0))))
2716 ;; (setq limit (1+ (match-end 0))))))
2719 ;; Make sure the current buffer (for a file) has the same contents as the
2720 ;; file on disk, and attempt to remedy the situation if not.
2721 ;; Signal an error if we can't make them the same, or the user doesn't want
2722 ;; to do what is necessary to make them the same.
2723 ;; Also, Ediff always offers to revert obsolete buffers, whether they
2724 ;; are modified or not.
2725 (defun ediff-verify-file-buffer (&optional file-magic)
2726 ;; First check if the file has been modified since the buffer visited it.
2727 (if (verify-visited-file-modtime (current-buffer))
2728 (if (buffer-modified-p)
2729 ;; If buffer is not obsolete and is modified, offer to save
2731 (format "Buffer out of sync with visited file. Save file %s? "
2737 (message "Couldn't save %s" buffer-file-name)))
2738 (error "Buffer is out of sync for file %s" buffer-file-name))
2739 ;; If buffer is not obsolete and is not modified, do nothing
2741 ;; If buffer is obsolete, offer to revert
2743 (format "Buffer is out of sync with visited file. REVERT file %s? "
2748 (revert-buffer t t))
2749 (error "Buffer out of sync for file %s" buffer-file-name))))
2752 (defun ediff-save-buffer (arg)
2753 "Safe way of saving buffers A, B, C, and the diff output.
2754 `wa' saves buffer A, `wb' saves buffer B, `wc' saves buffer C,
2755 and `wd' saves the diff output.
2757 With prefix argument, `wd' saves plain diff output.
2758 Without an argument, it saves customized diff argument, if available
2759 \(and plain output, if customized output was not generated\)."
2761 (ediff-barf-if-not-control-buffer)
2762 (ediff-compute-custom-diffs-maybe)
2763 (ediff-eval-in-buffer
2764 (cond ((memq last-command-char '(?a ?b ?c))
2766 (ediff-char-to-buftype last-command-char)))
2767 ((eq last-command-char ?d)
2768 (message "Saving diff output ...")
2769 (sit-for 1) ; let the user see the message
2770 (cond ((and arg (ediff-buffer-live-p ediff-diff-buffer))
2772 ((ediff-buffer-live-p ediff-custom-diff-buffer)
2773 ediff-custom-diff-buffer)
2774 ((ediff-buffer-live-p ediff-diff-buffer)
2776 (t (error "Output from `diff' not found"))))
2780 (defun ediff-compute-custom-diffs-maybe ()
2781 (let ((buf-A-file-name (buffer-file-name ediff-buffer-A))
2782 (buf-B-file-name (buffer-file-name ediff-buffer-B))
2784 (if (stringp buf-A-file-name)
2785 (setq buf-A-file-name (file-name-nondirectory buf-A-file-name)))
2786 (if (stringp buf-B-file-name)
2787 (setq buf-B-file-name (file-name-nondirectory buf-B-file-name)))
2788 (setq file-A (ediff-make-temp-file ediff-buffer-A buf-A-file-name)
2789 file-B (ediff-make-temp-file ediff-buffer-B buf-B-file-name))
2791 (or (ediff-buffer-live-p ediff-custom-diff-buffer)
2792 (setq ediff-custom-diff-buffer
2794 (ediff-unique-buffer-name "*ediff-custom-diff" "*"))))
2796 ediff-custom-diff-program ediff-custom-diff-buffer 'synchronize
2797 ediff-custom-diff-options file-A file-B)
2798 (delete-file file-A)
2799 (delete-file file-B)
2802 (defun ediff-show-diff-output (arg)
2804 (ediff-barf-if-not-control-buffer)
2805 (ediff-compute-custom-diffs-maybe)
2807 (ediff-skip-unsuitable-frames ' ok-unsplittable))
2808 (let ((buf (cond ((and arg (ediff-buffer-live-p ediff-diff-buffer))
2810 ((ediff-buffer-live-p ediff-custom-diff-buffer)
2811 ediff-custom-diff-buffer)
2812 ((ediff-buffer-live-p ediff-diff-buffer)
2816 (message "Output from `diff' not found")
2820 (ediff-eval-in-buffer buf
2821 (goto-char (point-min)))
2822 (switch-to-buffer buf)
2823 (raise-frame (selected-frame)))))
2824 (if (frame-live-p ediff-control-frame)
2825 (ediff-reset-mouse ediff-control-frame))
2826 (if (window-live-p ediff-control-window)
2827 (select-window ediff-control-window)))
2830 (defun ediff-inferior-compare-regions ()
2831 "Compare regions in an active Ediff session.
2832 Like ediff-regions-linewise but is called from under an active Ediff session on
2833 the files that belong to that session.
2835 After quitting the session invoked via this function, type C-l to the parent
2836 Ediff Control Panel to restore highlighting."
2839 (possibilities (list ?A ?B ?C))
2840 begA begB endA endB bufA bufB)
2842 (cond ((ediff-merge-job)
2843 (setq bufB ediff-buffer-C)
2844 (while (cond ((memq answer '(?A ?a))
2845 (setq bufA ediff-buffer-A)
2847 ((memq answer '(?B ?b))
2848 (setq bufA ediff-buffer-B)
2852 (message "Valid answers are A or B")
2855 (let ((cursor-in-echo-area t))
2856 (message "Which buffer to compare to the merge buffer (A/B)? ")
2857 (setq answer (read-char-exclusive)))))
2859 ((ediff-3way-comparison-job)
2860 (while (cond ((memq answer possibilities)
2861 (setq possibilities (delq answer possibilities))
2864 (intern (format "ediff-buffer-%c" answer))))
2869 "Valid answers are %s"
2870 (mapconcat 'char-to-string possibilities " or "))
2873 (let ((cursor-in-echo-area t))
2874 (message "Enter the 1st buffer you want to compare (%s): "
2875 (mapconcat 'char-to-string possibilities "/"))
2876 (setq answer (capitalize (read-char-exclusive)))))
2877 (setq answer "") ; silence error msg
2878 (while (cond ((memq answer possibilities)
2879 (setq possibilities (delq answer possibilities))
2882 (intern (format "ediff-buffer-%c" answer))))
2887 "Valid answers are %s"
2888 (mapconcat 'char-to-string possibilities " or "))
2891 (let ((cursor-in-echo-area t))
2892 (message "Enter the 2nd buffer you want to compare (%s): "
2893 (mapconcat 'char-to-string possibilities "/"))
2894 (setq answer (capitalize (read-char-exclusive))))))
2895 (t ; 2way comparison
2896 (setq bufA ediff-buffer-A
2897 bufB ediff-buffer-B)))
2899 (ediff-eval-in-buffer bufA
2900 (setq begA (region-beginning)
2907 (or (eobp) (forward-char)) ; include the newline char
2908 (setq endA (point)))
2909 (ediff-eval-in-buffer bufB
2910 (setq begB (region-beginning)
2917 (or (eobp) (forward-char)) ; include the newline char
2918 (setq endB (point)))
2920 (ediff-unselect-and-select-difference
2921 ediff-current-difference 'unselect-only)
2922 (ediff-paint-background-regions 'unhighlight)
2924 (ediff-regions-internal
2925 bufA begA endA bufB begB endB
2927 'ediff-regions-linewise ; job name
2933 ;; will simplify it in due time, when emacs acquires before/after strings
2934 (defun ediff-remove-flags-from-buffer (buffer overlay)
2935 (ediff-eval-in-buffer buffer
2936 (let ((inhibit-read-only t))
2938 (ediff-overlay-put overlay 'begin-glyph nil)
2939 ;; before-string is not yet implemented in emacs.
2940 ;; when it will be, I will be able to delete much of the rest of
2942 (ediff-overlay-put overlay 'before-string nil))
2945 (ediff-overlay-put overlay 'end-glyph nil)
2946 ;; after-string is not yet implemented in emacs.
2947 (ediff-overlay-put overlay 'after-string nil))
2952 ;; will simplify it in due time, when emacs acquires before/after strings
2953 (defun ediff-place-flags-in-buffer (buf-type buffer ctl-buffer diff)
2954 (ediff-eval-in-buffer buffer
2955 (ediff-place-flags-in-buffer1 buf-type ctl-buffer diff)))
2958 (defun ediff-place-flags-in-buffer1 (buf-type ctl-buffer diff-no)
2959 (let* ((curr-overl (ediff-eval-in-buffer ctl-buffer
2960 (ediff-get-diff-overlay diff-no buf-type)))
2961 (before (ediff-get-diff-posn buf-type 'beg diff-no ctl-buffer))
2962 after beg-of-line flag)
2964 ;; insert flag before the difference
2966 (setq beg-of-line (bolp))
2968 (setq flag (ediff-eval-in-buffer ctl-buffer
2969 (if (eq ediff-highlighting-style 'ascii)
2971 ediff-before-flag-bol ediff-before-flag-mol))))
2973 ;; insert the flag itself
2975 (ediff-overlay-put curr-overl 'begin-glyph flag)
2976 (ediff-overlay-put curr-overl 'before-string flag))
2978 ;; insert the flag after the difference
2979 ;; `after' must be set here, after the before-flag was inserted
2980 (setq after (ediff-get-diff-posn buf-type 'end diff-no ctl-buffer))
2982 (setq beg-of-line (bolp))
2984 (setq flag (ediff-eval-in-buffer ctl-buffer
2985 (if (eq ediff-highlighting-style 'ascii)
2987 ediff-after-flag-eol ediff-after-flag-mol))))
2989 ;; insert the flag itself
2991 (ediff-overlay-put curr-overl 'end-glyph flag)
2992 (ediff-overlay-put curr-overl 'after-string flag))
2996 ;; Returns positions of difference sectors in the BUF-TYPE buffer.
2997 ;; BUF-TYPE should be a symbol -- `A', `B', or `C'.
2998 ;; POS is either `beg' or `end'--it specifies whether you want the position at
2999 ;; the beginning of a difference or at the end.
3001 ;; The optional argument N says which difference (default:
3002 ;; `ediff-current-difference'). N is the internal difference number (1- what
3003 ;; the user sees). The optional argument CONTROL-BUF says
3004 ;; which control buffer is in effect in case it is not the current
3006 (defun ediff-get-diff-posn (buf-type pos &optional n control-buf)
3009 (setq control-buf (current-buffer)))
3011 (ediff-eval-in-buffer control-buf
3012 (or n (setq n ediff-current-difference))
3013 (if (or (< n 0) (>= n ediff-number-of-differences))
3014 (if (> ediff-number-of-differences 0)
3015 (error ediff-BAD-DIFF-NUMBER
3016 this-command (1+ n) ediff-number-of-differences)
3017 (error ediff-NO-DIFFERENCES)))
3018 (setq diff-overlay (ediff-get-diff-overlay n buf-type)))
3019 (if (not (ediff-buffer-live-p (ediff-overlay-buffer diff-overlay)))
3020 (error ediff-KILLED-VITAL-BUFFER))
3022 (ediff-overlay-start diff-overlay)
3023 (ediff-overlay-end diff-overlay))
3027 ;; Restore highlighting to what it should be according to ediff-use-faces,
3028 ;; ediff-highlighting-style, and ediff-highlight-all-diffs variables.
3029 (defun ediff-restore-highlighting (&optional ctl-buf)
3030 (ediff-eval-in-buffer (or ctl-buf (current-buffer))
3031 (if (and (ediff-has-face-support-p)
3033 ediff-highlight-all-diffs)
3034 (ediff-paint-background-regions))
3035 (ediff-select-difference ediff-current-difference)))
3039 ;; null out difference overlays so they won't slow down future
3040 ;; editing operations
3041 ;; VEC is either a difference vector or a fine-diff vector
3042 (defun ediff-clear-diff-vector (vec-var &optional fine-diffs-also)
3043 (if (vectorp (symbol-value vec-var))
3046 (ediff-delete-overlay
3047 (ediff-get-diff-overlay-from-diff-record elt))
3049 (ediff-clear-fine-diff-vector elt))
3051 (symbol-value vec-var)))
3052 ;; allow them to be garbage collected
3059 ;; In Emacs, this just makes overlay. In the future, when Emacs will start
3060 ;; supporting sticky overlays, this function will make a sticky overlay.
3061 ;; BEG and END are expressions telling where overlay starts.
3062 ;; If they are numbers or buffers, then all is well. Otherwise, they must
3063 ;; be expressions to be evaluated in buffer BUF in order to get the overlay
3065 ;; If BUFF is not a live buffer, then return nil; otherwise, return the
3066 ;; newly created overlay.
3067 (defun ediff-make-bullet-proof-overlay (beg end buff)
3068 (if (ediff-buffer-live-p buff)
3070 (ediff-eval-in-buffer buff
3071 (or (number-or-marker-p beg)
3072 (setq beg (eval beg)))
3073 (or (number-or-marker-p end)
3074 (setq end (eval end)))
3077 (make-extent beg end buff)
3078 ;; advance front and rear of the overlay
3079 (make-overlay beg end buff nil 'rear-advance)))
3083 overl (if ediff-emacs-p 'evaporate 'detachable) nil)
3084 ;; make vip-minibuffer-overlay open-ended
3085 ;; In emacs, it is made open ended at creation time
3088 (ediff-overlay-put overl 'start-open nil)
3089 (ediff-overlay-put overl 'end-open nil)))
3090 (ediff-overlay-put overl 'ediff-diff-num 0)
3093 (defsubst ediff-overlay-start (overl)
3094 (if (ediff-overlayp overl)
3096 (overlay-start overl)
3097 (extent-start-position overl))))
3099 (defsubst ediff-overlay-end (overl)
3100 (if (ediff-overlayp overl)
3103 (extent-end-position overl))))
3106 ;; Like other-buffer, but prefers visible buffers and ignores temporary or
3107 ;; other insignificant buffers (those beginning with "^[ *]").
3108 ;; Gets one arg--buffer name or a list of buffer names (it won't return
3110 (defun ediff-other-buffer (buff)
3111 (if (not (listp buff)) (setq buff (list buff)))
3112 (let* ((frame-buffers (buffer-list))
3113 (significant-buffers
3115 (function (lambda (x)
3116 (cond ((member (buffer-name x) buff)
3118 ((not (ediff-get-visible-buffer-window x))
3120 ((string-match "^ " (buffer-name x))
3124 (buffers (delq nil significant-buffers))
3125 less-significant-buffers)
3127 (cond (buffers (car buffers))
3128 ;; try also buffers that are not displayed in windows
3129 ((setq less-significant-buffers
3134 (cond ((member (buffer-name x) buff) nil)
3135 ((string-match "^[ *]" (buffer-name x)) nil)
3138 (car less-significant-buffers))
3139 (t (other-buffer (current-buffer))))
3143 ;; Construct a unique buffer name.
3144 ;; The first one tried is prefixsuffix, then prefix<2>suffix,
3145 ;; prefix<3>suffix, etc.
3146 (defun ediff-unique-buffer-name (prefix suffix)
3147 (if (null (get-buffer (concat prefix suffix)))
3148 (concat prefix suffix)
3150 (while (get-buffer (format "%s<%d>%s" prefix n suffix))
3152 (format "%s<%d>%s" prefix n suffix))))
3155 ;; splits at a white space, returns a list
3156 (defun ediff-split-string (string)
3160 (while (string-match "[ \t]+" string start)
3161 (let ((match (string-match "[ \t]+" string start)))
3162 (setq substr (substring string start match))
3163 (if (> (length substr) 0)
3164 (setq result (cons substr result)))
3165 (setq start (match-end 0))))
3166 (setq substr (substring string start nil))
3167 (if (> (length substr) 0)
3168 (setq result (cons substr result)))
3171 (defun ediff-submit-report ()
3172 "Submit bug report on Ediff."
3174 (ediff-barf-if-not-control-buffer)
3175 (let ((reporter-prompt-for-summary-p t)
3176 (ctl-buf ediff-control-buffer)
3177 (ediff-device-type (ediff-device-type))
3178 varlist salutation buffer-name)
3179 (setq varlist '(ediff-diff-program ediff-diff-options
3180 ediff-patch-program ediff-patch-options
3183 ediff-auto-refine ediff-highlighting-style
3184 ediff-buffer-A ediff-buffer-B ediff-control-buffer
3185 ediff-forward-word-function
3187 ediff-control-frame-parameters
3188 ediff-control-frame-position-function
3189 ediff-prefer-iconified-control-frame
3190 ediff-window-setup-function
3191 ediff-split-window-function
3198 Congratulations! You may have unearthed a bug in Ediff!
3200 Please make a concise and accurate summary of what happened
3201 and mail it to the address above.
3202 -----------------------------------------------------------
3205 (ediff-skip-unsuitable-frames)
3208 (switch-to-buffer ediff-msg-buffer)
3210 (delete-other-windows)
3212 Please read this first:
3213 ----------------------
3215 Some ``bugs'' may actually be no bugs at all. For instance, if you are
3216 reporting that certain difference regions are not matched as you think they
3217 should, this is most likely due to the way Unix diff program decides what
3218 constitutes a difference region. Ediff is an Emacs interface to diff, and
3219 it has nothing to do with those decisions---it only takes the output from
3220 diff and presents it in a way that is better suited for human browsing and
3223 If Emacs happens to dump core, this is NOT an Ediff problem---it is
3224 an Emacs bug. Report this to Emacs maintainers.
3226 Another popular topic for reports is compilation messages. Because Ediff
3227 interfaces to several other packages and runs under Emacs and XEmacs,
3228 byte-compilation may produce output like this:
3230 While compiling toplevel forms in file ediff.el:
3231 ** reference to free variable pm-color-alist
3232 ........................
3233 While compiling the end of the data:
3234 ** The following functions are not known to be defined:
3235 ediff-valid-color-p, ediff-set-face,
3236 ........................
3238 These are NOT errors, but inevitable warnings, which ought to be ignored.
3240 Please do not report those and similar things. However, comments and
3241 suggestions are always welcome.
3243 Mail anyway? (y or n) ")
3245 (if (y-or-n-p "Mail anyway? ")
3247 (if (ediff-buffer-live-p ctl-buf)
3248 (set-buffer ctl-buf))
3249 (setq buffer-name (buffer-name))
3251 (reporter-submit-bug-report "kifer@cs.sunysb.edu"
3255 'delete-other-windows
3258 (beep 1)(message "Bug report aborted")
3259 (if (ediff-buffer-live-p ctl-buf)
3260 (ediff-eval-in-buffer ctl-buf
3261 (ediff-recenter 'no-rehighlight))))
3265 (defun ediff-deactivate-mark ()
3267 (zmacs-deactivate-region)
3270 (cond ((fboundp 'nuke-selective-display)
3271 ;; XEmacs 19.12 has nuke-selective-display
3272 (fset 'ediff-nuke-selective-display 'nuke-selective-display))
3274 (defun ediff-nuke-selective-display ()
3278 (goto-char (point-min))
3279 (let ((mod-p (buffer-modified-p))
3280 buffer-read-only end)
3281 (and (eq t selective-display)
3282 (while (search-forward "\^M" nil t)
3286 (while (search-forward "\^M" end t)
3289 (set-buffer-modified-p mod-p)
3290 (setq selective-display nil)))))
3294 ;; The next two are modified versions from emerge.el.
3295 ;; VARS must be a list of symbols
3296 ;; ediff-save-variables returns an association list: ((var . val) ...)
3297 (defsubst ediff-save-variables (vars)
3298 (mapcar (function (lambda (v) (cons v (symbol-value v))))
3300 ;; VARS is a list of variable symbols.
3301 (defun ediff-restore-variables (vars assoc-list)
3303 (set (car vars) (cdr (assoc (car vars) assoc-list)))
3304 (setq vars (cdr vars))))
3306 (defun ediff-change-saved-variable (var value buf-type)
3308 (symbol-value (intern
3309 (concat "ediff-buffer-values-orig-"
3310 (symbol-name buf-type)))))
3311 (assoc-elt (assoc var assoc-list)))
3313 (setcdr assoc-elt value))))
3316 ;; must execute in control buf
3317 (defun ediff-save-protected-variables ()
3318 (setq ediff-buffer-values-orig-A
3319 (ediff-eval-in-buffer ediff-buffer-A
3320 (ediff-save-variables ediff-protected-variables)))
3321 (setq ediff-buffer-values-orig-B
3322 (ediff-eval-in-buffer ediff-buffer-B
3323 (ediff-save-variables ediff-protected-variables)))
3324 (if ediff-3way-comparison-job
3325 (setq ediff-buffer-values-orig-C
3326 (ediff-eval-in-buffer ediff-buffer-C
3327 (ediff-save-variables ediff-protected-variables))))
3328 (if (ediff-buffer-live-p ediff-ancestor-buffer)
3329 (setq ediff-buffer-values-orig-Ancestor
3330 (ediff-eval-in-buffer ediff-ancestor-buffer
3331 (ediff-save-variables ediff-protected-variables)))))
3333 ;; must execute in control buf
3334 (defun ediff-restore-protected-variables ()
3335 (let ((values-A ediff-buffer-values-orig-A)
3336 (values-B ediff-buffer-values-orig-B)
3337 (values-C ediff-buffer-values-orig-C)
3338 (values-Ancestor ediff-buffer-values-orig-Ancestor))
3339 (ediff-eval-in-buffer ediff-buffer-A
3340 (ediff-restore-variables ediff-protected-variables values-A))
3341 (ediff-eval-in-buffer ediff-buffer-B
3342 (ediff-restore-variables ediff-protected-variables values-B))
3343 (if ediff-3way-comparison-job
3344 (ediff-eval-in-buffer ediff-buffer-C
3345 (ediff-restore-variables ediff-protected-variables values-C)))
3346 (if (ediff-buffer-live-p ediff-ancestor-buffer)
3347 (ediff-eval-in-buffer ediff-ancestor-buffer
3348 (ediff-restore-variables ediff-protected-variables values-Ancestor)))
3351 ;; save BUFFER in FILE. used in hooks.
3352 (defun ediff-save-buffer-in-file (buffer file)
3353 (ediff-eval-in-buffer buffer
3359 (ediff-defvar-local ediff-command-begin-time '(0 0 0) "")
3361 ;; calculate time used by command
3362 (defun ediff-calc-command-time ()
3363 (let ((end (current-time))
3366 (if (>= (nth 2 end) (nth 2 ediff-command-begin-time))
3367 (- (nth 2 end) (nth 2 ediff-command-begin-time))
3368 (+ (nth 2 end) (- 1000000 (nth 2 ediff-command-begin-time)))))
3369 (setq sec (- (nth 1 end) (nth 1 ediff-command-begin-time)))
3370 (or (equal ediff-command-begin-time '(0 0 0))
3371 (message "Elapsed time: %d second(s) + %d microsecond(s)" sec micro))))
3373 (defsubst ediff-save-time ()
3374 (setq ediff-command-begin-time (current-time)))
3376 (defun ediff-profile ()
3377 "Toggle profiling Ediff commands."
3379 (ediff-barf-if-not-control-buffer)
3380 (make-local-hook 'post-command-hook)
3381 (let ((pre-hook 'pre-command-hook)
3382 (post-hook 'post-command-hook))
3383 (if (not (equal ediff-command-begin-time '(0 0 0)))
3384 (progn (remove-hook pre-hook 'ediff-save-time)
3385 (remove-hook post-hook 'ediff-calc-command-time)
3386 (setq ediff-command-begin-time '(0 0 0))
3387 (message "Ediff profiling disabled"))
3388 (add-hook pre-hook 'ediff-save-time t t)
3389 (add-hook post-hook 'ediff-calc-command-time nil t)
3390 (message "Ediff profiling enabled"))))
3392 (defun ediff-print-diff-vector (diff-vector-var)
3393 (princ (format "\n*** %S ***\n" diff-vector-var))
3398 "Diff %d: \tOverlay: %S
3400 \t\tNo-fine-diff-flag: %S
3401 \t\tState-of-diff:\t %S
3402 \t\tState-of-merge:\t %S
3404 (1+ (ediff-overlay-get (aref overl-vec 0) 'ediff-diff-num))
3407 (if (= (length (aref overl-vec 1)) 0)
3409 (mapconcat 'prin1-to-string
3410 (aref overl-vec 1) "\n\t\t\t "))
3411 (aref overl-vec 2) ; no fine diff flag
3412 (aref overl-vec 3) ; state-of-diff
3413 (aref overl-vec 4) ; state-of-merge
3415 (eval diff-vector-var)))
3419 (defun ediff-debug-info ()
3421 (ediff-barf-if-not-control-buffer)
3422 (with-output-to-temp-buffer ediff-debug-buffer
3423 (princ (format "\nCtl buffer: %S\n" ediff-control-buffer))
3424 (ediff-print-diff-vector (intern "ediff-difference-vector-A"))
3425 (ediff-print-diff-vector (intern "ediff-difference-vector-B"))
3426 (ediff-print-diff-vector (intern "ediff-difference-vector-C"))
3427 (ediff-print-diff-vector (intern "ediff-difference-vector-Ancestor"))
3431 ;;; General utilities
3433 ;; this uses comparison-func to decide who is a member
3434 (defun ediff-member (elt lis comparison-func)
3435 (while (and lis (not (funcall comparison-func (car lis) elt)))
3436 (setq lis (cdr lis)))
3439 ;; this uses comparison-func to decide who is a member, and this determines how
3440 ;; intersection looks like
3441 (defun ediff-intersection (lis1 lis2 comparison-func)
3442 (let ((result (list 'a)))
3444 (if (ediff-member (car lis1) lis2 comparison-func)
3445 (nconc result (list (car lis1))))
3446 (setq lis1 (cdr lis1)))
3450 ;; eliminates duplicates using comparison-func
3451 (defun ediff-union (lis1 lis2 comparison-func)
3452 (let ((result (list 'a)))
3454 (or (ediff-member (car lis1) (cdr result) comparison-func)
3455 (nconc result (list (car lis1))))
3456 (setq lis1 (cdr lis1)))
3458 (or (ediff-member (car lis2) (cdr result) comparison-func)
3459 (nconc result (list (car lis2))))
3460 (setq lis2 (cdr lis2)))
3463 ;; eliminates duplicates using comparison-func
3464 (defun ediff-set-difference (lis1 lis2 comparison-func)
3465 (let ((result (list 'a)))
3467 (or (ediff-member (car lis1) (cdr result) comparison-func)
3468 (ediff-member (car lis1) lis2 comparison-func)
3469 (nconc result (list (car lis1))))
3470 (setq lis1 (cdr lis1)))
3473 (defun ediff-copy-list (list)
3476 ;;; (while (consp list) (push (pop list) res))
3477 ;;; (prog1 (nreverse res) (setcdr res list)))
3480 (setq elt (car list)
3487 ;; don't report error if version control package wasn't found
3488 ;;(ediff-load-version-control 'silent)
3490 (run-hooks 'ediff-load-hook)
3493 ;;; Local Variables:
3494 ;;; eval: (put 'ediff-defvar-local 'lisp-indent-hook 'defun)
3495 ;;; eval: (put 'ediff-eval-in-buffer 'lisp-indent-hook 1)
3496 ;;; eval: (put 'ediff-eval-in-buffer 'edebug-form-spec '(form body))
3499 (provide 'ediff-util)
3501 ;;; ediff-util.el ends here