Update copyright year to 2014 by running admin/update-copyright.
[emacs.git] / lisp / vc / ediff-util.el
blob127e6b2cfc056a8a6ef21be52bddc4545aeff718
1 ;;; ediff-util.el --- the core commands and utilities of ediff
3 ;; Copyright (C) 1994-2014 Free Software Foundation, Inc.
5 ;; Author: Michael Kifer <kifer@cs.stonybrook.edu>
6 ;; Package: ediff
8 ;; This file is part of GNU Emacs.
10 ;; GNU Emacs is free software: you can redistribute it and/or modify
11 ;; it under the terms of the GNU General Public License as published by
12 ;; the Free Software Foundation, either version 3 of the License, or
13 ;; (at your option) any later version.
15 ;; GNU Emacs is distributed in the hope that it will be useful,
16 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
17 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 ;; GNU General Public License for more details.
20 ;; You should have received a copy of the GNU General Public License
21 ;; along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>.
23 ;;; Commentary:
25 ;;; Code:
28 (provide 'ediff-util)
30 ;; Compiler pacifier
31 (defvar ediff-use-toolbar-p)
32 (defvar ediff-toolbar-height)
33 (defvar ediff-toolbar)
34 (defvar ediff-toolbar-3way)
35 (defvar bottom-toolbar)
36 (defvar bottom-toolbar-visible-p)
37 (defvar bottom-toolbar-height)
38 (defvar mark-active)
40 (defvar ediff-after-quit-hook-internal nil)
42 (eval-and-compile
43 (unless (fboundp 'declare-function) (defmacro declare-function (&rest _r))))
45 ;; end pacifier
48 (require 'ediff-init)
49 (require 'ediff-help)
50 (require 'ediff-mult)
51 (require 'ediff-wind)
52 (require 'ediff-diff)
53 (require 'ediff-merg)
54 ;; for compatibility with current stable version of xemacs
55 (if (featurep 'xemacs)
56 (require 'ediff-tbar))
59 ;;; Functions
61 (defun ediff-mode ()
62 "Ediff mode controls all operations in a single Ediff session.
63 This mode is entered through one of the following commands:
64 `ediff'
65 `ediff-files'
66 `ediff-buffers'
67 `ebuffers'
68 `ediff3'
69 `ediff-files3'
70 `ediff-buffers3'
71 `ebuffers3'
72 `ediff-merge'
73 `ediff-merge-files'
74 `ediff-merge-files-with-ancestor'
75 `ediff-merge-buffers'
76 `ediff-merge-buffers-with-ancestor'
77 `ediff-merge-revisions'
78 `ediff-merge-revisions-with-ancestor'
79 `ediff-windows-wordwise'
80 `ediff-windows-linewise'
81 `ediff-regions-wordwise'
82 `ediff-regions-linewise'
83 `epatch'
84 `ediff-patch-file'
85 `ediff-patch-buffer'
86 `epatch-buffer'
87 `erevision'
88 `ediff-revision'
90 Commands:
91 \\{ediff-mode-map}"
92 ;; FIXME: Use define-derived-mode.
93 (kill-all-local-variables)
94 (setq major-mode 'ediff-mode)
95 (setq mode-name "Ediff")
96 ;; We use run-hooks instead of run-mode-hooks for two reasons.
97 ;; The ediff control buffer is read-only and it is not supposed to be
98 ;; modified by minor modes and such. So, run-mode-hooks doesn't do anything
99 ;; useful here on top of what run-hooks does.
100 ;; Second, changing run-hooks to run-mode-hooks would require an
101 ;; if-statement, since XEmacs doesn't have this.
102 (run-hooks 'ediff-mode-hook))
106 ;;; Build keymaps
108 (ediff-defvar-local ediff-mode-map nil
109 "Local keymap used in Ediff mode.
110 This is local to each Ediff Control Panel, so they may vary from invocation
111 to invocation.")
113 ;; Set up the keymap in the control buffer
114 (defun ediff-set-keys ()
115 "Set up Ediff keymap, if necessary."
116 (if (null ediff-mode-map)
117 (ediff-setup-keymap))
118 (use-local-map ediff-mode-map))
120 ;; Reload Ediff keymap. For debugging only.
121 (defun ediff-reload-keymap ()
122 (interactive)
123 (setq ediff-mode-map nil)
124 (ediff-set-keys))
127 (defun ediff-setup-keymap ()
128 "Set up the keymap used in the control buffer of Ediff."
129 (setq ediff-mode-map (make-sparse-keymap))
130 (suppress-keymap ediff-mode-map)
132 (define-key ediff-mode-map
133 (if (featurep 'emacs) [mouse-2] [button2]) 'ediff-help-for-quick-help)
134 (define-key ediff-mode-map "\C-m" 'ediff-help-for-quick-help)
136 (define-key ediff-mode-map "p" 'ediff-previous-difference)
137 (define-key ediff-mode-map "\C-?" 'ediff-previous-difference)
138 (define-key ediff-mode-map [delete] 'ediff-previous-difference)
139 (define-key ediff-mode-map "\C-h" (if ediff-no-emacs-help-in-control-buffer
140 'ediff-previous-difference nil))
141 ;; must come after C-h, or else C-h wipes out backspace's binding in XEmacs
142 (define-key ediff-mode-map [backspace] 'ediff-previous-difference)
143 (define-key ediff-mode-map [?\S-\ ] 'ediff-previous-difference)
144 (define-key ediff-mode-map "n" 'ediff-next-difference)
145 (define-key ediff-mode-map " " 'ediff-next-difference)
146 (define-key ediff-mode-map "j" 'ediff-jump-to-difference)
147 (define-key ediff-mode-map "g" nil)
148 (define-key ediff-mode-map "ga" 'ediff-jump-to-difference-at-point)
149 (define-key ediff-mode-map "gb" 'ediff-jump-to-difference-at-point)
150 (define-key ediff-mode-map "q" 'ediff-quit)
151 (define-key ediff-mode-map "D" 'ediff-show-diff-output)
152 (define-key ediff-mode-map "z" 'ediff-suspend)
153 (define-key ediff-mode-map "\C-l" 'ediff-recenter)
154 (define-key ediff-mode-map "|" 'ediff-toggle-split)
155 (define-key ediff-mode-map "h" 'ediff-toggle-hilit)
156 (or ediff-word-mode
157 (define-key ediff-mode-map "@" 'ediff-toggle-autorefine))
158 (if ediff-narrow-job
159 (define-key ediff-mode-map "%" 'ediff-toggle-narrow-region))
160 (define-key ediff-mode-map "~" 'ediff-swap-buffers)
161 (define-key ediff-mode-map "v" 'ediff-scroll-vertically)
162 (define-key ediff-mode-map "\C-v" 'ediff-scroll-vertically)
163 (define-key ediff-mode-map "^" 'ediff-scroll-vertically)
164 (define-key ediff-mode-map "\M-v" 'ediff-scroll-vertically)
165 (define-key ediff-mode-map "V" 'ediff-scroll-vertically)
166 (define-key ediff-mode-map "<" 'ediff-scroll-horizontally)
167 (define-key ediff-mode-map ">" 'ediff-scroll-horizontally)
168 (define-key ediff-mode-map "i" 'ediff-status-info)
169 (define-key ediff-mode-map "E" 'ediff-documentation)
170 (define-key ediff-mode-map "?" 'ediff-toggle-help)
171 (define-key ediff-mode-map "!" 'ediff-update-diffs)
172 (define-key ediff-mode-map "M" 'ediff-show-current-session-meta-buffer)
173 (define-key ediff-mode-map "R" 'ediff-show-registry)
174 (or ediff-word-mode
175 (define-key ediff-mode-map "*" 'ediff-make-or-kill-fine-diffs))
176 (define-key ediff-mode-map "a" nil)
177 (define-key ediff-mode-map "b" nil)
178 (define-key ediff-mode-map "r" nil)
179 (cond (ediff-merge-job
180 ;; Will barf if no ancestor
181 (define-key ediff-mode-map "/" 'ediff-show-ancestor)
182 ;; In merging, we allow only A->C and B->C copying.
183 (define-key ediff-mode-map "a" 'ediff-copy-A-to-C)
184 (define-key ediff-mode-map "b" 'ediff-copy-B-to-C)
185 (define-key ediff-mode-map "r" 'ediff-restore-diff-in-merge-buffer)
186 (define-key ediff-mode-map "s" 'ediff-shrink-window-C)
187 (define-key ediff-mode-map "+" 'ediff-combine-diffs)
188 (define-key ediff-mode-map "$" nil)
189 (define-key ediff-mode-map "$$" 'ediff-toggle-show-clashes-only)
190 (define-key ediff-mode-map "$*" 'ediff-toggle-skip-changed-regions)
191 (define-key ediff-mode-map "&" 'ediff-re-merge))
192 (ediff-3way-comparison-job
193 (define-key ediff-mode-map "ab" 'ediff-copy-A-to-B)
194 (define-key ediff-mode-map "ba" 'ediff-copy-B-to-A)
195 (define-key ediff-mode-map "ac" 'ediff-copy-A-to-C)
196 (define-key ediff-mode-map "bc" 'ediff-copy-B-to-C)
197 (define-key ediff-mode-map "c" nil)
198 (define-key ediff-mode-map "ca" 'ediff-copy-C-to-A)
199 (define-key ediff-mode-map "cb" 'ediff-copy-C-to-B)
200 (define-key ediff-mode-map "ra" 'ediff-restore-diff)
201 (define-key ediff-mode-map "rb" 'ediff-restore-diff)
202 (define-key ediff-mode-map "rc" 'ediff-restore-diff)
203 (define-key ediff-mode-map "C" 'ediff-toggle-read-only))
204 (t ; 2-way comparison
205 (define-key ediff-mode-map "a" 'ediff-copy-A-to-B)
206 (define-key ediff-mode-map "b" 'ediff-copy-B-to-A)
207 (define-key ediff-mode-map "ra" 'ediff-restore-diff)
208 (define-key ediff-mode-map "rb" 'ediff-restore-diff))
209 ) ; cond
210 (define-key ediff-mode-map "G" 'ediff-submit-report)
211 (define-key ediff-mode-map "#" nil)
212 (define-key ediff-mode-map "#h" 'ediff-toggle-regexp-match)
213 (define-key ediff-mode-map "#f" 'ediff-toggle-regexp-match)
214 (define-key ediff-mode-map "#c" 'ediff-toggle-ignore-case)
215 (or ediff-word-mode
216 (define-key ediff-mode-map "##" 'ediff-toggle-skip-similar))
217 (define-key ediff-mode-map "o" nil)
218 (define-key ediff-mode-map "A" 'ediff-toggle-read-only)
219 (define-key ediff-mode-map "B" 'ediff-toggle-read-only)
220 (define-key ediff-mode-map "w" nil)
221 (define-key ediff-mode-map "wa" 'ediff-save-buffer)
222 (define-key ediff-mode-map "wb" 'ediff-save-buffer)
223 (define-key ediff-mode-map "wd" 'ediff-save-buffer)
224 (define-key ediff-mode-map "=" 'ediff-inferior-compare-regions)
225 (if (and (fboundp 'ediff-show-patch-diagnostics) (ediff-patch-job))
226 (define-key ediff-mode-map "P" 'ediff-show-patch-diagnostics))
227 (if ediff-3way-job
228 (progn
229 (define-key ediff-mode-map "wc" 'ediff-save-buffer)
230 (define-key ediff-mode-map "gc" 'ediff-jump-to-difference-at-point)
233 (define-key ediff-mode-map "m" 'ediff-toggle-wide-display)
235 ;; Allow ediff-mode-map to be referenced indirectly
236 (fset 'ediff-mode-map ediff-mode-map)
237 (run-hooks 'ediff-keymap-setup-hook))
240 ;;; Setup functions
242 ;; Common startup entry for all Ediff functions It now returns control buffer
243 ;; so other functions can do post-processing SETUP-PARAMETERS is a list of the
244 ;; form ((param .val) (param . val)...) This serves a similar purpose to
245 ;; STARTUP-HOOKS, but these parameters are set in the new control buffer right
246 ;; after this buf is created and before any windows are set and such.
247 (defun ediff-setup (buffer-A file-A buffer-B file-B buffer-C file-C
248 startup-hooks setup-parameters
249 &optional merge-buffer-file)
250 (run-hooks 'ediff-before-setup-hook)
251 ;; ediff-convert-standard-filename puts file names in the form appropriate
252 ;; for the OS at hand.
253 (setq file-A (ediff-convert-standard-filename (expand-file-name file-A)))
254 (setq file-B (ediff-convert-standard-filename (expand-file-name file-B)))
255 (if (stringp file-C)
256 (setq file-C
257 (ediff-convert-standard-filename (expand-file-name file-C))))
258 (if (stringp merge-buffer-file)
259 (progn
260 (setq merge-buffer-file
261 (ediff-convert-standard-filename
262 (expand-file-name merge-buffer-file)))
263 ;; check the directory exists
264 (or (file-exists-p (file-name-directory merge-buffer-file))
265 (error "Directory %s given as place to save the merge doesn't exist"
266 (abbreviate-file-name
267 (file-name-directory merge-buffer-file))))
268 (if (and (file-exists-p merge-buffer-file)
269 (file-directory-p merge-buffer-file))
270 (error "The merge buffer file %s must not be a directory"
271 (abbreviate-file-name merge-buffer-file)))
273 (let* ((control-buffer-name
274 (ediff-unique-buffer-name "*Ediff Control Panel" "*"))
275 (control-buffer (ediff-with-current-buffer buffer-A
276 (get-buffer-create control-buffer-name))))
277 (ediff-with-current-buffer control-buffer
278 (ediff-mode)
280 (make-local-variable 'ediff-use-long-help-message)
281 (make-local-variable 'ediff-prefer-iconified-control-frame)
282 (make-local-variable 'ediff-split-window-function)
283 (make-local-variable 'ediff-default-variant)
284 (make-local-variable 'ediff-merge-window-share)
285 (make-local-variable 'ediff-window-setup-function)
286 (make-local-variable 'ediff-keep-variants)
288 (make-local-variable 'window-min-height)
289 (setq window-min-height 2)
291 (if (featurep 'xemacs)
292 (make-local-hook 'ediff-after-quit-hook-internal))
294 ;; unwrap set up parameters passed as argument
295 (while setup-parameters
296 (set (car (car setup-parameters)) (cdr (car setup-parameters)))
297 (setq setup-parameters (cdr setup-parameters)))
299 ;; set variables classifying the current ediff job
300 ;; must come AFTER setup-parameters
301 (setq ediff-3way-comparison-job (ediff-3way-comparison-job)
302 ediff-merge-job (ediff-merge-job)
303 ediff-merge-with-ancestor-job (ediff-merge-with-ancestor-job)
304 ediff-3way-job (ediff-3way-job)
305 ediff-diff3-job (ediff-diff3-job)
306 ediff-narrow-job (ediff-narrow-job)
307 ediff-windows-job (ediff-windows-job)
308 ediff-word-mode-job (ediff-word-mode-job))
310 ;; Don't delete variants in case of ediff-buffer-* jobs without asking.
311 ;; This is because one may lose work---dangerous.
312 (if (string-match "buffer" (symbol-name ediff-job-name))
313 (setq ediff-keep-variants t))
315 (if (featurep 'xemacs)
316 (make-local-hook 'pre-command-hook))
318 (if (ediff-window-display-p)
319 (add-hook 'pre-command-hook 'ediff-spy-after-mouse nil 'local))
320 (setq ediff-mouse-pixel-position (mouse-pixel-position))
322 ;; adjust for merge jobs
323 (if ediff-merge-job
324 (let ((buf
325 ;; If default variant is `combined', the right stuff is
326 ;; inserted by ediff-do-merge
327 ;; Note: at some point, we tried to put ancestor buffer here
328 ;; (which is currently buffer C. This didn't work right
329 ;; because the merge buffer will contain lossage: diff regions
330 ;; in the ancestor, which correspond to revisions that agree
331 ;; in both buf A and B.
332 (cond ((eq ediff-default-variant 'default-B)
333 buffer-B)
334 (t buffer-A))))
336 (setq ediff-split-window-function
337 ediff-merge-split-window-function)
339 ;; remember the ancestor buffer, if any
340 (setq ediff-ancestor-buffer buffer-C)
342 (setq buffer-C
343 (get-buffer-create
344 (ediff-unique-buffer-name "*ediff-merge" "*")))
345 (with-current-buffer buffer-C
346 (insert-buffer-substring buf)
347 (goto-char (point-min))
348 (funcall (ediff-with-current-buffer buf major-mode))
349 (widen) ; merge buffer is always widened
350 (add-hook 'local-write-file-hooks 'ediff-set-merge-mode nil t)
352 (setq buffer-read-only nil
353 ediff-buffer-A buffer-A
354 ediff-buffer-B buffer-B
355 ediff-buffer-C buffer-C
356 ediff-control-buffer control-buffer)
358 (ediff-choose-syntax-table)
360 (setq ediff-control-buffer-suffix
361 (if (string-match "<[0-9]*>" control-buffer-name)
362 (substring control-buffer-name
363 (match-beginning 0) (match-end 0))
365 ediff-control-buffer-number
366 (max
369 (string-to-number
370 (substring
371 ediff-control-buffer-suffix
373 (string-match "[0-9]+" ediff-control-buffer-suffix)
374 0))))))
376 (setq ediff-error-buffer
377 (get-buffer-create (ediff-unique-buffer-name "*ediff-errors" "*")))
379 (with-current-buffer ediff-error-buffer
380 (setq buffer-undo-list t))
382 (ediff-with-current-buffer buffer-A (ediff-strip-mode-line-format))
383 (ediff-with-current-buffer buffer-B (ediff-strip-mode-line-format))
384 (if ediff-3way-job
385 (ediff-with-current-buffer buffer-C (ediff-strip-mode-line-format)))
386 (if (ediff-buffer-live-p ediff-ancestor-buffer)
387 (ediff-with-current-buffer ediff-ancestor-buffer
388 (ediff-strip-mode-line-format)))
390 (ediff-save-protected-variables) ; save variables to be restored on exit
392 ;; ediff-setup-diff-regions-function must be set after setup
393 ;; parameters are processed.
394 (setq ediff-setup-diff-regions-function
395 (if ediff-diff3-job
396 'ediff-setup-diff-regions3
397 'ediff-setup-diff-regions))
399 (setq ediff-wide-bounds
400 (list (ediff-make-bullet-proof-overlay
401 '(point-min) '(point-max) ediff-buffer-A)
402 (ediff-make-bullet-proof-overlay
403 '(point-min) '(point-max) ediff-buffer-B)
404 (ediff-make-bullet-proof-overlay
405 '(point-min) '(point-max) ediff-buffer-C)))
407 ;; This has effect only on ediff-windows/regions
408 ;; In all other cases, ediff-visible-region sets visibility bounds to
409 ;; ediff-wide-bounds, and ediff-narrow-bounds are ignored.
410 (if ediff-start-narrowed
411 (setq ediff-visible-bounds ediff-narrow-bounds)
412 (setq ediff-visible-bounds ediff-wide-bounds))
414 (ediff-set-keys) ; comes after parameter setup
416 ;; set up ediff-narrow-bounds, if not set
417 (or ediff-narrow-bounds
418 (setq ediff-narrow-bounds ediff-wide-bounds))
420 ;; All these must be inside ediff-with-current-buffer control-buffer,
421 ;; since these vars are local to control-buffer
422 ;; These won't run if there are errors in diff
423 (ediff-with-current-buffer ediff-buffer-A
424 (ediff-nuke-selective-display)
425 (run-hooks 'ediff-prepare-buffer-hook)
426 (if (ediff-with-current-buffer control-buffer ediff-merge-job)
427 (setq buffer-read-only t))
428 ;; add control-buffer to the list of sessions--no longer used, but may
429 ;; be used again in the future
430 (or (memq control-buffer ediff-this-buffer-ediff-sessions)
431 (setq ediff-this-buffer-ediff-sessions
432 (cons control-buffer ediff-this-buffer-ediff-sessions)))
433 (if ediff-make-buffers-readonly-at-startup
434 (setq buffer-read-only t))
437 (ediff-with-current-buffer ediff-buffer-B
438 (ediff-nuke-selective-display)
439 (run-hooks 'ediff-prepare-buffer-hook)
440 (if (ediff-with-current-buffer control-buffer ediff-merge-job)
441 (setq buffer-read-only t))
442 ;; add control-buffer to the list of sessions
443 (or (memq control-buffer ediff-this-buffer-ediff-sessions)
444 (setq ediff-this-buffer-ediff-sessions
445 (cons control-buffer ediff-this-buffer-ediff-sessions)))
446 (if ediff-make-buffers-readonly-at-startup
447 (setq buffer-read-only t))
450 (if ediff-3way-job
451 (ediff-with-current-buffer ediff-buffer-C
452 (ediff-nuke-selective-display)
453 ;; the merge buffer should never be narrowed
454 ;; (it can happen if it is on rmail-mode or similar)
455 (if (ediff-with-current-buffer control-buffer ediff-merge-job)
456 (widen))
457 (run-hooks 'ediff-prepare-buffer-hook)
458 ;; add control-buffer to the list of sessions
459 (or (memq control-buffer ediff-this-buffer-ediff-sessions)
460 (setq ediff-this-buffer-ediff-sessions
461 (cons control-buffer
462 ediff-this-buffer-ediff-sessions)))
463 (if ediff-make-buffers-readonly-at-startup
464 (setq buffer-read-only t)
465 (setq buffer-read-only nil))
468 (if (ediff-buffer-live-p ediff-ancestor-buffer)
469 (ediff-with-current-buffer ediff-ancestor-buffer
470 (ediff-nuke-selective-display)
471 (setq buffer-read-only t)
472 (run-hooks 'ediff-prepare-buffer-hook)
473 (or (memq control-buffer ediff-this-buffer-ediff-sessions)
474 (setq ediff-this-buffer-ediff-sessions
475 (cons control-buffer
476 ediff-this-buffer-ediff-sessions)))
479 ;; the following must be after setting up ediff-narrow-bounds AND after
480 ;; nuking selective display
481 (funcall ediff-setup-diff-regions-function file-A file-B file-C)
482 (setq ediff-number-of-differences (length ediff-difference-vector-A))
483 (setq ediff-current-difference -1)
485 (ediff-make-current-diff-overlay 'A)
486 (ediff-make-current-diff-overlay 'B)
487 (if ediff-3way-job
488 (ediff-make-current-diff-overlay 'C))
489 (if ediff-merge-with-ancestor-job
490 (ediff-make-current-diff-overlay 'Ancestor))
492 (ediff-setup-windows buffer-A buffer-B buffer-C control-buffer)
494 (let ((shift-A (ediff-overlay-start
495 (ediff-get-value-according-to-buffer-type
496 'A ediff-narrow-bounds)))
497 (shift-B (ediff-overlay-start
498 (ediff-get-value-according-to-buffer-type
499 'B ediff-narrow-bounds)))
500 (shift-C (ediff-overlay-start
501 (ediff-get-value-according-to-buffer-type
502 'C ediff-narrow-bounds))))
503 ;; position point in buf A
504 (save-excursion
505 (select-window ediff-window-A)
506 (goto-char shift-A))
507 ;; position point in buf B
508 (save-excursion
509 (select-window ediff-window-B)
510 (goto-char shift-B))
511 (if ediff-3way-job
512 (save-excursion
513 (select-window ediff-window-C)
514 (goto-char shift-C)))
517 (select-window ediff-control-window)
518 (ediff-visible-region)
520 (run-hooks 'startup-hooks)
521 (ediff-arrange-autosave-in-merge-jobs merge-buffer-file)
523 (ediff-refresh-mode-lines)
524 (setq buffer-read-only t)
525 (setq ediff-session-registry
526 (cons control-buffer ediff-session-registry))
527 (ediff-update-registry)
528 (if (ediff-buffer-live-p ediff-meta-buffer)
529 (ediff-update-meta-buffer
530 ediff-meta-buffer nil ediff-meta-session-number))
531 (run-hooks 'ediff-startup-hook)
532 ) ; eval in control-buffer
533 control-buffer))
536 ;; This function assumes that we are in the window where control buffer is
537 ;; to reside.
538 (defun ediff-setup-control-buffer (ctl-buf)
539 "Set up window for control buffer."
540 (if (window-dedicated-p)
541 (set-buffer ctl-buf) ; we are in control frame but just in case
542 (switch-to-buffer ctl-buf))
543 (let ((window-min-height 2))
544 (erase-buffer)
545 (ediff-set-help-message)
546 (insert ediff-help-message)
547 (shrink-window-if-larger-than-buffer)
548 (or (ediff-multiframe-setup-p)
549 (ediff-indent-help-message))
550 (ediff-set-help-overlays)
552 (set-buffer-modified-p nil)
553 (ediff-refresh-mode-lines)
554 (setq ediff-control-window (selected-window))
555 (setq ediff-window-config-saved
556 (format "%S%S%S%S%S%S%S"
557 ediff-control-window
558 ediff-window-A
559 ediff-window-B
560 ediff-window-C
561 ediff-split-window-function
562 (ediff-multiframe-setup-p)
563 ediff-wide-display-p))
565 (set-window-dedicated-p (selected-window) t)
566 ;; In multiframe, toolbar is set in ediff-setup-control-frame
567 (if (not (ediff-multiframe-setup-p))
568 (ediff-make-bottom-toolbar)) ; this checks if toolbar is requested
569 (goto-char (point-min))
570 (skip-chars-forward ediff-whitespace)))
572 ;; This executes in control buffer and sets auto-save, visited file name, etc,
573 ;; in the merge buffer
574 (defun ediff-arrange-autosave-in-merge-jobs (merge-buffer-file)
575 (if (not ediff-merge-job)
577 (if (stringp merge-buffer-file)
578 (setq ediff-autostore-merges t
579 ediff-merge-store-file merge-buffer-file))
580 (if (stringp ediff-merge-store-file)
581 (progn
582 ;; save before leaving ctl buffer
583 (ediff-verify-file-merge-buffer ediff-merge-store-file)
584 (setq merge-buffer-file ediff-merge-store-file)
585 (ediff-with-current-buffer ediff-buffer-C
586 (set-visited-file-name merge-buffer-file))))
587 (ediff-with-current-buffer ediff-buffer-C
588 (setq buffer-offer-save t) ; ask before killing buffer
589 ;; make sure the contents is auto-saved
590 (auto-save-mode 1))
594 ;;; Commands for working with Ediff
596 (defun ediff-update-diffs ()
597 "Recompute difference regions in buffers A, B, and C.
598 Buffers are not synchronized with their respective files, so changes done
599 to these buffers are not saved at this point---the user can do this later,
600 if necessary."
601 (interactive)
602 (ediff-barf-if-not-control-buffer)
603 (if (and (ediff-buffer-live-p ediff-ancestor-buffer)
604 (not
605 (y-or-n-p
606 "Ancestor buffer will not be used. Recompute diffs anyway? ")))
607 (error "Recomputation of differences canceled"))
609 (let ((point-A (ediff-with-current-buffer ediff-buffer-A (point)))
610 ;;(point-B (ediff-with-current-buffer ediff-buffer-B (point)))
611 (tmp-buffer (get-buffer-create ediff-tmp-buffer))
612 (buf-A-file-name (buffer-file-name ediff-buffer-A))
613 (buf-B-file-name (buffer-file-name ediff-buffer-B))
614 ;; (null ediff-buffer-C) is no problem, as we later check if
615 ;; ediff-buffer-C is alive
616 (buf-C-file-name (buffer-file-name ediff-buffer-C))
617 (overl-A (ediff-get-value-according-to-buffer-type
618 'A ediff-narrow-bounds))
619 (overl-B (ediff-get-value-according-to-buffer-type
620 'B ediff-narrow-bounds))
621 (overl-C (ediff-get-value-according-to-buffer-type
622 'C ediff-narrow-bounds))
623 beg-A end-A beg-B end-B beg-C end-C
624 file-A file-B file-C)
626 (if (stringp buf-A-file-name)
627 (setq buf-A-file-name (file-name-nondirectory buf-A-file-name)))
628 (if (stringp buf-B-file-name)
629 (setq buf-B-file-name (file-name-nondirectory buf-B-file-name)))
630 (if (stringp buf-C-file-name)
631 (setq buf-C-file-name (file-name-nondirectory buf-C-file-name)))
633 (ediff-unselect-and-select-difference -1)
635 (setq beg-A (ediff-overlay-start overl-A)
636 beg-B (ediff-overlay-start overl-B)
637 beg-C (ediff-overlay-start overl-C)
638 end-A (ediff-overlay-end overl-A)
639 end-B (ediff-overlay-end overl-B)
640 end-C (ediff-overlay-end overl-C))
642 (if ediff-word-mode
643 (progn
644 (ediff-wordify beg-A end-A ediff-buffer-A tmp-buffer)
645 (setq file-A (ediff-make-temp-file tmp-buffer "regA"))
646 (ediff-wordify beg-B end-B ediff-buffer-B tmp-buffer)
647 (setq file-B (ediff-make-temp-file tmp-buffer "regB"))
648 (if ediff-3way-job
649 (progn
650 (ediff-wordify beg-C end-C ediff-buffer-C tmp-buffer)
651 (setq file-C (ediff-make-temp-file tmp-buffer "regC"))))
653 ;; not word-mode
654 (setq file-A (ediff-make-temp-file ediff-buffer-A buf-A-file-name))
655 (setq file-B (ediff-make-temp-file ediff-buffer-B buf-B-file-name))
656 (if ediff-3way-job
657 (setq file-C (ediff-make-temp-file ediff-buffer-C buf-C-file-name)))
660 (ediff-clear-diff-vector 'ediff-difference-vector-A 'fine-diffs-also)
661 (ediff-clear-diff-vector 'ediff-difference-vector-B 'fine-diffs-also)
662 (ediff-clear-diff-vector 'ediff-difference-vector-C 'fine-diffs-also)
663 (ediff-clear-diff-vector
664 'ediff-difference-vector-Ancestor 'fine-diffs-also)
665 ;; let them garbage collect. we can't use the ancestor after recomputing
666 ;; the diffs.
667 (setq ediff-difference-vector-Ancestor nil
668 ediff-ancestor-buffer nil
669 ediff-state-of-merge nil)
671 (setq ediff-killed-diffs-alist nil) ; invalidate saved killed diff regions
673 ;; In case of merge job, fool it into thinking that it is just doing
674 ;; comparison
675 (let ((ediff-setup-diff-regions-function ediff-setup-diff-regions-function)
676 (ediff-3way-comparison-job ediff-3way-comparison-job)
677 (ediff-merge-job ediff-merge-job)
678 (ediff-merge-with-ancestor-job ediff-merge-with-ancestor-job)
679 (ediff-job-name ediff-job-name))
680 (if ediff-merge-job
681 (setq ediff-setup-diff-regions-function 'ediff-setup-diff-regions3
682 ediff-3way-comparison-job t
683 ediff-merge-job nil
684 ediff-merge-with-ancestor-job nil
685 ediff-job-name 'ediff-files3))
686 (funcall ediff-setup-diff-regions-function file-A file-B file-C))
688 (setq ediff-number-of-differences (length ediff-difference-vector-A))
689 (delete-file file-A)
690 (delete-file file-B)
691 (if file-C
692 (delete-file file-C))
694 (if ediff-3way-job
695 (ediff-set-state-of-all-diffs-in-all-buffers ediff-control-buffer))
697 (ediff-jump-to-difference (ediff-diff-at-point 'A point-A))
698 (message "")
701 ;; Not bound to any key---to dangerous. A user can do it if necessary.
702 (defun ediff-revert-buffers-then-recompute-diffs (noconfirm)
703 "Revert buffers A, B and C. Then rerun Ediff on file A and file B."
704 (interactive "P")
705 (ediff-barf-if-not-control-buffer)
706 (let ((bufA ediff-buffer-A)
707 (bufB ediff-buffer-B)
708 (bufC ediff-buffer-C)
709 (ctl-buf ediff-control-buffer)
710 (keep-variants ediff-keep-variants)
711 (ancestor-buf ediff-ancestor-buffer)
712 (ancestor-job ediff-merge-with-ancestor-job)
713 (merge ediff-merge-job)
714 (comparison ediff-3way-comparison-job))
715 (ediff-with-current-buffer bufA
716 (revert-buffer t noconfirm))
717 (ediff-with-current-buffer bufB
718 (revert-buffer t noconfirm))
719 ;; this should only be executed in a 3way comparison, not in merge
720 (if comparison
721 (ediff-with-current-buffer bufC
722 (revert-buffer t noconfirm)))
723 (if merge
724 (progn
725 (set-buffer ctl-buf)
726 ;; the argument says whether to reverse the meaning of
727 ;; ediff-keep-variants, i.e., ediff-really-quit runs here with
728 ;; variants kept.
729 (ediff-really-quit (not keep-variants))
730 (kill-buffer bufC)
731 (if ancestor-job
732 (ediff-merge-buffers-with-ancestor bufA bufB ancestor-buf)
733 (ediff-merge-buffers bufA bufB)))
734 (ediff-update-diffs))))
737 ;; optional NO-REHIGHLIGHT says to not rehighlight buffers
738 (defun ediff-recenter (&optional no-rehighlight)
739 "Bring the highlighted region of all buffers being compared into view.
740 Reestablish the default three-window display."
741 (interactive)
742 (ediff-barf-if-not-control-buffer)
743 (let (buffer-read-only)
744 (if (and (ediff-buffer-live-p ediff-buffer-A)
745 (ediff-buffer-live-p ediff-buffer-B)
746 (or (not ediff-3way-job)
747 (ediff-buffer-live-p ediff-buffer-C)))
748 (ediff-setup-windows
749 ediff-buffer-A ediff-buffer-B ediff-buffer-C ediff-control-buffer)
750 (or (eq this-command 'ediff-quit)
751 (message ediff-KILLED-VITAL-BUFFER
752 (beep 1)))
755 ;; set visibility range appropriate to this invocation of Ediff.
756 (ediff-visible-region)
757 ;; raise
758 (if (and (ediff-window-display-p)
759 (symbolp this-command)
760 (symbolp last-command)
761 ;; Either one of the display-changing commands
762 (or (memq this-command
763 '(ediff-recenter
764 ediff-dir-action ediff-registry-action
765 ediff-patch-action
766 ediff-toggle-wide-display ediff-toggle-multiframe))
767 ;; Or one of the movement cmds and prev cmd was an Ediff cmd
768 ;; This avoids raising frames unnecessarily.
769 (and (memq this-command
770 '(ediff-next-difference
771 ediff-previous-difference
772 ediff-jump-to-difference
773 ediff-jump-to-difference-at-point))
774 (not (string-match "^ediff-" (symbol-name last-command)))
776 (progn
777 (if (window-live-p ediff-window-A)
778 (raise-frame (window-frame ediff-window-A)))
779 (if (window-live-p ediff-window-B)
780 (raise-frame (window-frame ediff-window-B)))
781 (if (window-live-p ediff-window-C)
782 (raise-frame (window-frame ediff-window-C)))))
783 (if (and (ediff-window-display-p)
784 (frame-live-p ediff-control-frame)
785 (not ediff-use-long-help-message)
786 (not (ediff-frame-iconified-p ediff-control-frame)))
787 (if (fboundp 'select-frame-set-input-focus)
788 (select-frame-set-input-focus ediff-control-frame)
789 (raise-frame ediff-control-frame)
790 (select-frame ediff-control-frame)
791 (if (fboundp 'focus-frame)
792 (focus-frame ediff-control-frame))))
794 ;; Redisplay whatever buffers are showing, if there is a selected difference
795 (let ((control-frame ediff-control-frame)
796 (control-buf ediff-control-buffer))
797 (if (and (ediff-buffer-live-p ediff-buffer-A)
798 (ediff-buffer-live-p ediff-buffer-B)
799 (or (not ediff-3way-job)
800 (ediff-buffer-live-p ediff-buffer-C)))
801 (progn
802 (or no-rehighlight
803 (ediff-select-difference ediff-current-difference))
805 (ediff-recenter-one-window 'A)
806 (ediff-recenter-one-window 'B)
807 (if ediff-3way-job
808 (ediff-recenter-one-window 'C))
810 (ediff-with-current-buffer control-buf
811 (ediff-recenter-ancestor) ; check if ancestor is alive
813 (if (and (ediff-multiframe-setup-p)
814 (not ediff-use-long-help-message)
815 (not (ediff-frame-iconified-p ediff-control-frame)))
816 ;; never grab mouse on quit in this place
817 (ediff-reset-mouse
818 control-frame
819 (eq this-command 'ediff-quit))))
822 (or no-rehighlight
823 (ediff-restore-highlighting))
824 (ediff-with-current-buffer control-buf (ediff-refresh-mode-lines))
827 ;; this function returns to the window it was called from
828 ;; (which was the control window)
829 (defun ediff-recenter-one-window (buf-type)
830 (if (ediff-valid-difference-p)
831 ;; context must be saved before switching to windows A/B/C
832 (let* ((ctl-wind (selected-window))
833 (shift (ediff-overlay-start
834 (ediff-get-value-according-to-buffer-type
835 buf-type ediff-narrow-bounds)))
836 (job-name ediff-job-name)
837 (control-buf ediff-control-buffer)
838 (window-name (ediff-get-symbol-from-alist
839 buf-type ediff-window-alist))
840 (window (if (window-live-p (symbol-value window-name))
841 (symbol-value window-name))))
843 (if (and window ediff-windows-job)
844 (set-window-start window shift))
845 (if window
846 (progn
847 (select-window window)
848 (ediff-deactivate-mark)
849 (ediff-position-region
850 (ediff-get-diff-posn buf-type 'beg nil control-buf)
851 (ediff-get-diff-posn buf-type 'end nil control-buf)
852 (ediff-get-diff-posn buf-type 'beg nil control-buf)
853 job-name
855 (select-window ctl-wind)
858 (defun ediff-recenter-ancestor ()
859 ;; do half-hearted job by recentering the ancestor buffer, if it is alive and
860 ;; visible.
861 (if (and (ediff-buffer-live-p ediff-ancestor-buffer)
862 (ediff-valid-difference-p))
863 (let ((window (ediff-get-visible-buffer-window ediff-ancestor-buffer))
864 (ctl-wind (selected-window))
865 (job-name ediff-job-name)
866 (ctl-buf ediff-control-buffer))
867 (ediff-with-current-buffer ediff-ancestor-buffer
868 (goto-char (ediff-get-diff-posn 'Ancestor 'beg nil ctl-buf))
869 (if window
870 (progn
871 (select-window window)
872 (ediff-position-region
873 (ediff-get-diff-posn 'Ancestor 'beg nil ctl-buf)
874 (ediff-get-diff-posn 'Ancestor 'end nil ctl-buf)
875 (ediff-get-diff-posn 'Ancestor 'beg nil ctl-buf)
876 job-name))))
877 (select-window ctl-wind)
881 ;; This will have to be refined for 3way jobs
882 (defun ediff-toggle-split ()
883 "Toggle vertical/horizontal window split.
884 Does nothing if file-A and file-B are in different frames."
885 (interactive)
886 (ediff-barf-if-not-control-buffer)
887 (let* ((wind-A (if (window-live-p ediff-window-A) ediff-window-A))
888 (wind-B (if (window-live-p ediff-window-B) ediff-window-B))
889 (wind-C (if (window-live-p ediff-window-C) ediff-window-C))
890 (frame-A (if wind-A (window-frame wind-A)))
891 (frame-B (if wind-B (window-frame wind-B)))
892 (frame-C (if wind-C (window-frame wind-C))))
893 (if (or (eq frame-A frame-B)
894 (not (frame-live-p frame-A))
895 (not (frame-live-p frame-B))
896 (if ediff-3way-comparison-job
897 (or (not (frame-live-p frame-C))
898 (eq frame-A frame-C) (eq frame-B frame-C))))
899 (setq ediff-split-window-function
900 (if (eq ediff-split-window-function 'split-window-vertically)
901 'split-window-horizontally
902 'split-window-vertically))
903 (message "Buffers being compared are in different frames"))
904 (ediff-recenter 'no-rehighlight)))
906 (defun ediff-toggle-hilit ()
907 "Switch between highlighting using ASCII flags and highlighting using faces.
908 On a dumb terminal, switches between ASCII highlighting and no highlighting."
909 (interactive)
910 (ediff-barf-if-not-control-buffer)
912 (ediff-unselect-and-select-difference
913 ediff-current-difference 'unselect-only)
914 ;; cycle through highlighting
915 (cond ((and ediff-use-faces
916 (ediff-has-face-support-p)
917 ediff-highlight-all-diffs)
918 (message "Unhighlighting unselected difference regions")
919 (setq ediff-highlight-all-diffs nil
920 ediff-highlighting-style 'face))
921 ((or (and ediff-use-faces (ediff-has-face-support-p)
922 (eq ediff-highlighting-style 'face)) ; has face support
923 (and (not (ediff-has-face-support-p)) ; no face support
924 (eq ediff-highlighting-style 'off)))
925 (message "Highlighting with ASCII flags")
926 (setq ediff-highlighting-style 'ascii
927 ediff-highlight-all-diffs nil
928 ediff-use-faces nil))
929 ((eq ediff-highlighting-style 'ascii)
930 (message "ASCII highlighting flags removed")
931 (setq ediff-highlighting-style 'off
932 ediff-highlight-all-diffs nil))
933 ((ediff-has-face-support-p) ; catch-all for cases with face support
934 (message "Re-highlighting all difference regions")
935 (setq ediff-use-faces t
936 ediff-highlighting-style 'face
937 ediff-highlight-all-diffs t)))
939 (if (and ediff-use-faces ediff-highlight-all-diffs)
940 (ediff-paint-background-regions)
941 (ediff-paint-background-regions 'unhighlight))
943 (ediff-unselect-and-select-difference
944 ediff-current-difference 'select-only))
947 (defun ediff-toggle-autorefine ()
948 "Toggle auto-refine mode."
949 (interactive)
950 (ediff-barf-if-not-control-buffer)
951 (if ediff-word-mode
952 (error "No fine differences in this mode"))
953 (cond ((eq ediff-auto-refine 'nix)
954 (setq ediff-auto-refine 'on)
955 (ediff-make-fine-diffs ediff-current-difference 'noforce)
956 (message "Auto-refining is ON"))
957 ((eq ediff-auto-refine 'on)
958 (message "Auto-refining is OFF")
959 (setq ediff-auto-refine 'off))
960 (t ;; nix 'em
961 (ediff-set-fine-diff-properties ediff-current-difference 'default)
962 (message "Refinements are HIDDEN")
963 (setq ediff-auto-refine 'nix))
966 (defun ediff-show-ancestor ()
967 "Show the ancestor buffer in a suitable window."
968 (interactive)
969 (ediff-recenter)
970 (or (ediff-buffer-live-p ediff-ancestor-buffer)
971 (if ediff-merge-with-ancestor-job
972 (error "Lost connection to ancestor buffer...sorry")
973 (error "Not merging with ancestor")))
974 (let (wind)
975 (cond ((setq wind (ediff-get-visible-buffer-window ediff-ancestor-buffer))
976 (raise-frame (window-frame wind)))
977 (t (set-window-buffer ediff-window-C ediff-ancestor-buffer)))))
979 (defun ediff-make-or-kill-fine-diffs (arg)
980 "Compute fine diffs. With negative prefix arg, kill fine diffs.
981 In both cases, operates on the current difference region."
982 (interactive "P")
983 (ediff-barf-if-not-control-buffer)
984 (cond ((eq arg '-)
985 (ediff-clear-fine-differences ediff-current-difference))
986 ((and (numberp arg) (< arg 0))
987 (ediff-clear-fine-differences ediff-current-difference))
988 (t (ediff-make-fine-diffs))))
991 (defun ediff-toggle-help ()
992 "Toggle short/long help message."
993 (interactive)
994 (ediff-barf-if-not-control-buffer)
995 (let (buffer-read-only)
996 (erase-buffer)
997 (setq ediff-use-long-help-message (not ediff-use-long-help-message))
998 (ediff-set-help-message))
999 ;; remember the icon status of the control frame when the user requested
1000 ;; full control message
1001 (if (and ediff-use-long-help-message (ediff-multiframe-setup-p))
1002 (setq ediff-prefer-iconified-control-frame
1003 (ediff-frame-iconified-p ediff-control-frame)))
1005 (setq ediff-window-config-saved "") ; force redisplay
1006 (ediff-recenter 'no-rehighlight))
1009 ;; If BUF, this is the buffer to toggle, not current buffer.
1010 (defun ediff-toggle-read-only (&optional buf)
1011 "Toggle read-only in current buffer.
1012 If buffer is under version control and locked, check it out first.
1013 If optional argument BUF is specified, toggle read-only in that buffer instead
1014 of the current buffer."
1015 (interactive)
1016 (ediff-barf-if-not-control-buffer)
1017 (let ((ctl-buf (if (null buf) (current-buffer)))
1018 (buf-type (ediff-char-to-buftype (ediff-last-command-char))))
1019 (or buf (ediff-recenter))
1020 (or buf
1021 (setq buf (ediff-get-buffer buf-type)))
1023 (ediff-with-current-buffer buf ; eval in buf A/B/C
1024 (let* ((file (buffer-file-name buf))
1025 (file-writable (and file
1026 (file-exists-p file)
1027 (file-writable-p file)))
1028 (toggle-ro-cmd (cond (ediff-toggle-read-only-function)
1029 ((ediff-file-checked-out-p file)
1030 'toggle-read-only)
1031 (file-writable 'toggle-read-only)
1032 (t (key-binding "\C-x\C-q")))))
1033 ;; If the file is checked in, make sure we don't make buffer modifiable
1034 ;; without warning the user. The user can fool our checks by making the
1035 ;; buffer non-RO without checking the file out. We regard this as a
1036 ;; user problem.
1037 (if (and (ediff-file-checked-in-p file)
1038 ;; If ctl-buf is null, this means we called this
1039 ;; non-interactively, in which case don't ask questions
1040 ctl-buf)
1041 (cond ((not buffer-read-only)
1042 (setq toggle-ro-cmd 'toggle-read-only))
1043 ((and (or (beep 1) t) ; always beep
1044 (y-or-n-p
1045 (format
1046 "File %s is under version control. Check it out? "
1047 (ediff-abbreviate-file-name file))))
1048 ;; if we checked the file out, we should also change the
1049 ;; original state of buffer-read-only to nil. If we don't
1050 ;; do this, the mode line will show %%, since the file was
1051 ;; RO before ediff started, so the user will think the file
1052 ;; is checked in.
1053 (ediff-with-current-buffer ctl-buf
1054 (ediff-change-saved-variable
1055 'buffer-read-only nil buf-type)))
1057 (setq toggle-ro-cmd 'toggle-read-only)
1058 (beep 1) (beep 1)
1059 (message
1060 "Boy, this is risky! Don't modify this file...")
1061 (sit-for 3)))) ; let the user see the warning
1062 (if (and toggle-ro-cmd
1063 (string-match "toggle-read-only" (symbol-name toggle-ro-cmd)))
1064 (save-excursion
1065 (save-window-excursion
1066 (select-window (ediff-get-visible-buffer-window buf))
1067 (command-execute toggle-ro-cmd)))
1068 (error "Don't know how to toggle read-only in buffer %S" buf))
1070 ;; Check if we made the current buffer updatable, but its file is RO.
1071 ;; Signal a warning in this case.
1072 (if (and file (not buffer-read-only)
1073 (eq this-command 'ediff-toggle-read-only)
1074 (file-exists-p file)
1075 (not (file-writable-p file)))
1076 (progn
1077 (beep 1)
1078 (message "Warning: file %s is read-only"
1079 (ediff-abbreviate-file-name file))))
1080 ))))
1082 ;; checkout if visited file is checked in
1083 (defun ediff-maybe-checkout (buf)
1084 (let ((file (expand-file-name (buffer-file-name buf)))
1085 (checkout-function (key-binding "\C-x\C-q")))
1086 (if (and (ediff-file-checked-in-p file)
1087 (or (beep 1) t)
1088 (y-or-n-p
1089 (format
1090 "File %s is under version control. Check it out? "
1091 (ediff-abbreviate-file-name file))))
1092 (ediff-with-current-buffer buf
1093 (command-execute checkout-function)))))
1096 ;; This is a simple-minded check for whether a file is under version control.
1097 ;; If file,v exists but file doesn't, this file is considered to be not checked
1098 ;; in and not checked out for the purpose of patching (since patch won't be
1099 ;; able to read such a file anyway).
1100 ;; FILE is a string representing file name
1101 ;;(defun ediff-file-under-version-control (file)
1102 ;; (let* ((filedir (file-name-directory file))
1103 ;; (file-nondir (file-name-nondirectory file))
1104 ;; (trial (concat file-nondir ",v"))
1105 ;; (full-trial (concat filedir trial))
1106 ;; (full-rcs-trial (concat filedir "RCS/" trial)))
1107 ;; (and (stringp file)
1108 ;; (file-exists-p file)
1109 ;; (or
1110 ;; (and
1111 ;; (file-exists-p full-trial)
1112 ;; ;; in FAT FS, `file,v' and `file' may turn out to be the same!
1113 ;; ;; don't be fooled by this!
1114 ;; (not (equal (file-attributes file)
1115 ;; (file-attributes full-trial))))
1116 ;; ;; check if a version is in RCS/ directory
1117 ;; (file-exists-p full-rcs-trial)))
1118 ;; ))
1121 (defun ediff-file-checked-out-p (file)
1122 (or (not (featurep 'vc-hooks))
1123 (and (vc-backend file)
1124 (if (fboundp 'vc-state)
1125 (or (memq (vc-state file) '(edited needs-merge))
1126 (stringp (vc-state file)))
1127 ;; XEmacs has no vc-state
1128 (when (featurep 'xemacs) (vc-locking-user file)))
1131 (defun ediff-file-checked-in-p (file)
1132 (and (featurep 'vc-hooks)
1133 ;; Only RCS and SCCS files are considered checked in
1134 (memq (vc-backend file) '(RCS SCCS))
1135 (if (fboundp 'vc-state)
1136 (and
1137 (not (memq (vc-state file) '(edited needs-merge)))
1138 (not (stringp (vc-state file))))
1139 ;; XEmacs has no vc-state
1140 (when (featurep 'xemacs) (not (vc-locking-user file))))
1143 (defun ediff-file-compressed-p (file)
1144 (condition-case nil
1145 (require 'jka-compr)
1146 (error))
1147 (if (featurep 'jka-compr)
1148 (string-match (jka-compr-build-file-regexp) file)))
1151 (defun ediff-swap-buffers ()
1152 "Rotate the display of buffers A, B, and C."
1153 (interactive)
1154 (ediff-barf-if-not-control-buffer)
1155 (if (and (window-live-p ediff-window-A) (window-live-p ediff-window-B))
1156 (let ((buf ediff-buffer-A)
1157 (values ediff-buffer-values-orig-A)
1158 (diff-vec ediff-difference-vector-A)
1159 (hide-regexp ediff-regexp-hide-A)
1160 (focus-regexp ediff-regexp-focus-A)
1161 (wide-visibility-p (eq ediff-visible-bounds ediff-wide-bounds))
1162 (overlay (if (ediff-has-face-support-p)
1163 ediff-current-diff-overlay-A)))
1164 (if ediff-3way-comparison-job
1165 (progn
1166 (set-window-buffer ediff-window-A ediff-buffer-C)
1167 (set-window-buffer ediff-window-B ediff-buffer-A)
1168 (set-window-buffer ediff-window-C ediff-buffer-B)
1170 (set-window-buffer ediff-window-A ediff-buffer-B)
1171 (set-window-buffer ediff-window-B ediff-buffer-A))
1172 ;; swap diff buffers
1173 (if ediff-3way-comparison-job
1174 (setq ediff-buffer-A ediff-buffer-C
1175 ediff-buffer-C ediff-buffer-B
1176 ediff-buffer-B buf)
1177 (setq ediff-buffer-A ediff-buffer-B
1178 ediff-buffer-B buf))
1180 ;; swap saved buffer characteristics
1181 (if ediff-3way-comparison-job
1182 (setq ediff-buffer-values-orig-A ediff-buffer-values-orig-C
1183 ediff-buffer-values-orig-C ediff-buffer-values-orig-B
1184 ediff-buffer-values-orig-B values)
1185 (setq ediff-buffer-values-orig-A ediff-buffer-values-orig-B
1186 ediff-buffer-values-orig-B values))
1188 ;; swap diff vectors
1189 (if ediff-3way-comparison-job
1190 (setq ediff-difference-vector-A ediff-difference-vector-C
1191 ediff-difference-vector-C ediff-difference-vector-B
1192 ediff-difference-vector-B diff-vec)
1193 (setq ediff-difference-vector-A ediff-difference-vector-B
1194 ediff-difference-vector-B diff-vec))
1196 ;; swap hide/focus regexp
1197 (if ediff-3way-comparison-job
1198 (setq ediff-regexp-hide-A ediff-regexp-hide-C
1199 ediff-regexp-hide-C ediff-regexp-hide-B
1200 ediff-regexp-hide-B hide-regexp
1201 ediff-regexp-focus-A ediff-regexp-focus-C
1202 ediff-regexp-focus-C ediff-regexp-focus-B
1203 ediff-regexp-focus-B focus-regexp)
1204 (setq ediff-regexp-hide-A ediff-regexp-hide-B
1205 ediff-regexp-hide-B hide-regexp
1206 ediff-regexp-focus-A ediff-regexp-focus-B
1207 ediff-regexp-focus-B focus-regexp))
1209 ;; The following is needed for XEmacs, since there one can't move
1210 ;; overlay to another buffer. In Emacs, this swap is redundant.
1211 (if (ediff-has-face-support-p)
1212 (if ediff-3way-comparison-job
1213 (setq ediff-current-diff-overlay-A ediff-current-diff-overlay-C
1214 ediff-current-diff-overlay-C ediff-current-diff-overlay-B
1215 ediff-current-diff-overlay-B overlay)
1216 (setq ediff-current-diff-overlay-A ediff-current-diff-overlay-B
1217 ediff-current-diff-overlay-B overlay)))
1219 ;; swap wide bounds
1220 (setq ediff-wide-bounds
1221 (cond (ediff-3way-comparison-job
1222 (list (nth 2 ediff-wide-bounds)
1223 (nth 0 ediff-wide-bounds)
1224 (nth 1 ediff-wide-bounds)))
1225 (ediff-3way-job
1226 (list (nth 1 ediff-wide-bounds)
1227 (nth 0 ediff-wide-bounds)
1228 (nth 2 ediff-wide-bounds)))
1230 (list (nth 1 ediff-wide-bounds)
1231 (nth 0 ediff-wide-bounds)))))
1232 ;; swap narrow bounds
1233 (setq ediff-narrow-bounds
1234 (cond (ediff-3way-comparison-job
1235 (list (nth 2 ediff-narrow-bounds)
1236 (nth 0 ediff-narrow-bounds)
1237 (nth 1 ediff-narrow-bounds)))
1238 (ediff-3way-job
1239 (list (nth 1 ediff-narrow-bounds)
1240 (nth 0 ediff-narrow-bounds)
1241 (nth 2 ediff-narrow-bounds)))
1243 (list (nth 1 ediff-narrow-bounds)
1244 (nth 0 ediff-narrow-bounds)))))
1245 (if wide-visibility-p
1246 (setq ediff-visible-bounds ediff-wide-bounds)
1247 (setq ediff-visible-bounds ediff-narrow-bounds))
1249 (if ediff-3way-job
1250 (ediff-set-state-of-all-diffs-in-all-buffers ediff-control-buffer))
1251 (ediff-recenter 'no-rehighlight)
1255 (defun ediff-toggle-wide-display ()
1256 "Toggle wide/regular display.
1257 This is especially useful when comparing buffers side-by-side."
1258 (interactive)
1259 (ediff-barf-if-not-control-buffer)
1260 (or (ediff-window-display-p)
1261 (error "%sEmacs is not running as a window application"
1262 (if (featurep 'emacs) "" "X")))
1263 (ediff-recenter 'no-rehighlight) ; make sure buffs are displayed in windows
1264 (let ((ctl-buf ediff-control-buffer))
1265 (setq ediff-wide-display-p (not ediff-wide-display-p))
1266 (if (not ediff-wide-display-p)
1267 (ediff-with-current-buffer ctl-buf
1268 (modify-frame-parameters
1269 ediff-wide-display-frame ediff-wide-display-orig-parameters)
1270 ;;(sit-for (if (featurep 'xemacs) 0.4 0))
1271 ;; restore control buf, since ctl window may have been deleted
1272 ;; during resizing
1273 (set-buffer ctl-buf)
1274 (setq ediff-wide-display-orig-parameters nil
1275 ediff-window-B nil) ; force update of window config
1276 (ediff-recenter 'no-rehighlight))
1277 (funcall ediff-make-wide-display-function)
1278 ;;(sit-for (if (featurep 'xemacs) 0.4 0))
1279 (ediff-with-current-buffer ctl-buf
1280 (setq ediff-window-B nil) ; force update of window config
1281 (ediff-recenter 'no-rehighlight)))))
1283 ;;;###autoload
1284 (defun ediff-toggle-multiframe ()
1285 "Switch from multiframe display to single-frame display and back.
1286 To change the default, set the variable `ediff-window-setup-function',
1287 which see."
1288 (interactive)
1289 (let (window-setup-func)
1290 (or (ediff-window-display-p)
1291 (error "%sEmacs is not running as a window application"
1292 (if (featurep 'emacs) "" "X")))
1294 (cond ((eq ediff-window-setup-function 'ediff-setup-windows-multiframe)
1295 (setq ediff-multiframe nil)
1296 (setq window-setup-func 'ediff-setup-windows-plain))
1297 ((eq ediff-window-setup-function 'ediff-setup-windows-plain)
1298 (if (ediff-in-control-buffer-p)
1299 (ediff-kill-bottom-toolbar))
1300 (if (and (ediff-buffer-live-p ediff-control-buffer)
1301 (window-live-p ediff-control-window))
1302 (set-window-dedicated-p ediff-control-window nil))
1303 (setq ediff-multiframe t)
1304 (setq window-setup-func 'ediff-setup-windows-multiframe))
1306 (if (and (ediff-buffer-live-p ediff-control-buffer)
1307 (window-live-p ediff-control-window))
1308 (set-window-dedicated-p ediff-control-window nil))
1309 (setq ediff-multiframe t)
1310 (setq window-setup-func 'ediff-setup-windows-multiframe))
1313 ;; change default
1314 (setq-default ediff-window-setup-function window-setup-func)
1315 ;; change in all active ediff sessions
1316 (mapc (lambda(buf) (ediff-with-current-buffer buf
1317 (setq ediff-window-setup-function window-setup-func
1318 ediff-window-B nil)))
1319 ediff-session-registry)
1320 (if (ediff-in-control-buffer-p)
1321 (progn
1322 (set-window-dedicated-p (selected-window) nil)
1323 (ediff-recenter 'no-rehighlight)))))
1326 ;;;###autoload
1327 (defun ediff-toggle-use-toolbar ()
1328 "Enable or disable Ediff toolbar.
1329 Works only in versions of Emacs that support toolbars.
1330 To change the default, set the variable `ediff-use-toolbar-p', which see."
1331 (interactive)
1332 (if (featurep 'ediff-tbar)
1333 (progn
1334 (or (ediff-window-display-p)
1335 (error "%sEmacs is not running as a window application"
1336 (if (featurep 'emacs) "" "X")))
1337 (if (ediff-use-toolbar-p)
1338 (ediff-kill-bottom-toolbar))
1339 ;; do this only after killing the toolbar
1340 (setq ediff-use-toolbar-p (not ediff-use-toolbar-p))
1342 (mapc (lambda(buf)
1343 (ediff-with-current-buffer buf
1344 ;; force redisplay
1345 (setq ediff-window-config-saved "")
1347 ediff-session-registry)
1348 (if (ediff-in-control-buffer-p)
1349 (ediff-recenter 'no-rehighlight)))))
1352 ;; if was using toolbar, kill it
1353 (defun ediff-kill-bottom-toolbar ()
1354 ;; Using ctl-buffer or ediff-control-window for LOCALE does not
1355 ;; work properly in XEmacs 19.14: we have to use
1356 ;;(selected-frame).
1357 ;; The problem with this is that any previous bottom-toolbar
1358 ;; will not re-appear after our cleanup here. Is there a way
1359 ;; to do "push" and "pop" toolbars ? --marcpa
1360 (if (featurep 'xemacs)
1361 (when (ediff-use-toolbar-p)
1362 (set-specifier bottom-toolbar (list (selected-frame) nil))
1363 (set-specifier bottom-toolbar-visible-p (list (selected-frame) nil)))))
1365 ;; If wants to use toolbar, make it.
1366 ;; If not, zero the toolbar for XEmacs.
1367 ;; Do nothing for Emacs.
1368 (defun ediff-make-bottom-toolbar (&optional frame)
1369 (when (ediff-window-display-p)
1370 (setq frame (or frame (selected-frame)))
1371 (if (featurep 'xemacs)
1372 (cond ((ediff-use-toolbar-p) ; this checks for XEmacs
1373 (set-specifier
1374 bottom-toolbar
1375 (list frame (if (ediff-3way-comparison-job)
1376 ediff-toolbar-3way ediff-toolbar)))
1377 (set-specifier bottom-toolbar-visible-p (list frame t))
1378 (set-specifier bottom-toolbar-height
1379 (list frame ediff-toolbar-height)))
1380 ((ediff-has-toolbar-support-p)
1381 (set-specifier bottom-toolbar-height (list frame 0)))))))
1383 ;; Merging
1385 (defun ediff-toggle-show-clashes-only ()
1386 "Toggle the mode that shows only the merge regions where both variants differ from the ancestor."
1387 (interactive)
1388 (ediff-barf-if-not-control-buffer)
1389 (if (not ediff-merge-with-ancestor-job)
1390 (error "This command makes sense only when merging with an ancestor"))
1391 (setq ediff-show-clashes-only (not ediff-show-clashes-only))
1392 (if ediff-show-clashes-only
1393 (message "Focus on regions where both buffers differ from the ancestor")
1394 (message "Canceling focus on regions where changes clash")))
1396 (defun ediff-toggle-skip-changed-regions ()
1397 "Toggle the mode that skips the merge regions that differ from the default."
1398 (interactive)
1399 (ediff-barf-if-not-control-buffer)
1400 (setq ediff-skip-merge-regions-that-differ-from-default
1401 (not ediff-skip-merge-regions-that-differ-from-default))
1402 (if ediff-skip-merge-regions-that-differ-from-default
1403 (message "Skipping regions that differ from default setting")
1404 (message "Showing regions that differ from default setting")))
1408 ;; Widening/narrowing
1410 (defun ediff-toggle-narrow-region ()
1411 "Toggle narrowing in buffers A, B, and C.
1412 Used in ediff-windows/regions only."
1413 (interactive)
1414 (if (eq ediff-buffer-A ediff-buffer-B)
1415 (error ediff-NO-DIFFERENCES))
1416 (if (eq ediff-visible-bounds ediff-wide-bounds)
1417 (setq ediff-visible-bounds ediff-narrow-bounds)
1418 (setq ediff-visible-bounds ediff-wide-bounds))
1419 (ediff-recenter 'no-rehighlight))
1421 ;; Narrow bufs A/B/C to ediff-visible-bounds. If this is currently set to
1422 ;; ediff-wide-bounds, then this actually widens.
1423 ;; This function does nothing if job-name is not
1424 ;; ediff-regions-wordwise/linewise or ediff-windows-wordwise/linewise.
1425 ;; Does nothing if buffer-A = buffer-B since we can't narrow
1426 ;; to two different regions in one buffer.
1427 (defun ediff-visible-region ()
1428 (if (or (eq ediff-buffer-A ediff-buffer-B)
1429 (eq ediff-buffer-A ediff-buffer-C)
1430 (eq ediff-buffer-C ediff-buffer-B))
1432 ;; If ediff-*-regions/windows, ediff-visible-bounds is already set
1433 ;; Otherwise, always use full range.
1434 (if (not ediff-narrow-job)
1435 (setq ediff-visible-bounds ediff-wide-bounds))
1436 (let ((overl-A (ediff-get-value-according-to-buffer-type
1437 'A ediff-visible-bounds))
1438 (overl-B (ediff-get-value-according-to-buffer-type
1439 'B ediff-visible-bounds))
1440 (overl-C (ediff-get-value-according-to-buffer-type
1441 'C ediff-visible-bounds))
1443 (ediff-with-current-buffer ediff-buffer-A
1444 (if (ediff-overlay-buffer overl-A)
1445 (narrow-to-region
1446 (ediff-overlay-start overl-A) (ediff-overlay-end overl-A))))
1447 (ediff-with-current-buffer ediff-buffer-B
1448 (if (ediff-overlay-buffer overl-B)
1449 (narrow-to-region
1450 (ediff-overlay-start overl-B) (ediff-overlay-end overl-B))))
1452 (if (and ediff-3way-job (ediff-overlay-buffer overl-C))
1453 (ediff-with-current-buffer ediff-buffer-C
1454 (narrow-to-region
1455 (ediff-overlay-start overl-C) (ediff-overlay-end overl-C))))
1459 ;; Window scrolling operations
1461 ;; Performs some operation on the two file windows (if they are showing).
1462 ;; Traps all errors on the operation in windows A/B/C.
1463 ;; Usually, errors come from scrolling off the
1464 ;; beginning or end of the buffer, and this gives error messages.
1465 (defun ediff-operate-on-windows (operation arg)
1467 ;; make sure windows aren't dead
1468 (if (not (and (window-live-p ediff-window-A) (window-live-p ediff-window-B)))
1469 (ediff-recenter 'no-rehighlight))
1470 (if (not (and (ediff-buffer-live-p ediff-buffer-A)
1471 (ediff-buffer-live-p ediff-buffer-B)
1472 (or (not ediff-3way-job) ediff-buffer-C)
1474 (error ediff-KILLED-VITAL-BUFFER))
1476 (let* ((wind (selected-window))
1477 (wind-A ediff-window-A)
1478 (wind-B ediff-window-B)
1479 (wind-C ediff-window-C)
1480 (coefA (ediff-get-region-size-coefficient 'A operation))
1481 (coefB (ediff-get-region-size-coefficient 'B operation))
1482 (three-way ediff-3way-job)
1483 (coefC (if three-way
1484 (ediff-get-region-size-coefficient 'C operation))))
1486 (select-window wind-A)
1487 (condition-case nil
1488 (funcall operation (round (* coefA arg)))
1489 (error))
1490 (select-window wind-B)
1491 (condition-case nil
1492 (funcall operation (round (* coefB arg)))
1493 (error))
1494 (if three-way
1495 (progn
1496 (select-window wind-C)
1497 (condition-case nil
1498 (funcall operation (round (* coefC arg)))
1499 (error))))
1500 (select-window wind)))
1502 (defun ediff-scroll-vertically (&optional arg)
1503 "Vertically scroll buffers A, B \(and C if appropriate\).
1504 With optional argument ARG, scroll ARG lines; otherwise scroll by nearly
1505 the one half of the height of window-A."
1506 (interactive "P")
1507 (ediff-barf-if-not-control-buffer)
1509 ;; make sure windows aren't dead
1510 (if (not (and (window-live-p ediff-window-A) (window-live-p ediff-window-B)))
1511 (ediff-recenter 'no-rehighlight))
1512 (if (not (and (ediff-buffer-live-p ediff-buffer-A)
1513 (ediff-buffer-live-p ediff-buffer-B)
1514 (or (not ediff-3way-job)
1515 (ediff-buffer-live-p ediff-buffer-C))
1517 (error ediff-KILLED-VITAL-BUFFER))
1519 (ediff-operate-on-windows
1520 (if (memq (ediff-last-command-char) '(?v ?\C-v))
1521 'scroll-up
1522 'scroll-down)
1523 ;; calculate argument to scroll-up/down
1524 ;; if there is an explicit argument
1525 (if (and arg (not (equal arg '-)))
1526 ;; use it
1527 (prefix-numeric-value arg)
1528 ;; if not, see if we can determine a default amount (the window height)
1529 (let (default-amount)
1530 (setq default-amount
1531 (- (/ (min (window-height ediff-window-A)
1532 (window-height ediff-window-B)
1533 (if ediff-3way-job
1534 (window-height ediff-window-C)
1535 500)) ; some large number
1537 1 next-screen-context-lines))
1538 ;; window found
1539 (if arg
1540 ;; C-u as argument means half of default amount
1541 (/ default-amount 2)
1542 ;; no argument means default amount
1543 default-amount)))))
1546 (defun ediff-scroll-horizontally (&optional arg)
1547 "Horizontally scroll buffers A, B \(and C if appropriate\).
1548 If an argument is given, that is how many columns are scrolled, else nearly
1549 the width of the A/B/C windows."
1550 (interactive "P")
1551 (ediff-barf-if-not-control-buffer)
1553 ;; make sure windows aren't dead
1554 (if (not (and (window-live-p ediff-window-A) (window-live-p ediff-window-B)))
1555 (ediff-recenter 'no-rehighlight))
1556 (if (not (and (ediff-buffer-live-p ediff-buffer-A)
1557 (ediff-buffer-live-p ediff-buffer-B)
1558 (or (not ediff-3way-job)
1559 (ediff-buffer-live-p ediff-buffer-C))
1561 (error ediff-KILLED-VITAL-BUFFER))
1563 (ediff-operate-on-windows
1564 ;; Arrange for scroll-left and scroll-right being called
1565 ;; interactively so that they set the window's min_hscroll.
1566 ;; Otherwise, automatic hscrolling will undo the effect of
1567 ;; hscrolling.
1568 (if (= (ediff-last-command-char) ?<)
1569 (lambda (arg)
1570 (let ((prefix-arg arg))
1571 (call-interactively 'scroll-left)))
1572 (lambda (arg)
1573 (let ((prefix-arg arg))
1574 (call-interactively 'scroll-right))))
1575 ;; calculate argument to scroll-left/right
1576 ;; if there is an explicit argument
1577 (if (and arg (not (equal arg '-)))
1578 ;; use it
1579 (prefix-numeric-value arg)
1580 ;; if not, see if we can determine a default amount
1581 ;; (half the window width)
1582 (if (null ediff-control-window)
1583 ;; no control window, use nil
1585 (let ((default-amount
1586 (- (/ (min (window-width ediff-window-A)
1587 (window-width ediff-window-B)
1588 (if ediff-3way-comparison-job
1589 (window-width ediff-window-C)
1590 500) ; some large number
1593 3)))
1594 ;; window found
1595 (if arg
1596 ;; C-u as argument means half of default amount
1597 (/ default-amount 2)
1598 ;; no argument means default amount
1599 default-amount))))))
1602 ;;BEG, END show the region to be positioned.
1603 ;;JOB-NAME holds ediff-job-name. The ediff-windows job positions regions
1604 ;;differently.
1605 (defun ediff-position-region (beg end pos _job-name)
1606 (if (> end (point-max))
1607 (setq end (point-max)))
1608 (if ediff-windows-job
1609 (if (pos-visible-in-window-p end)
1610 () ; do nothing, wind is already positioned
1611 ;; at this point, windows are positioned at the beginning of the
1612 ;; file regions (not diff-regions) being compared.
1613 (save-excursion
1614 (move-to-window-line (- (window-height) 2))
1615 (let ((amount (+ 2 (count-lines (point) end))))
1616 (scroll-up amount))))
1617 (set-window-start (selected-window) beg)
1618 (if (pos-visible-in-window-p end)
1619 ;; Determine the number of lines that the region occupies
1620 (let ((lines 0)
1621 (prev-point 0))
1622 (while ( and (> end (progn
1623 (move-to-window-line lines)
1624 (point)))
1625 ;; `end' may be beyond the window bottom, so check
1626 ;; that we are making progress
1627 (< prev-point (point)))
1628 (setq prev-point (point))
1629 (setq lines (1+ lines)))
1630 ;; And position the beginning on the right line
1631 (goto-char beg)
1632 (recenter (/ (1+ (max (- (1- (window-height))
1633 lines)
1636 2))))
1637 (goto-char pos)
1640 ;; get number of lines from window start to region end
1641 (defun ediff-get-lines-to-region-end (buf-type &optional n ctl-buf)
1642 (or n (setq n ediff-current-difference))
1643 (or ctl-buf (setq ctl-buf ediff-control-buffer))
1644 (ediff-with-current-buffer ctl-buf
1645 (let* ((buf (ediff-get-buffer buf-type))
1646 (wind (eval (ediff-get-symbol-from-alist
1647 buf-type ediff-window-alist)))
1648 (beg (window-start wind))
1649 (end (ediff-get-diff-posn buf-type 'end))
1650 lines)
1651 (ediff-with-current-buffer buf
1652 (if (< beg end)
1653 (setq lines (count-lines beg end))
1654 (setq lines 0))
1655 lines
1656 ))))
1658 ;; Calculate the number of lines from window end to the start of diff region
1659 (defun ediff-get-lines-to-region-start (buf-type &optional diff-num ctl-buf)
1660 (or diff-num (setq diff-num ediff-current-difference))
1661 (or ctl-buf (setq ctl-buf ediff-control-buffer))
1662 (ediff-with-current-buffer ctl-buf
1663 (let* ((buf (ediff-get-buffer buf-type))
1664 (wind (eval (ediff-get-symbol-from-alist
1665 buf-type ediff-window-alist)))
1666 (end (or (window-end wind) (window-end wind t)))
1667 (beg (ediff-get-diff-posn buf-type 'beg diff-num)))
1668 (ediff-with-current-buffer buf
1669 (if (< beg end)
1670 (count-lines (max beg (point-min)) (min end (point-max))) 0))
1674 ;; region size coefficient is a coefficient by which to adjust scrolling
1675 ;; up/down of the window displaying buffer of type BUFTYPE.
1676 ;; The purpose of this coefficient is to make the windows scroll in sync, so
1677 ;; that it won't happen that one diff region is scrolled off while the other is
1678 ;; still seen.
1680 ;; If the difference region is invalid, the coefficient is 1
1681 (defun ediff-get-region-size-coefficient (buf-type op &optional n ctl-buf)
1682 (ediff-with-current-buffer (or ctl-buf ediff-control-buffer)
1683 (if (ediff-valid-difference-p n)
1684 (let* ((func (cond ((eq op 'scroll-down)
1685 'ediff-get-lines-to-region-start)
1686 ((eq op 'scroll-up)
1687 'ediff-get-lines-to-region-end)
1688 (t (lambda (_a _b _c) 0))))
1689 (max-lines (max (funcall func 'A n ctl-buf)
1690 (funcall func 'B n ctl-buf)
1691 (if (ediff-buffer-live-p ediff-buffer-C)
1692 (funcall func 'C n ctl-buf)
1693 0))))
1694 ;; this covers the horizontal coefficient as well:
1695 ;; if max-lines = 0 then coef = 1
1696 (if (> max-lines 0)
1697 (/ (+ (funcall func buf-type n ctl-buf) 0.0)
1698 (+ max-lines 0.0))
1700 1)))
1703 (defun ediff-next-difference (&optional arg)
1704 "Advance to the next difference.
1705 With a prefix argument, go forward that many differences."
1706 (interactive "p")
1707 (ediff-barf-if-not-control-buffer)
1708 (if (< ediff-current-difference ediff-number-of-differences)
1709 (let ((n (min ediff-number-of-differences
1710 (+ ediff-current-difference (or arg 1))))
1711 non-clash-skip skip-changed regexp-skip)
1713 (ediff-visible-region)
1714 (or (>= n ediff-number-of-differences)
1715 (setq regexp-skip (funcall ediff-skip-diff-region-function n))
1716 ;; this won't exec if regexp-skip is t
1717 (setq non-clash-skip (ediff-merge-region-is-non-clash-to-skip n)
1718 skip-changed
1719 (ediff-skip-merge-region-if-changed-from-default-p n))
1720 (ediff-install-fine-diff-if-necessary n))
1721 ;; Skip loop
1722 (while (and (< n ediff-number-of-differences)
1724 ;; regexp skip
1725 regexp-skip
1726 ;; skip clashes, if necessary
1727 non-clash-skip
1728 ;; skip processed regions
1729 skip-changed
1730 ;; skip difference regions that differ in white space
1731 (and ediff-ignore-similar-regions
1732 (ediff-merge-region-is-non-clash n)
1733 (or (eq (ediff-no-fine-diffs-p n) t)
1734 (and (ediff-merge-job)
1735 (eq (ediff-no-fine-diffs-p n) 'C)))
1737 (setq n (1+ n))
1738 (if (= 0 (mod n 20))
1739 (message "Skipped over region %d and counting ..." n))
1740 (or (>= n ediff-number-of-differences)
1741 (setq regexp-skip (funcall ediff-skip-diff-region-function n))
1742 ;; this won't exec if regexp-skip is t
1743 (setq non-clash-skip (ediff-merge-region-is-non-clash-to-skip n)
1744 skip-changed
1745 (ediff-skip-merge-region-if-changed-from-default-p n))
1746 (ediff-install-fine-diff-if-necessary n))
1748 (message "")
1749 (ediff-unselect-and-select-difference n)
1750 ) ; let
1751 (ediff-visible-region)
1752 (error "At end of the difference list")))
1754 (defun ediff-previous-difference (&optional arg)
1755 "Go to the previous difference.
1756 With a prefix argument, go back that many differences."
1757 (interactive "p")
1758 (ediff-barf-if-not-control-buffer)
1759 (if (> ediff-current-difference -1)
1760 (let ((n (max -1 (- ediff-current-difference (or arg 1))))
1761 non-clash-skip skip-changed regexp-skip)
1763 (ediff-visible-region)
1764 (or (< n 0)
1765 (setq regexp-skip (funcall ediff-skip-diff-region-function n))
1766 ;; this won't exec if regexp-skip is t
1767 (setq non-clash-skip (ediff-merge-region-is-non-clash-to-skip n)
1768 skip-changed
1769 (ediff-skip-merge-region-if-changed-from-default-p n))
1770 (ediff-install-fine-diff-if-necessary n))
1771 (while (and (> n -1)
1773 ;; regexp skip
1774 regexp-skip
1775 ;; skip clashes, if necessary
1776 non-clash-skip
1777 ;; skipp changed regions
1778 skip-changed
1779 ;; skip difference regions that differ in white space
1780 (and ediff-ignore-similar-regions
1781 (ediff-merge-region-is-non-clash n)
1782 (or (eq (ediff-no-fine-diffs-p n) t)
1783 (and (ediff-merge-job)
1784 (eq (ediff-no-fine-diffs-p n) 'C)))
1786 (if (= 0 (mod (1+ n) 20))
1787 (message "Skipped over region %d and counting ..." (1+ n)))
1788 (setq n (1- n))
1789 (or (< n 0)
1790 (setq regexp-skip (funcall ediff-skip-diff-region-function n))
1791 ;; this won't exec if regexp-skip is t
1792 (setq non-clash-skip (ediff-merge-region-is-non-clash-to-skip n)
1793 skip-changed
1794 (ediff-skip-merge-region-if-changed-from-default-p n))
1795 (ediff-install-fine-diff-if-necessary n))
1797 (message "")
1798 (ediff-unselect-and-select-difference n)
1799 ) ; let
1800 (ediff-visible-region)
1801 (error "At beginning of the difference list")))
1803 ;; The diff number is as perceived by the user (i.e., 1+ the internal
1804 ;; representation)
1805 (defun ediff-jump-to-difference (difference-number)
1806 "Go to the difference specified as a prefix argument.
1807 If the prefix is negative, count differences from the end."
1808 (interactive "p")
1809 (ediff-barf-if-not-control-buffer)
1810 (setq difference-number
1811 (cond ((< difference-number 0)
1812 (+ ediff-number-of-differences difference-number))
1813 ((> difference-number 0) (1- difference-number))
1814 (t -1)))
1815 ;; -1 is allowed by ediff-unselect-and-select-difference --- it is the
1816 ;; position before the first one.
1817 (if (and (>= difference-number -1)
1818 (<= difference-number ediff-number-of-differences))
1819 (ediff-unselect-and-select-difference difference-number)
1820 (error ediff-BAD-DIFF-NUMBER
1821 this-command (1+ difference-number) ediff-number-of-differences)))
1823 (defun ediff-jump-to-difference-at-point (arg)
1824 "Go to difference closest to the point in buffer A, B, or C.
1825 The buffer depends on last command character \(a, b, or c\) that invoked this
1826 command. For instance, if the command was `ga' then the point value in buffer
1827 A is used.
1828 With a prefix argument, synchronize all files around the current point position
1829 in the specified buffer."
1830 (interactive "P")
1831 (ediff-barf-if-not-control-buffer)
1832 (let* ((buf-type (ediff-char-to-buftype (ediff-last-command-char)))
1833 (buffer (ediff-get-buffer buf-type))
1834 (pt (ediff-with-current-buffer buffer (point)))
1835 (diff-no (ediff-diff-at-point buf-type nil (if arg 'after)))
1836 (past-last-diff (< ediff-number-of-differences diff-no))
1837 (beg (if past-last-diff
1838 (ediff-with-current-buffer buffer (point-max))
1839 (ediff-get-diff-posn buf-type 'beg (1- diff-no))))
1840 ctl-wind wind-A wind-B wind-C
1841 shift)
1842 (if past-last-diff
1843 (ediff-jump-to-difference -1)
1844 (ediff-jump-to-difference diff-no))
1845 (setq ctl-wind (selected-window)
1846 wind-A ediff-window-A
1847 wind-B ediff-window-B
1848 wind-C ediff-window-C)
1849 (if arg
1850 (progn
1851 (ediff-with-current-buffer buffer
1852 (setq shift (- beg pt)))
1853 (select-window wind-A)
1854 (if past-last-diff (goto-char (point-max)))
1855 (condition-case nil
1856 (backward-char shift) ; noerror, if beginning of buffer
1857 (error))
1858 (recenter)
1859 (select-window wind-B)
1860 (if past-last-diff (goto-char (point-max)))
1861 (condition-case nil
1862 (backward-char shift) ; noerror, if beginning of buffer
1863 (error))
1864 (recenter)
1865 (if (window-live-p wind-C)
1866 (progn
1867 (select-window wind-C)
1868 (if past-last-diff (goto-char (point-max)))
1869 (condition-case nil
1870 (backward-char shift) ; noerror, if beginning of buffer
1871 (error))
1872 (recenter)
1874 (select-window ctl-wind)
1879 ;; find region most related to the current point position (or POS, if given)
1880 ;; returns diff number as seen by the user (i.e., 1+ the internal
1881 ;; representation)
1882 ;; The optional argument WHICH-DIFF can be `after' or `before'. If `after',
1883 ;; find the diff after the point. If `before', find the diff before the
1884 ;; point. If the point is inside a diff, return that diff.
1885 (defun ediff-diff-at-point (buf-type &optional pos which-diff)
1886 (let ((buffer (ediff-get-buffer buf-type))
1887 (ctl-buffer ediff-control-buffer)
1888 (max-dif-num (1- ediff-number-of-differences))
1889 (diff-no -1)
1890 (prev-beg 0)
1891 (prev-end 0)
1892 (beg 0)
1893 (end 0))
1895 (ediff-with-current-buffer buffer
1896 (setq pos (or pos (point)))
1897 (while (and (or (< pos prev-beg) (> pos beg))
1898 (< diff-no max-dif-num))
1899 (setq diff-no (1+ diff-no))
1900 (setq prev-beg beg
1901 prev-end end)
1902 (setq beg (ediff-get-diff-posn buf-type 'beg diff-no ctl-buffer)
1903 end (ediff-get-diff-posn buf-type 'end diff-no ctl-buffer))
1906 ;; boost diff-no by 1, if past the last diff region
1907 (if (and (memq which-diff '(after before))
1908 (> pos beg) (= diff-no max-dif-num))
1909 (setq diff-no (1+ diff-no)))
1911 (cond ((eq which-diff 'after) (1+ diff-no))
1912 ((eq which-diff 'before) diff-no)
1913 ((< (abs (count-lines pos (max (point-min) prev-end)))
1914 (abs (count-lines pos (max (point-min) beg))))
1915 diff-no) ; choose prev difference
1917 (1+ diff-no))) ; choose next difference
1921 ;;; Copying diffs.
1923 (defun ediff-diff-to-diff (arg &optional keys)
1924 "Copy buffer-X'th difference region to buffer Y \(X,Y are A, B, or C\).
1925 If numerical prefix argument, copy the difference specified in the arg.
1926 Otherwise, copy the difference given by `ediff-current-difference'.
1927 This command assumes it is bound to a 2-character key sequence, `ab', `ba',
1928 `ac', etc., which is used to determine the types of buffers to be used for
1929 copying difference regions. The first character in the sequence specifies
1930 the source buffer and the second specifies the target.
1932 If the second optional argument, a 2-character string, is given, use it to
1933 determine the source and the target buffers instead of the command keys."
1934 (interactive "P")
1935 (ediff-barf-if-not-control-buffer)
1936 (or keys (setq keys (this-command-keys)))
1937 (if (eq arg '-) (setq arg -1)) ; translate neg arg to -1
1938 (if (numberp arg) (ediff-jump-to-difference arg))
1940 (let* ((key1 (aref keys 0))
1941 (key2 (aref keys 1))
1942 (char1 (ediff-event-key key1))
1943 (char2 (ediff-event-key key2))
1944 ediff-verbose-p)
1945 (ediff-copy-diff ediff-current-difference
1946 (ediff-char-to-buftype char1)
1947 (ediff-char-to-buftype char2))
1948 ;; recenter with rehighlighting, but no messages
1949 (ediff-recenter)))
1951 (defun ediff-copy-A-to-B (arg)
1952 "Copy ARGth difference region from buffer A to B.
1953 ARG is a prefix argument. If nil, copy the current difference region."
1954 (interactive "P")
1955 (ediff-diff-to-diff arg "ab"))
1957 (defun ediff-copy-B-to-A (arg)
1958 "Copy ARGth difference region from buffer B to A.
1959 ARG is a prefix argument. If nil, copy the current difference region."
1960 (interactive "P")
1961 (ediff-diff-to-diff arg "ba"))
1963 (defun ediff-copy-A-to-C (arg)
1964 "Copy ARGth difference region from buffer A to buffer C.
1965 ARG is a prefix argument. If nil, copy the current difference region."
1966 (interactive "P")
1967 (ediff-diff-to-diff arg "ac"))
1969 (defun ediff-copy-B-to-C (arg)
1970 "Copy ARGth difference region from buffer B to buffer C.
1971 ARG is a prefix argument. If nil, copy the current difference region."
1972 (interactive "P")
1973 (ediff-diff-to-diff arg "bc"))
1975 (defun ediff-copy-C-to-B (arg)
1976 "Copy ARGth difference region from buffer C to B.
1977 ARG is a prefix argument. If nil, copy the current difference region."
1978 (interactive "P")
1979 (ediff-diff-to-diff arg "cb"))
1981 (defun ediff-copy-C-to-A (arg)
1982 "Copy ARGth difference region from buffer C to A.
1983 ARG is a prefix argument. If nil, copy the current difference region."
1984 (interactive "P")
1985 (ediff-diff-to-diff arg "ca"))
1989 ;; Copy diff N from FROM-BUF-TYPE \(given as A, B or C\) to TO-BUF-TYPE.
1990 ;; If optional DO-NOT-SAVE is non-nil, do not save the old value of the
1991 ;; target diff. This is used in merging, when constructing the merged
1992 ;; version.
1993 (defun ediff-copy-diff (n from-buf-type to-buf-type
1994 &optional batch-invocation reg-to-copy)
1995 (let* ((to-buf (ediff-get-buffer to-buf-type))
1996 ;;(from-buf (if (not reg-to-copy) (ediff-get-buffer from-buf-type)))
1997 (ctrl-buf ediff-control-buffer)
1998 (saved-p t)
1999 (three-way ediff-3way-job)
2000 messg
2001 ediff-verbose-p
2002 reg-to-delete reg-to-delete-beg reg-to-delete-end)
2004 (setq reg-to-delete-beg
2005 (ediff-get-diff-posn to-buf-type 'beg n ctrl-buf))
2006 (setq reg-to-delete-end
2007 (ediff-get-diff-posn to-buf-type 'end n ctrl-buf))
2009 (if reg-to-copy
2010 (setq from-buf-type nil)
2011 (setq reg-to-copy (ediff-get-region-contents n from-buf-type ctrl-buf)))
2013 (setq reg-to-delete (ediff-get-region-contents
2014 n to-buf-type ctrl-buf
2015 reg-to-delete-beg reg-to-delete-end))
2017 (if (string= reg-to-delete reg-to-copy)
2018 (setq saved-p nil) ; don't copy identical buffers
2019 ;; seems ok to copy
2020 (if (or batch-invocation (ediff-test-save-region n to-buf-type))
2021 (condition-case conds
2022 (progn
2023 (ediff-with-current-buffer to-buf
2024 ;; to prevent flags from interfering if buffer is writable
2025 (let ((inhibit-read-only (null buffer-read-only)))
2027 (goto-char reg-to-delete-end)
2028 (insert reg-to-copy)
2030 (if (> reg-to-delete-end reg-to-delete-beg)
2031 (kill-region reg-to-delete-beg reg-to-delete-end))
2033 (or batch-invocation
2034 (setq
2035 messg
2036 (ediff-save-diff-region n to-buf-type reg-to-delete))))
2037 (error (message "ediff-copy-diff: %s %s"
2038 (car conds)
2039 (mapconcat 'prin1-to-string (cdr conds) " "))
2040 (beep 1)
2041 (sit-for 2) ; let the user see the error msg
2042 (setq saved-p nil)
2046 ;; adjust state of difference in case 3-way and diff was copied ok
2047 (if (and saved-p three-way)
2048 (ediff-set-state-of-diff-in-all-buffers n ctrl-buf))
2050 (if batch-invocation
2051 (ediff-clear-fine-differences n)
2052 ;; If diff3 job, we should recompute fine diffs so we clear them
2053 ;; before reinserting flags (and thus before ediff-recenter).
2054 (if (and saved-p three-way)
2055 (ediff-clear-fine-differences n))
2057 (ediff-refresh-mode-lines)
2059 ;; For diff2 jobs, don't recompute fine diffs, since we know there
2060 ;; aren't any. So we clear diffs after ediff-recenter.
2061 (if (and saved-p (not three-way))
2062 (ediff-clear-fine-differences n))
2063 ;; Make sure that the message about saving and how to restore is seen
2064 ;; by the user
2065 (message "%s" messg))
2068 ;; Save Nth diff of buffer BUF-TYPE \(A, B, or C\).
2069 ;; That is to say, the Nth diff on the `ediff-killed-diffs-alist'. REG
2070 ;; is the region to save. It is redundant here, but is passed anyway, for
2071 ;; convenience.
2072 (defun ediff-save-diff-region (n buf-type reg)
2073 (let* ((n-th-diff-saved (assoc n ediff-killed-diffs-alist))
2074 (buf (ediff-get-buffer buf-type))
2075 (this-buf-n-th-diff-saved (assoc buf (cdr n-th-diff-saved))))
2077 (if this-buf-n-th-diff-saved
2078 ;; either nothing saved for n-th diff and buffer or we OK'ed
2079 ;; overriding
2080 (setcdr this-buf-n-th-diff-saved reg)
2081 (if n-th-diff-saved ;; n-th diff saved, but for another buffer
2082 (nconc n-th-diff-saved (list (cons buf reg)))
2083 (setq ediff-killed-diffs-alist ;; create record for n-th diff
2084 (cons (list n (cons buf reg))
2085 ediff-killed-diffs-alist))))
2086 (message "Saving old diff region #%d of buffer %S. To recover, type `r%s'"
2087 (1+ n) buf-type
2088 (if ediff-merge-job
2089 "" (downcase (symbol-name buf-type))))
2092 ;; Test if saving Nth difference region of buffer BUF-TYPE is possible.
2093 (defun ediff-test-save-region (n buf-type)
2094 (let* ((n-th-diff-saved (assoc n ediff-killed-diffs-alist))
2095 (buf (ediff-get-buffer buf-type))
2096 (this-buf-n-th-diff-saved (assoc buf (cdr n-th-diff-saved))))
2098 (if this-buf-n-th-diff-saved
2099 (if (yes-or-no-p
2100 (format
2101 "You've previously copied diff region %d to buffer %S. Confirm? "
2102 (1+ n) buf-type))
2104 (error "Quit"))
2105 t)))
2107 (defun ediff-pop-diff (n buf-type)
2108 "Pop last killed Nth diff region from buffer BUF-TYPE."
2109 (let* ((n-th-record (assoc n ediff-killed-diffs-alist))
2110 (buf (ediff-get-buffer buf-type))
2111 (saved-rec (assoc buf (cdr n-th-record)))
2112 (three-way ediff-3way-job)
2113 (ctl-buf ediff-control-buffer)
2114 ediff-verbose-p
2115 saved-diff reg-beg reg-end recovered)
2117 (if (cdr saved-rec)
2118 (setq saved-diff (cdr saved-rec))
2119 (if (> ediff-number-of-differences 0)
2120 (error "Nothing saved for diff %d in buffer %S" (1+ n) buf-type)
2121 (error ediff-NO-DIFFERENCES)))
2123 (setq reg-beg (ediff-get-diff-posn buf-type 'beg n ediff-control-buffer))
2124 (setq reg-end (ediff-get-diff-posn buf-type 'end n ediff-control-buffer))
2126 (condition-case conds
2127 (ediff-with-current-buffer buf
2128 (let ((inhibit-read-only (null buffer-read-only)))
2130 (goto-char reg-end)
2131 (insert saved-diff)
2133 (if (> reg-end reg-beg)
2134 (kill-region reg-beg reg-end))
2136 (setq recovered t)
2138 (error (message "ediff-pop-diff: %s %s"
2139 (car conds)
2140 (mapconcat 'prin1-to-string (cdr conds) " "))
2141 (beep 1)))
2143 ;; Clearing fine diffs is necessary for
2144 ;; ediff-unselect-and-select-difference to properly recompute them. We
2145 ;; can't rely on ediff-copy-diff to clear this vector, as the user might
2146 ;; have modified diff regions after copying and, thus, may have recomputed
2147 ;; fine diffs.
2148 (if recovered
2149 (ediff-clear-fine-differences n))
2151 ;; adjust state of difference
2152 (if (and three-way recovered)
2153 (ediff-set-state-of-diff-in-all-buffers n ctl-buf))
2155 (ediff-refresh-mode-lines)
2157 (if recovered
2158 (progn
2159 (setq n-th-record (delq saved-rec n-th-record))
2160 (message "Diff region %d in buffer %S restored" (1+ n) buf-type)
2164 (defun ediff-restore-diff (arg &optional key)
2165 "Restore ARGth diff from `ediff-killed-diffs-alist'.
2166 ARG is a prefix argument. If ARG is nil, restore the current-difference.
2167 If the second optional argument, a character, is given, use it to
2168 determine the target buffer instead of (ediff-last-command-char)"
2169 (interactive "P")
2170 (ediff-barf-if-not-control-buffer)
2171 (if (numberp arg)
2172 (ediff-jump-to-difference arg))
2173 (ediff-pop-diff ediff-current-difference
2174 (ediff-char-to-buftype (or key (ediff-last-command-char))))
2175 ;; recenter with rehighlighting, but no messages
2176 (let (ediff-verbose-p)
2177 (ediff-recenter)))
2179 (defun ediff-restore-diff-in-merge-buffer (arg)
2180 "Restore ARGth diff in the merge buffer.
2181 ARG is a prefix argument. If nil, restore the current diff."
2182 (interactive "P")
2183 (ediff-restore-diff arg ?c))
2186 (defun ediff-toggle-regexp-match ()
2187 "Toggle between focusing and hiding of difference regions that match
2188 a regular expression typed in by the user."
2189 (interactive)
2190 (ediff-barf-if-not-control-buffer)
2191 (let ((regexp-A "")
2192 (regexp-B "")
2193 (regexp-C "")
2194 msg-connective alt-msg-connective alt-connective)
2195 (cond
2196 ((or (and (eq ediff-skip-diff-region-function
2197 ediff-focus-on-regexp-matches-function)
2198 (eq (ediff-last-command-char) ?f))
2199 (and (eq ediff-skip-diff-region-function
2200 ediff-hide-regexp-matches-function)
2201 (eq (ediff-last-command-char) ?h)))
2202 (message "Selective browsing by regexp turned off")
2203 (setq ediff-skip-diff-region-function 'ediff-show-all-diffs))
2204 ((eq (ediff-last-command-char) ?h)
2205 (setq ediff-skip-diff-region-function ediff-hide-regexp-matches-function
2206 regexp-A
2207 (read-string
2208 (format
2209 "Ignore A-regions matching this regexp (default %s): "
2210 ediff-regexp-hide-A))
2211 regexp-B
2212 (read-string
2213 (format
2214 "Ignore B-regions matching this regexp (default %s): "
2215 ediff-regexp-hide-B)))
2216 (if ediff-3way-comparison-job
2217 (setq regexp-C
2218 (read-string
2219 (format
2220 "Ignore C-regions matching this regexp (default %s): "
2221 ediff-regexp-hide-C))))
2222 (if (eq ediff-hide-regexp-connective 'and)
2223 (setq msg-connective "BOTH"
2224 alt-msg-connective "ONE OF"
2225 alt-connective 'or)
2226 (setq msg-connective "ONE OF"
2227 alt-msg-connective "BOTH"
2228 alt-connective 'and))
2229 (if (y-or-n-p
2230 (format
2231 "Ignore regions that match %s regexps, OK? "
2232 msg-connective))
2233 (message "Will ignore regions that match %s regexps" msg-connective)
2234 (setq ediff-hide-regexp-connective alt-connective)
2235 (message "Will ignore regions that match %s regexps"
2236 alt-msg-connective))
2238 (or (string= regexp-A "") (setq ediff-regexp-hide-A regexp-A))
2239 (or (string= regexp-B "") (setq ediff-regexp-hide-B regexp-B))
2240 (or (string= regexp-C "") (setq ediff-regexp-hide-C regexp-C)))
2242 ((eq (ediff-last-command-char) ?f)
2243 (setq ediff-skip-diff-region-function
2244 ediff-focus-on-regexp-matches-function
2245 regexp-A
2246 (read-string
2247 (format
2248 "Focus on A-regions matching this regexp (default %s): "
2249 ediff-regexp-focus-A))
2250 regexp-B
2251 (read-string
2252 (format
2253 "Focus on B-regions matching this regexp (default %s): "
2254 ediff-regexp-focus-B)))
2255 (if ediff-3way-comparison-job
2256 (setq regexp-C
2257 (read-string
2258 (format
2259 "Focus on C-regions matching this regexp (default %s): "
2260 ediff-regexp-focus-C))))
2261 (if (eq ediff-focus-regexp-connective 'and)
2262 (setq msg-connective "BOTH"
2263 alt-msg-connective "ONE OF"
2264 alt-connective 'or)
2265 (setq msg-connective "ONE OF"
2266 alt-msg-connective "BOTH"
2267 alt-connective 'and))
2268 (if (y-or-n-p
2269 (format
2270 "Focus on regions that match %s regexps, OK? "
2271 msg-connective))
2272 (message "Will focus on regions that match %s regexps"
2273 msg-connective)
2274 (setq ediff-focus-regexp-connective alt-connective)
2275 (message "Will focus on regions that match %s regexps"
2276 alt-msg-connective))
2278 (or (string= regexp-A "") (setq ediff-regexp-focus-A regexp-A))
2279 (or (string= regexp-B "") (setq ediff-regexp-focus-B regexp-B))
2280 (or (string= regexp-C "") (setq ediff-regexp-focus-C regexp-C))))))
2282 (defun ediff-toggle-skip-similar ()
2283 (interactive)
2284 (ediff-barf-if-not-control-buffer)
2285 (if (not (eq ediff-auto-refine 'on))
2286 (error
2287 "Can't skip over whitespace regions: first turn auto-refining on"))
2288 (setq ediff-ignore-similar-regions (not ediff-ignore-similar-regions))
2289 (if ediff-ignore-similar-regions
2290 (message
2291 "Skipping regions that differ only in white space & line breaks")
2292 (message "Skipping over white-space differences turned off")))
2294 (defun ediff-focus-on-regexp-matches (n)
2295 "Focus on diffs that match regexp `ediff-regexp-focus-A/B'.
2296 Regions to be ignored according to this function are those where
2297 buf A region doesn't match `ediff-regexp-focus-A' and buf B region
2298 doesn't match `ediff-regexp-focus-B'.
2299 This function returns nil if the region number N (specified as
2300 an argument) is not to be ignored and t if region N is to be ignored.
2302 N is a region number used by Ediff internally. It is 1 less
2303 the number seen by the user."
2304 (if (ediff-valid-difference-p n)
2305 (let* ((ctl-buf ediff-control-buffer)
2306 (regex-A ediff-regexp-focus-A)
2307 (regex-B ediff-regexp-focus-B)
2308 (regex-C ediff-regexp-focus-C)
2309 (reg-A-match (ediff-with-current-buffer ediff-buffer-A
2310 (save-restriction
2311 (narrow-to-region
2312 (ediff-get-diff-posn 'A 'beg n ctl-buf)
2313 (ediff-get-diff-posn 'A 'end n ctl-buf))
2314 (goto-char (point-min))
2315 (re-search-forward regex-A nil t))))
2316 (reg-B-match (ediff-with-current-buffer ediff-buffer-B
2317 (save-restriction
2318 (narrow-to-region
2319 (ediff-get-diff-posn 'B 'beg n ctl-buf)
2320 (ediff-get-diff-posn 'B 'end n ctl-buf))
2321 (re-search-forward regex-B nil t))))
2322 (reg-C-match (if ediff-3way-comparison-job
2323 (ediff-with-current-buffer ediff-buffer-C
2324 (save-restriction
2325 (narrow-to-region
2326 (ediff-get-diff-posn 'C 'beg n ctl-buf)
2327 (ediff-get-diff-posn 'C 'end n ctl-buf))
2328 (re-search-forward regex-C nil t))))))
2329 (not (eval (if ediff-3way-comparison-job
2330 (list ediff-focus-regexp-connective
2331 reg-A-match reg-B-match reg-C-match)
2332 (list ediff-focus-regexp-connective
2333 reg-A-match reg-B-match))))
2336 (defun ediff-hide-regexp-matches (n)
2337 "Hide diffs that match regexp `ediff-regexp-hide-A/B/C'.
2338 Regions to be ignored are those where buf A region matches
2339 `ediff-regexp-hide-A' and buf B region matches `ediff-regexp-hide-B'.
2340 This function returns nil if the region number N (specified as
2341 an argument) is not to be ignored and t if region N is to be ignored.
2343 N is a region number used by Ediff internally. It is 1 less
2344 the number seen by the user."
2345 (if (ediff-valid-difference-p n)
2346 (let* ((ctl-buf ediff-control-buffer)
2347 (regex-A ediff-regexp-hide-A)
2348 (regex-B ediff-regexp-hide-B)
2349 (regex-C ediff-regexp-hide-C)
2350 (reg-A-match (ediff-with-current-buffer ediff-buffer-A
2351 (save-restriction
2352 (narrow-to-region
2353 (ediff-get-diff-posn 'A 'beg n ctl-buf)
2354 (ediff-get-diff-posn 'A 'end n ctl-buf))
2355 (goto-char (point-min))
2356 (re-search-forward regex-A nil t))))
2357 (reg-B-match (ediff-with-current-buffer ediff-buffer-B
2358 (save-restriction
2359 (narrow-to-region
2360 (ediff-get-diff-posn 'B 'beg n ctl-buf)
2361 (ediff-get-diff-posn 'B 'end n ctl-buf))
2362 (goto-char (point-min))
2363 (re-search-forward regex-B nil t))))
2364 (reg-C-match (if ediff-3way-comparison-job
2365 (ediff-with-current-buffer ediff-buffer-C
2366 (save-restriction
2367 (narrow-to-region
2368 (ediff-get-diff-posn 'C 'beg n ctl-buf)
2369 (ediff-get-diff-posn 'C 'end n ctl-buf))
2370 (goto-char (point-min))
2371 (re-search-forward regex-C nil t))))))
2372 (eval (if ediff-3way-comparison-job
2373 (list ediff-hide-regexp-connective
2374 reg-A-match reg-B-match reg-C-match)
2375 (list ediff-hide-regexp-connective reg-A-match reg-B-match)))
2380 ;;; Quitting, suspending, etc.
2382 (defun ediff-quit (reverse-default-keep-variants)
2383 "Finish an Ediff session and exit Ediff.
2384 Unselects the selected difference, if any, restores the read-only and modified
2385 flags of the compared file buffers, kills Ediff buffers for this session
2386 \(but not buffers A, B, C\).
2388 If `ediff-keep-variants' is nil, the user will be asked whether the buffers
2389 containing the variants should be removed \(if they haven't been modified\).
2390 If it is t, they will be preserved unconditionally. A prefix argument,
2391 temporarily reverses the meaning of this variable."
2392 (interactive "P")
2393 (ediff-barf-if-not-control-buffer)
2394 (let ((ctl-buf (current-buffer))
2395 (ctl-frm (selected-frame))
2396 (minibuffer-auto-raise t))
2397 (if (y-or-n-p (format "Quit this Ediff session%s? "
2398 (if (ediff-buffer-live-p ediff-meta-buffer)
2399 " & show containing session group" "")))
2400 (progn
2401 (message "")
2402 (set-buffer ctl-buf)
2403 (ediff-really-quit reverse-default-keep-variants))
2404 (select-frame ctl-frm)
2405 (raise-frame ctl-frm)
2406 (message ""))))
2409 ;; Perform the quit operations.
2410 (defun ediff-really-quit (reverse-default-keep-variants)
2411 (ediff-unhighlight-diffs-totally)
2412 (ediff-clear-diff-vector 'ediff-difference-vector-A 'fine-diffs-also)
2413 (ediff-clear-diff-vector 'ediff-difference-vector-B 'fine-diffs-also)
2414 (ediff-clear-diff-vector 'ediff-difference-vector-C 'fine-diffs-also)
2415 (ediff-clear-diff-vector 'ediff-difference-vector-Ancestor 'fine-diffs-also)
2417 (ediff-delete-temp-files)
2419 ;; Restore the visibility range. This affects only ediff-*-regions/windows.
2420 ;; Since for other job names ediff-visible-region sets
2421 ;; ediff-visible-bounds to ediff-wide-bounds, the settings below are
2422 ;; ignored for such jobs.
2423 (if ediff-quit-widened
2424 (setq ediff-visible-bounds ediff-wide-bounds)
2425 (setq ediff-visible-bounds ediff-narrow-bounds))
2427 ;; Apply selective display to narrow or widen
2428 (ediff-visible-region)
2429 (mapc (lambda (overl)
2430 (if (ediff-overlayp overl)
2431 (ediff-delete-overlay overl)))
2432 ediff-wide-bounds)
2433 (mapc (lambda (overl)
2434 (if (ediff-overlayp overl)
2435 (ediff-delete-overlay overl)))
2436 ediff-narrow-bounds)
2438 ;; restore buffer mode line id's in buffer-A/B/C
2439 (let ((control-buffer ediff-control-buffer)
2440 (meta-buffer ediff-meta-buffer)
2441 (after-quit-hook-internal ediff-after-quit-hook-internal)
2442 (session-number ediff-meta-session-number)
2443 ;; suitable working frame
2444 (warp-frame (if (and (ediff-window-display-p) (eq ediff-grab-mouse t))
2445 (cond ((window-live-p ediff-window-A)
2446 (window-frame ediff-window-A))
2447 ((window-live-p ediff-window-B)
2448 (window-frame ediff-window-B))
2449 (t (next-frame))))))
2450 (condition-case nil
2451 (ediff-with-current-buffer ediff-buffer-A
2452 (setq ediff-this-buffer-ediff-sessions
2453 (delq control-buffer ediff-this-buffer-ediff-sessions))
2454 (kill-local-variable 'mode-line-buffer-identification)
2455 (kill-local-variable 'mode-line-format)
2457 (error))
2459 (condition-case nil
2460 (ediff-with-current-buffer ediff-buffer-B
2461 (setq ediff-this-buffer-ediff-sessions
2462 (delq control-buffer ediff-this-buffer-ediff-sessions))
2463 (kill-local-variable 'mode-line-buffer-identification)
2464 (kill-local-variable 'mode-line-format)
2466 (error))
2468 (condition-case nil
2469 (ediff-with-current-buffer ediff-buffer-C
2470 (setq ediff-this-buffer-ediff-sessions
2471 (delq control-buffer ediff-this-buffer-ediff-sessions))
2472 (kill-local-variable 'mode-line-buffer-identification)
2473 (kill-local-variable 'mode-line-format)
2475 (error))
2477 (condition-case nil
2478 (ediff-with-current-buffer ediff-ancestor-buffer
2479 (setq ediff-this-buffer-ediff-sessions
2480 (delq control-buffer ediff-this-buffer-ediff-sessions))
2481 (kill-local-variable 'mode-line-buffer-identification)
2482 (kill-local-variable 'mode-line-format)
2484 (error))
2486 (setq ediff-session-registry
2487 (delq ediff-control-buffer ediff-session-registry))
2488 (ediff-update-registry)
2489 ;; restore state of buffers to what it was before ediff
2490 (ediff-restore-protected-variables)
2492 ;; If the user interrupts (canceling saving the merge buffer), continue
2493 ;; normally.
2494 (condition-case nil
2495 (if (ediff-merge-job)
2496 (run-hooks 'ediff-quit-merge-hook))
2497 (quit))
2499 (run-hooks 'ediff-cleanup-hook)
2501 (ediff-janitor
2502 'ask
2503 ;; reverse-default-keep-variants is t if the user quits with a prefix arg
2504 (if reverse-default-keep-variants
2505 (not ediff-keep-variants)
2506 ediff-keep-variants))
2508 ;; one hook here is ediff-cleanup-mess, which kills the control buffer and
2509 ;; other auxiliary buffers. we made it into a hook to let the users do their
2510 ;; own cleanup, if needed.
2511 (run-hooks 'ediff-quit-hook)
2512 (ediff-update-meta-buffer meta-buffer nil session-number)
2514 ;; warp mouse into a working window
2515 (setq warp-frame ; if mouse is over a reasonable frame, use it
2516 (cond ((ediff-good-frame-under-mouse))
2517 (t warp-frame)))
2518 (if (and (ediff-window-display-p) (frame-live-p warp-frame) ediff-grab-mouse)
2519 (set-mouse-position (if (featurep 'emacs)
2520 warp-frame
2521 (frame-selected-window warp-frame))
2522 2 1))
2524 (run-hooks 'after-quit-hook-internal)
2527 ;; Returns frame under mouse, if this frame is not a minibuffer
2528 ;; frame. Otherwise: nil
2529 (defun ediff-good-frame-under-mouse ()
2530 (let ((frame-or-win (car (mouse-position)))
2531 (buf-name "")
2532 frame obj-ok)
2533 (setq obj-ok
2534 (if (featurep 'emacs)
2535 (frame-live-p frame-or-win)
2536 (window-live-p frame-or-win)))
2537 (if obj-ok
2538 (setq frame (if (featurep 'emacs) frame-or-win (window-frame frame-or-win))
2539 buf-name
2540 (buffer-name (window-buffer (frame-selected-window frame)))))
2541 (if (string-match "Minibuf" buf-name)
2543 frame)))
2546 (defun ediff-delete-temp-files ()
2547 (if (and (stringp ediff-temp-file-A) (file-exists-p ediff-temp-file-A))
2548 (delete-file ediff-temp-file-A))
2549 (if (and (stringp ediff-temp-file-B) (file-exists-p ediff-temp-file-B))
2550 (delete-file ediff-temp-file-B))
2551 (if (and (stringp ediff-temp-file-C) (file-exists-p ediff-temp-file-C))
2552 (delete-file ediff-temp-file-C)))
2555 ;; Kill control buffer, other auxiliary Ediff buffers.
2556 ;; Leave one of the frames split between buffers A/B/C
2557 (defun ediff-cleanup-mess ()
2558 (let* ((buff-A ediff-buffer-A)
2559 (buff-B ediff-buffer-B)
2560 (buff-C ediff-buffer-C)
2561 (ctl-buf ediff-control-buffer)
2562 (ctl-wind (ediff-get-visible-buffer-window ctl-buf))
2563 (ctl-frame ediff-control-frame)
2564 (three-way-job ediff-3way-job)
2565 (main-frame (cond ((window-live-p ediff-window-A)
2566 (window-frame ediff-window-A))
2567 ((window-live-p ediff-window-B)
2568 (window-frame ediff-window-B)))))
2570 (ediff-kill-buffer-carefully ediff-diff-buffer)
2571 (ediff-kill-buffer-carefully ediff-custom-diff-buffer)
2572 (ediff-kill-buffer-carefully ediff-fine-diff-buffer)
2573 (ediff-kill-buffer-carefully ediff-tmp-buffer)
2574 (ediff-kill-buffer-carefully ediff-error-buffer)
2575 (ediff-kill-buffer-carefully ediff-msg-buffer)
2576 (ediff-kill-buffer-carefully ediff-debug-buffer)
2577 (if (boundp 'ediff-patch-diagnostics)
2578 (ediff-kill-buffer-carefully ediff-patch-diagnostics))
2580 ;; delete control frame or window
2581 (cond ((and (ediff-window-display-p) (frame-live-p ctl-frame))
2582 (delete-frame ctl-frame))
2583 ((window-live-p ctl-wind)
2584 (delete-window ctl-wind)))
2586 ;; Hide bottom toolbar. --marcpa
2587 (if (not (ediff-multiframe-setup-p))
2588 (ediff-kill-bottom-toolbar))
2590 (ediff-kill-buffer-carefully ctl-buf)
2592 (if (frame-live-p main-frame)
2593 (select-frame main-frame))
2595 ;; display only if not visible
2596 (condition-case nil
2597 (or (ediff-get-visible-buffer-window buff-B)
2598 (switch-to-buffer buff-B))
2599 (error))
2600 (condition-case nil
2601 (or (ediff-get-visible-buffer-window buff-A)
2602 (progn
2603 (if (and (ediff-get-visible-buffer-window buff-B)
2604 (ediff-buffer-live-p buff-A))
2605 (funcall ediff-split-window-function))
2606 (switch-to-buffer buff-A)))
2607 (error))
2608 (if three-way-job
2609 (condition-case nil
2610 (or (ediff-get-visible-buffer-window buff-C)
2611 (progn
2612 (if (and (or (ediff-get-visible-buffer-window buff-A)
2613 (ediff-get-visible-buffer-window buff-B))
2614 (ediff-buffer-live-p buff-C))
2615 (funcall ediff-split-window-function))
2616 (switch-to-buffer buff-C)))
2617 (error)))
2618 (balance-windows)
2619 (message "")
2622 (defun ediff-janitor (ask keep-variants)
2623 "Kill buffers A, B, and, possibly, C, if these buffers aren't modified.
2624 In merge jobs, buffer C is not deleted here, but rather according to
2625 ediff-quit-merge-hook.
2626 A side effect of cleaning up may be that you should be careful when comparing
2627 the same buffer in two separate Ediff sessions: quitting one of them might
2628 delete this buffer in another session as well."
2629 (ediff-dispose-of-variant-according-to-user
2630 ediff-buffer-A 'A ask keep-variants)
2631 (ediff-dispose-of-variant-according-to-user
2632 ediff-buffer-B 'B ask keep-variants)
2633 (if ediff-merge-job ; don't del buf C if merging--del ancestor buf instead
2634 (ediff-dispose-of-variant-according-to-user
2635 ediff-ancestor-buffer 'Ancestor ask keep-variants)
2636 (ediff-dispose-of-variant-according-to-user
2637 ediff-buffer-C 'C ask keep-variants)
2640 ;; Kill the variant buffer, according to user directives (ask, kill
2641 ;; unconditionally, keep)
2642 ;; BUFF is the buffer, BUFF-TYPE is either 'A, or 'B, 'C, 'Ancestor
2643 (defun ediff-dispose-of-variant-according-to-user (buff bufftype ask keep-variants)
2644 ;; if this is indirect buffer, kill it and substitute with direct buf
2645 (if (and (ediff-buffer-live-p buff)
2646 (ediff-with-current-buffer buff ediff-temp-indirect-buffer))
2647 (let ((wind (ediff-get-visible-buffer-window buff))
2648 (base (buffer-base-buffer buff))
2649 (modified-p (buffer-modified-p buff)))
2650 (if (and (window-live-p wind) (ediff-buffer-live-p base))
2651 (set-window-buffer wind base))
2652 ;; Kill indirect buffer even if it is modified, because the base buffer
2653 ;; is still there. Note that if the base buffer is dead then so will be
2654 ;; the indirect buffer
2655 (ediff-with-current-buffer buff
2656 (set-buffer-modified-p nil))
2657 (ediff-kill-buffer-carefully buff)
2658 (ediff-with-current-buffer base
2659 (set-buffer-modified-p modified-p)))
2660 ;; otherwise, ask or use the value of keep-variants
2661 (or (not (ediff-buffer-live-p buff))
2662 keep-variants
2663 (buffer-modified-p buff)
2664 (and ask
2665 (not (y-or-n-p (format "Kill buffer %S [%s]? "
2666 bufftype (buffer-name buff)))))
2667 (ediff-kill-buffer-carefully buff))
2670 (defun ediff-maybe-save-and-delete-merge (&optional save-and-continue)
2671 "Default hook to run on quitting a merge job.
2672 This can also be used to save merge buffer in the middle of an Ediff session.
2674 If the optional SAVE-AND-CONTINUE argument is non-nil, save merge buffer and
2675 continue. Otherwise:
2676 If `ediff-autostore-merges' is nil, this does nothing.
2677 If it is t, it saves the merge buffer in the file `ediff-merge-store-file'
2678 or asks the user, if the latter is nil. It then asks the user whether to
2679 delete the merge buffer.
2680 If `ediff-autostore-merges' is neither nil nor t, the merge buffer is saved
2681 only if this merge job is part of a group, i.e., was invoked from within
2682 `ediff-merge-directories', `ediff-merge-directory-revisions', and such."
2683 (let ((merge-store-file ediff-merge-store-file)
2684 (ediff-autostore-merges ; fake ediff-autostore-merges, if necessary
2685 (if save-and-continue t ediff-autostore-merges)))
2686 (if ediff-autostore-merges
2687 (cond ((stringp merge-store-file)
2688 ;; store, ask to delete
2689 (ediff-write-merge-buffer-and-maybe-kill
2690 ediff-buffer-C merge-store-file 'show-file save-and-continue))
2691 ((eq ediff-autostore-merges t)
2692 ;; ask for file name
2693 (setq merge-store-file
2694 (read-file-name "Save the result of the merge in file: "))
2695 (ediff-write-merge-buffer-and-maybe-kill
2696 ediff-buffer-C merge-store-file nil save-and-continue))
2697 ((and (ediff-buffer-live-p ediff-meta-buffer)
2698 (ediff-with-current-buffer ediff-meta-buffer
2699 (ediff-merge-metajob)))
2700 ;; The parent metajob passed nil as the autostore file.
2701 nil)))
2704 ;; write merge buffer. If the optional argument save-and-continue is non-nil,
2705 ;; then don't kill the merge buffer
2706 (defun ediff-write-merge-buffer-and-maybe-kill (buf file
2707 &optional
2708 show-file save-and-continue)
2709 (if (not (eq (find-buffer-visiting file) buf))
2710 (let ((warn-message
2711 (format "Another buffer is visiting file %s. Too dangerous to save the merge buffer"
2712 file)))
2713 (beep)
2714 (message "%s" warn-message)
2715 (with-output-to-temp-buffer ediff-msg-buffer
2716 (princ "\n\n")
2717 (princ warn-message)
2718 (princ "\n\n")
2720 (sit-for 2))
2721 (ediff-with-current-buffer buf
2722 (if (or (not (file-exists-p file))
2723 (y-or-n-p (format "File %s exists, overwrite? " file)))
2724 (progn
2725 ;;(write-region nil nil file)
2726 (ediff-with-current-buffer buf
2727 (set-visited-file-name file)
2728 (save-buffer))
2729 (if show-file
2730 (progn
2731 (message "Merge buffer saved in: %s" file)
2732 (set-buffer-modified-p nil)
2733 (sit-for 3)))
2734 (if (and
2735 (not save-and-continue)
2736 (y-or-n-p "Merge buffer saved. Now kill the buffer? "))
2737 (ediff-kill-buffer-carefully buf)))))
2740 ;; The default way of suspending Ediff.
2741 ;; Buries Ediff buffers, kills all windows.
2742 (defun ediff-default-suspend-function ()
2743 (let* ((buf-A ediff-buffer-A)
2744 (buf-B ediff-buffer-B)
2745 (buf-C ediff-buffer-C)
2746 (buf-A-wind (ediff-get-visible-buffer-window buf-A))
2747 (buf-B-wind (ediff-get-visible-buffer-window buf-B))
2748 (buf-C-wind (ediff-get-visible-buffer-window buf-C))
2749 (buf-patch (if (boundp 'ediff-patchbufer) ediff-patchbufer nil))
2750 (buf-patch-diag (if (boundp 'ediff-patch-diagnostics)
2751 ediff-patch-diagnostics nil))
2752 (buf-err ediff-error-buffer)
2753 (buf-diff ediff-diff-buffer)
2754 (buf-custom-diff ediff-custom-diff-buffer)
2755 (buf-fine-diff ediff-fine-diff-buffer))
2757 ;; hide the control panel
2758 (if (and (ediff-window-display-p) (frame-live-p ediff-control-frame))
2759 (iconify-frame ediff-control-frame)
2760 (bury-buffer))
2761 (if buf-err (bury-buffer buf-err))
2762 (if buf-diff (bury-buffer buf-diff))
2763 (if buf-custom-diff (bury-buffer buf-custom-diff))
2764 (if buf-fine-diff (bury-buffer buf-fine-diff))
2765 (if buf-patch (bury-buffer buf-patch))
2766 (if buf-patch-diag (bury-buffer buf-patch-diag))
2767 (if (window-live-p buf-A-wind)
2768 (progn
2769 (select-window buf-A-wind)
2770 (delete-other-windows)
2771 (bury-buffer))
2772 (if (ediff-buffer-live-p buf-A)
2773 (progn
2774 (set-buffer buf-A)
2775 (bury-buffer))))
2776 (if (window-live-p buf-B-wind)
2777 (progn
2778 (select-window buf-B-wind)
2779 (delete-other-windows)
2780 (bury-buffer))
2781 (if (ediff-buffer-live-p buf-B)
2782 (progn
2783 (set-buffer buf-B)
2784 (bury-buffer))))
2785 (if (window-live-p buf-C-wind)
2786 (progn
2787 (select-window buf-C-wind)
2788 (delete-other-windows)
2789 (bury-buffer))
2790 (if (ediff-buffer-live-p buf-C)
2791 (progn
2792 (set-buffer buf-C)
2793 (bury-buffer))))
2797 (defun ediff-suspend ()
2798 "Suspend Ediff.
2799 To resume, switch to the appropriate `Ediff Control Panel'
2800 buffer and then type \\[ediff-recenter]. Ediff will automatically set
2801 up an appropriate window config."
2802 (interactive)
2803 (ediff-barf-if-not-control-buffer)
2804 (run-hooks 'ediff-suspend-hook)
2805 (message
2806 "To resume, type M-x eregistry and select the desired Ediff session"))
2808 ;; ediff-barf-if-not-control-buffer ensures only called from ediff.
2809 (declare-function ediff-version "ediff" ())
2811 (defun ediff-status-info ()
2812 "Show the names of the buffers or files being operated on by Ediff.
2813 Hit \\[ediff-recenter] to reset the windows afterward."
2814 (interactive)
2815 (ediff-barf-if-not-control-buffer)
2816 (save-excursion
2817 (ediff-skip-unsuitable-frames))
2818 (with-output-to-temp-buffer ediff-msg-buffer
2819 (ediff-with-current-buffer standard-output
2820 (fundamental-mode))
2821 (raise-frame)
2822 (princ (ediff-version))
2823 (princ "\n\n")
2824 (ediff-with-current-buffer ediff-buffer-A
2825 (if buffer-file-name
2826 (princ
2827 (format "File A = %S\n" buffer-file-name))
2828 (princ
2829 (format "Buffer A = %S\n" (buffer-name)))))
2830 (ediff-with-current-buffer ediff-buffer-B
2831 (if buffer-file-name
2832 (princ
2833 (format "File B = %S\n" buffer-file-name))
2834 (princ
2835 (format "Buffer B = %S\n" (buffer-name)))))
2836 (if ediff-3way-job
2837 (ediff-with-current-buffer ediff-buffer-C
2838 (if buffer-file-name
2839 (princ
2840 (format "File C = %S\n" buffer-file-name))
2841 (princ
2842 (format "Buffer C = %S\n" (buffer-name))))))
2843 (princ (format "Customized diff output %s\n"
2844 (if (ediff-buffer-live-p ediff-custom-diff-buffer)
2845 (concat "\tin buffer "
2846 (buffer-name ediff-custom-diff-buffer))
2847 " is not available")))
2848 (princ (format "Plain diff output %s\n"
2849 (if (ediff-buffer-live-p ediff-diff-buffer)
2850 (concat "\tin buffer "
2851 (buffer-name ediff-diff-buffer))
2852 " is not available")))
2854 (let* ((A-line (ediff-with-current-buffer ediff-buffer-A
2855 (1+ (count-lines (point-min) (point)))))
2856 (B-line (ediff-with-current-buffer ediff-buffer-B
2857 (1+ (count-lines (point-min) (point)))))
2858 C-line)
2859 (princ (format "\Buffer A's point is on line %d\n" A-line))
2860 (princ (format "Buffer B's point is on line %d\n" B-line))
2861 (if ediff-3way-job
2862 (progn
2863 (setq C-line (ediff-with-current-buffer ediff-buffer-C
2864 (1+ (count-lines (point-min) (point)))))
2865 (princ (format "Buffer C's point is on line %d\n" C-line)))))
2867 (princ (format "\nCurrent difference number = %S\n"
2868 (cond ((< ediff-current-difference 0) 'start)
2869 ((>= ediff-current-difference
2870 ediff-number-of-differences) 'end)
2871 (t (1+ ediff-current-difference)))))
2873 (princ
2874 (format "\n%s regions that differ in white space & line breaks only"
2875 (if ediff-ignore-similar-regions
2876 "Ignoring" "Showing")))
2877 (if (and ediff-merge-job ediff-show-clashes-only)
2878 (princ
2879 "\nFocusing on regions where both buffers differ from the ancestor"))
2880 (if (and ediff-skip-merge-regions-that-differ-from-default ediff-merge-job)
2881 (princ
2882 "\nSkipping merge regions that differ from default setting"))
2884 (cond ((eq ediff-skip-diff-region-function 'ediff-show-all-diffs)
2885 (princ "\nSelective browsing by regexp is off\n"))
2886 ((eq ediff-skip-diff-region-function
2887 ediff-hide-regexp-matches-function)
2888 (princ
2889 "\nIgnoring regions that match")
2890 (princ
2891 (format
2892 "\n\t regexp `%s' in buffer A %S\n\t regexp `%s' in buffer B\n"
2893 ediff-regexp-hide-A ediff-hide-regexp-connective
2894 ediff-regexp-hide-B)))
2895 ((eq ediff-skip-diff-region-function
2896 ediff-focus-on-regexp-matches-function)
2897 (princ
2898 "\nFocusing on regions that match")
2899 (princ
2900 (format
2901 "\n\t regexp `%s' in buffer A %S\n\t regexp `%s' in buffer B\n"
2902 ediff-regexp-focus-A ediff-focus-regexp-connective
2903 ediff-regexp-focus-B)))
2904 (t (princ "\nSelective browsing via a user-defined method.\n")))
2906 (princ
2907 (format "\nBugs/suggestions: type `%s' while in Ediff Control Panel."
2908 (substitute-command-keys "\\[ediff-submit-report]")))
2909 ) ; with output
2910 (if (frame-live-p ediff-control-frame)
2911 (ediff-reset-mouse ediff-control-frame))
2912 (if (window-live-p ediff-control-window)
2913 (select-window ediff-control-window)))
2918 ;;; Support routines
2920 ;; Select a difference by placing the ASCII flags around the appropriate
2921 ;; group of lines in the A, B buffers
2922 ;; This may have to be modified for buffer C, when it will be supported.
2923 (defun ediff-select-difference (n)
2924 (if (and (ediff-buffer-live-p ediff-buffer-A)
2925 (ediff-buffer-live-p ediff-buffer-B)
2926 (ediff-valid-difference-p n))
2927 (progn
2928 (cond
2929 ((and (ediff-has-face-support-p) ediff-use-faces)
2930 (ediff-highlight-diff n))
2931 ((eq ediff-highlighting-style 'ascii)
2932 (ediff-place-flags-in-buffer
2933 'A ediff-buffer-A ediff-control-buffer n)
2934 (ediff-place-flags-in-buffer
2935 'B ediff-buffer-B ediff-control-buffer n)
2936 (if ediff-3way-job
2937 (ediff-place-flags-in-buffer
2938 'C ediff-buffer-C ediff-control-buffer n))
2939 (if (ediff-buffer-live-p ediff-ancestor-buffer)
2940 (ediff-place-flags-in-buffer
2941 'Ancestor ediff-ancestor-buffer
2942 ediff-control-buffer n))
2945 (ediff-install-fine-diff-if-necessary n)
2946 ;; set current difference here so the hook will be able to refer to it
2947 (setq ediff-current-difference n)
2948 (run-hooks 'ediff-select-hook))))
2951 ;; Unselect a difference by removing the ASCII flags in the buffers.
2952 ;; This may have to be modified for buffer C, when it will be supported.
2953 (defun ediff-unselect-difference (n)
2954 (if (ediff-valid-difference-p n)
2955 (progn
2956 (cond ((and (ediff-has-face-support-p) ediff-use-faces)
2957 (ediff-unhighlight-diff))
2958 ((eq ediff-highlighting-style 'ascii)
2959 (ediff-remove-flags-from-buffer
2960 ediff-buffer-A
2961 (ediff-get-diff-overlay n 'A))
2962 (ediff-remove-flags-from-buffer
2963 ediff-buffer-B
2964 (ediff-get-diff-overlay n 'B))
2965 (if ediff-3way-job
2966 (ediff-remove-flags-from-buffer
2967 ediff-buffer-C
2968 (ediff-get-diff-overlay n 'C)))
2969 (if (ediff-buffer-live-p ediff-ancestor-buffer)
2970 (ediff-remove-flags-from-buffer
2971 ediff-ancestor-buffer
2972 (ediff-get-diff-overlay n 'Ancestor)))
2975 ;; unhighlight fine diffs
2976 (ediff-set-fine-diff-properties ediff-current-difference 'default)
2977 (run-hooks 'ediff-unselect-hook))))
2980 ;; Unselects prev diff and selects a new one, if FLAG has value other than
2981 ;; 'select-only or 'unselect-only. If FLAG is 'select-only, the
2982 ;; next difference is selected, but the current selection is not
2983 ;; unselected. If FLAG is 'unselect-only then the current selection is
2984 ;; unselected, but the next one is not selected. If NO-RECENTER is non-nil,
2985 ;; don't recenter buffers after selecting/unselecting.
2986 (defun ediff-unselect-and-select-difference (n &optional flag no-recenter)
2987 (let ((ediff-current-difference n))
2988 (or no-recenter
2989 (ediff-recenter 'no-rehighlight)))
2991 (let ((control-buf ediff-control-buffer))
2992 (unwind-protect
2993 (progn
2994 (or (eq flag 'select-only)
2995 (ediff-unselect-difference ediff-current-difference))
2997 (or (eq flag 'unselect-only)
2998 (ediff-select-difference n))
2999 ;; need to set current diff here even though it is also set in
3000 ;; ediff-select-difference because ediff-select-difference might not
3001 ;; be called if unselect-only is specified
3002 (setq ediff-current-difference n)
3003 ) ; end protected section
3005 (ediff-with-current-buffer control-buf (ediff-refresh-mode-lines)))
3010 (defun ediff-highlight-diff-in-one-buffer (n buf-type)
3011 (if (ediff-buffer-live-p (ediff-get-buffer buf-type))
3012 (let* ((buff (ediff-get-buffer buf-type))
3013 (last (ediff-with-current-buffer buff (point-max)))
3014 (begin (ediff-get-diff-posn buf-type 'beg n))
3015 (end (ediff-get-diff-posn buf-type 'end n))
3016 (xtra (if (equal begin end) 1 0))
3017 (end-hilit (min last (+ end xtra)))
3018 (current-diff-overlay
3019 (symbol-value
3020 (ediff-get-symbol-from-alist
3021 buf-type ediff-current-diff-overlay-alist))))
3023 (if (featurep 'xemacs)
3024 (ediff-move-overlay current-diff-overlay begin end-hilit)
3025 (ediff-move-overlay current-diff-overlay begin end-hilit buff))
3026 (ediff-overlay-put current-diff-overlay 'priority
3027 (ediff-highest-priority begin end-hilit buff))
3028 (ediff-overlay-put current-diff-overlay 'ediff-diff-num n)
3030 ;; unhighlight the background overlay for diff n so it won't
3031 ;; interfere with the current diff overlay
3032 (ediff-set-overlay-face (ediff-get-diff-overlay n buf-type) nil)
3036 (defun ediff-unhighlight-diff-in-one-buffer (buf-type)
3037 (if (ediff-buffer-live-p (ediff-get-buffer buf-type))
3038 (let ((current-diff-overlay
3039 (symbol-value
3040 (ediff-get-symbol-from-alist
3041 buf-type ediff-current-diff-overlay-alist)))
3042 (overlay
3043 (ediff-get-diff-overlay ediff-current-difference buf-type))
3046 (ediff-move-overlay current-diff-overlay 1 1)
3048 ;; rehighlight the overlay in the background of the
3049 ;; current difference region
3050 (ediff-set-overlay-face
3051 overlay
3052 (if (and (ediff-has-face-support-p)
3053 ediff-use-faces ediff-highlight-all-diffs)
3054 (ediff-background-face buf-type ediff-current-difference)))
3057 (defun ediff-unhighlight-diffs-totally-in-one-buffer (buf-type)
3058 (ediff-unselect-and-select-difference -1)
3059 (if (and (ediff-has-face-support-p) ediff-use-faces)
3060 (let* ((inhibit-quit t)
3061 (current-diff-overlay-var
3062 (ediff-get-symbol-from-alist
3063 buf-type ediff-current-diff-overlay-alist))
3064 (current-diff-overlay (symbol-value current-diff-overlay-var)))
3065 (ediff-paint-background-regions 'unhighlight)
3066 (if (ediff-overlayp current-diff-overlay)
3067 (ediff-delete-overlay current-diff-overlay))
3068 (set current-diff-overlay-var nil)
3072 (defun ediff-highlight-diff (n)
3073 "Put face on diff N. Invoked for X displays only."
3074 (ediff-highlight-diff-in-one-buffer n 'A)
3075 (ediff-highlight-diff-in-one-buffer n 'B)
3076 (ediff-highlight-diff-in-one-buffer n 'C)
3077 (ediff-highlight-diff-in-one-buffer n 'Ancestor)
3081 (defun ediff-unhighlight-diff ()
3082 "Remove overlays from buffers A, B, and C."
3083 (ediff-unhighlight-diff-in-one-buffer 'A)
3084 (ediff-unhighlight-diff-in-one-buffer 'B)
3085 (ediff-unhighlight-diff-in-one-buffer 'C)
3086 (ediff-unhighlight-diff-in-one-buffer 'Ancestor)
3089 ;; delete highlighting overlays, restore faces to their original form
3090 (defun ediff-unhighlight-diffs-totally ()
3091 (ediff-unhighlight-diffs-totally-in-one-buffer 'A)
3092 (ediff-unhighlight-diffs-totally-in-one-buffer 'B)
3093 (ediff-unhighlight-diffs-totally-in-one-buffer 'C)
3094 (ediff-unhighlight-diffs-totally-in-one-buffer 'Ancestor)
3098 ;; for compatibility
3099 (defmacro ediff-minibuffer-with-setup-hook (fun &rest body)
3100 `(if (fboundp 'minibuffer-with-setup-hook)
3101 (minibuffer-with-setup-hook ,fun ,@body)
3102 ,@body))
3104 ;; This is adapted from a similar function in `emerge.el'.
3105 ;; PROMPT should not have a trailing ': ', so that it can be modified
3106 ;; according to context.
3107 ;; If DEFAULT-FILE is set, it should be used as the default value.
3108 ;; If DEFAULT-DIR is non-nil, use it as the default directory.
3109 ;; Otherwise, use the value of `default-directory.'
3110 (defun ediff-read-file-name (prompt default-dir default-file &optional no-dirs)
3111 ;; hack default-dir if it is not set
3112 (setq default-dir
3113 (file-name-as-directory
3114 (ediff-abbreviate-file-name
3115 (expand-file-name (or default-dir
3116 (and default-file
3117 (file-name-directory default-file))
3118 default-directory)))))
3120 ;; strip the directory from default-file
3121 (if default-file
3122 (setq default-file (file-name-nondirectory default-file)))
3123 (if (string= default-file "")
3124 (setq default-file nil))
3126 (let ((defaults (and (fboundp 'dired-dwim-target-defaults)
3127 (dired-dwim-target-defaults
3128 (and default-file (list default-file))
3129 default-dir)))
3131 (setq f (ediff-minibuffer-with-setup-hook
3132 (lambda () (when defaults
3133 (setq minibuffer-default defaults)))
3134 (read-file-name
3135 (format "%s%s "
3136 prompt
3137 (cond (default-file
3138 (concat " (default " default-file "):"))
3139 (t (concat " (default " default-dir "):"))))
3140 default-dir
3141 (or default-file default-dir)
3142 t ; must match, no-confirm
3143 (if default-file (file-name-directory default-file)))))
3144 (setq f (expand-file-name f default-dir))
3145 ;; If user entered a directory name, expand the default file in that
3146 ;; directory. This allows the user to enter a directory name for the
3147 ;; B-file and diff against the default-file in that directory instead
3148 ;; of a DIRED listing!
3149 (if (and (file-directory-p f) default-file)
3150 (setq f (expand-file-name
3151 (file-name-nondirectory default-file) f)))
3152 (if (and no-dirs (file-directory-p f))
3153 (error "File %s is a directory" f))
3156 ;; If PREFIX is given, then it is used as a prefix for the temp file
3157 ;; name. Otherwise, `ediff' is used. If FILE is given, use this
3158 ;; file and don't create a new one.
3159 ;; In MS-DOS, make sure the prefix isn't too long, or else
3160 ;; `make-temp-name' isn't guaranteed to return a unique filename.
3161 ;; Also, save buffer from START to END in the file.
3162 ;; START defaults to (point-min), END to (point-max)
3163 (defun ediff-make-temp-file (buff &optional prefix given-file start end)
3164 (let* ((p (ediff-convert-standard-filename (or prefix "ediff")))
3165 (short-p p)
3166 (coding-system-for-write ediff-coding-system-for-write)
3167 f short-f)
3168 (if (and (fboundp 'msdos-long-file-names)
3169 (not (msdos-long-file-names))
3170 (> (length p) 2))
3171 (setq short-p (substring p 0 2)))
3173 (setq f (concat ediff-temp-file-prefix p)
3174 short-f (concat ediff-temp-file-prefix short-p)
3175 f (cond (given-file)
3176 ((find-file-name-handler f 'insert-file-contents)
3177 ;; to thwart file handlers in write-region, e.g., if file
3178 ;; name ends with .Z or .gz
3179 ;; This is needed so that patches produced by ediff will
3180 ;; have more meaningful names
3181 (ediff-make-empty-tmp-file short-f))
3182 (prefix
3183 ;; Prefix is most often the same as the file name for the
3184 ;; variant. Here we are trying to use the original file
3185 ;; name but in the temp directory.
3186 (ediff-make-empty-tmp-file f 'keep-name))
3188 ;; If don't care about name, add some random stuff
3189 ;; to proposed file name.
3190 (ediff-make-empty-tmp-file short-f))))
3192 ;; create the file
3193 (ediff-with-current-buffer buff
3194 (write-region (if start start (point-min))
3195 (if end end (point-max))
3197 nil ; don't append---erase
3198 'no-message)
3199 (set-file-modes f ediff-temp-file-mode)
3200 (expand-file-name f))))
3202 ;; Create a temporary file.
3203 ;; The returned file name (created by appending some random characters at the
3204 ;; end of PROPOSED-NAME is guaranteed to point to a newly created empty file.
3205 ;; This is a replacement for make-temp-name, which eliminates a security hole.
3206 ;; If KEEP-PROPOSED-NAME isn't nil, try to keep PROPOSED-NAME, unless such file
3207 ;; already exists.
3208 ;; It is a modified version of make-temp-file in emacs 20.5
3209 (defun ediff-make-empty-tmp-file (proposed-name &optional keep-proposed-name)
3210 (let ((file proposed-name))
3211 (while (condition-case ()
3212 (progn
3213 (if (or (file-exists-p file) (not keep-proposed-name))
3214 (setq file (make-temp-name proposed-name)))
3215 ;; the with-temp-buffer thing is a workaround for an XEmacs
3216 ;; bug: write-region complains that we are trying to visit a
3217 ;; file in an indirect buffer, failing to notice that the
3218 ;; VISIT flag is unset and that we are actually writing from a
3219 ;; string and not from any buffer.
3220 (with-temp-buffer
3221 (write-region "" nil file nil 'silent nil 'excl))
3222 nil)
3223 (file-already-exists t))
3224 ;; the file was somehow created by someone else between
3225 ;; `make-temp-name' and `write-region', let's try again.
3226 nil)
3227 file))
3230 ;; Quote metacharacters (using \) when executing diff in Unix, but not in
3231 ;; EMX OS/2
3232 ;;(defun ediff-protect-metachars (str)
3233 ;; (or (memq system-type '(emx))
3234 ;; (let ((limit 0))
3235 ;; (while (string-match ediff-metachars str limit)
3236 ;; (setq str (concat (substring str 0 (match-beginning 0))
3237 ;; "\\"
3238 ;; (substring str (match-beginning 0))))
3239 ;; (setq limit (1+ (match-end 0))))))
3240 ;; str)
3242 ;; Make sure the current buffer (for a file) has the same contents as the
3243 ;; file on disk, and attempt to remedy the situation if not.
3244 ;; Signal an error if we can't make them the same, or the user doesn't want
3245 ;; to do what is necessary to make them the same.
3246 ;; Also, Ediff always offers to revert obsolete buffers, whether they
3247 ;; are modified or not.
3248 (defun ediff-verify-file-buffer (&optional file-magic)
3249 ;; First check if the file has been modified since the buffer visited it.
3250 (if (verify-visited-file-modtime (current-buffer))
3251 (if (buffer-modified-p)
3252 ;; If buffer is not obsolete and is modified, offer to save
3253 (if (yes-or-no-p
3254 (format "Buffer %s has been modified. Save it in file %s? "
3255 (buffer-name)
3256 buffer-file-name))
3257 (condition-case nil
3258 (save-buffer)
3259 (error
3260 (beep)
3261 (message "Couldn't save %s" buffer-file-name)))
3262 (error "Buffer is out of sync for file %s" buffer-file-name))
3263 ;; If buffer is not obsolete and is not modified, do nothing
3264 nil)
3265 ;; If buffer is obsolete, offer to revert
3266 (if (yes-or-no-p
3267 (format "File %s was modified since visited by buffer %s. REVERT file %s? "
3268 buffer-file-name
3269 (buffer-name)
3270 buffer-file-name))
3271 (progn
3272 (if file-magic
3273 (erase-buffer))
3274 (revert-buffer t t))
3275 (error "Buffer out of sync for file %s" buffer-file-name))))
3277 ;; if there is another buffer visiting the file of the merge buffer, offer to
3278 ;; save and delete the buffer; else bark
3279 (defun ediff-verify-file-merge-buffer (file)
3280 (let ((buff (if (stringp file) (find-buffer-visiting file)))
3281 warn-message)
3282 (or (null buff)
3283 (progn
3284 (setq warn-message
3285 (format "Buffer %s is visiting %s. Save and kill the buffer? "
3286 (buffer-name buff) file))
3287 (with-output-to-temp-buffer ediff-msg-buffer
3288 (princ "\n\n")
3289 (princ warn-message)
3290 (princ "\n\n"))
3291 (if (y-or-n-p
3292 (message "%s" warn-message))
3293 (with-current-buffer buff
3294 (save-buffer)
3295 (kill-buffer (current-buffer)))
3296 (error "Too dangerous to merge versions of a file visited by another buffer"))))
3301 (defun ediff-filename-magic-p (file)
3302 (or (ediff-file-compressed-p file)
3303 (ediff-file-remote-p file)))
3306 (defun ediff-save-buffer (arg)
3307 "Safe way of saving buffers A, B, C, and the diff output.
3308 `wa' saves buffer A, `wb' saves buffer B, `wc' saves buffer C,
3309 and `wd' saves the diff output.
3311 With prefix argument, `wd' saves plain diff output.
3312 Without an argument, it saves customized diff argument, if available
3313 \(and plain output, if customized output was not generated\)."
3314 (interactive "P")
3315 (ediff-barf-if-not-control-buffer)
3316 (ediff-compute-custom-diffs-maybe)
3317 (ediff-with-current-buffer
3318 (cond ((memq (ediff-last-command-char) '(?a ?b ?c))
3319 (ediff-get-buffer
3320 (ediff-char-to-buftype (ediff-last-command-char))))
3321 ((eq (ediff-last-command-char) ?d)
3322 (message "Saving diff output ...")
3323 (sit-for 1) ; let the user see the message
3324 (cond ((and arg (ediff-buffer-live-p ediff-diff-buffer))
3325 ediff-diff-buffer)
3326 ((ediff-buffer-live-p ediff-custom-diff-buffer)
3327 ediff-custom-diff-buffer)
3328 ((ediff-buffer-live-p ediff-diff-buffer)
3329 ediff-diff-buffer)
3330 (t (error "Output from `diff' not found"))))
3332 (let ((window-min-height 2))
3333 (save-buffer))))
3336 ;; idea suggested by Hannu Koivisto <azure@iki.fi>
3337 (defun ediff-clone-buffer-for-region-comparison (buff region-name)
3338 (let ((cloned-buff (ediff-make-cloned-buffer buff region-name))
3339 (pop-up-windows t)
3340 wind
3341 other-wind
3342 msg-buf)
3343 (ediff-with-current-buffer cloned-buff
3344 (setq ediff-temp-indirect-buffer t))
3345 (pop-to-buffer cloned-buff)
3346 (setq wind (ediff-get-visible-buffer-window cloned-buff))
3347 (select-window wind)
3348 (delete-other-windows)
3349 (ediff-activate-mark)
3350 (split-window-vertically)
3351 (ediff-select-lowest-window)
3352 (setq other-wind (selected-window))
3353 (with-temp-buffer
3354 (erase-buffer)
3355 (insert
3356 (format "\n ******* Mark a region in buffer %s (or confirm the existing one) *******\n"
3357 (buffer-name cloned-buff)))
3358 (insert
3359 (ediff-with-current-buffer buff
3360 (format "\n\t When done, type %s Use %s to abort\n "
3361 (ediff-format-bindings-of 'exit-recursive-edit)
3362 (ediff-format-bindings-of 'abort-recursive-edit))))
3363 (goto-char (point-min))
3364 (setq msg-buf (current-buffer))
3365 (set-window-buffer other-wind msg-buf)
3366 (shrink-window-if-larger-than-buffer)
3367 (if (window-live-p wind)
3368 (select-window wind))
3369 (condition-case nil
3370 (recursive-edit)
3371 (quit
3372 (ediff-kill-buffer-carefully cloned-buff)))
3374 cloned-buff))
3377 (defun ediff-clone-buffer-for-window-comparison (buff wind region-name)
3378 (let ((cloned-buff (ediff-make-cloned-buffer buff region-name)))
3379 (ediff-with-current-buffer cloned-buff
3380 (setq ediff-temp-indirect-buffer t))
3381 (set-window-buffer wind cloned-buff)
3382 cloned-buff))
3384 (defun ediff-buffer-type (buffer)
3385 (cond ((eq buffer ediff-buffer-A) 'A)
3386 ((eq buffer ediff-buffer-B) 'B)
3387 ((eq buffer ediff-buffer-C) 'C)
3388 ((eq buffer ediff-ancestor-buffer) 'Ancestor)
3389 (t nil)))
3391 (defun ediff-clone-buffer-for-current-diff-comparison (buff reg-name)
3392 (let* ((cloned-buff (ediff-make-cloned-buffer buff reg-name))
3393 (buf-type (ediff-buffer-type buff))
3394 (reg-start (ediff-get-diff-posn buf-type 'beg))
3395 (reg-end (ediff-get-diff-posn buf-type 'end)))
3396 (ediff-with-current-buffer cloned-buff
3397 ;; set region to be the current diff region
3398 (goto-char reg-start)
3399 (set-mark reg-end)
3400 (setq ediff-temp-indirect-buffer t))
3401 cloned-buff))
3405 (defun ediff-make-cloned-buffer (buff region-name)
3406 (ediff-make-indirect-buffer
3407 buff (generate-new-buffer-name
3408 (concat (if (stringp buff) buff (buffer-name buff)) region-name))))
3411 (defun ediff-make-indirect-buffer (base-buf indirect-buf-name)
3412 (if (featurep 'xemacs)
3413 (make-indirect-buffer base-buf indirect-buf-name)
3414 (make-indirect-buffer base-buf indirect-buf-name 'clone)))
3417 ;; This function operates only from an ediff control buffer
3418 (defun ediff-compute-custom-diffs-maybe ()
3419 (let ((buf-A-file-name (buffer-file-name ediff-buffer-A))
3420 (buf-B-file-name (buffer-file-name ediff-buffer-B))
3421 file-A file-B)
3422 (unless (and buf-A-file-name
3423 (file-exists-p buf-A-file-name)
3424 (not (ediff-file-remote-p buf-A-file-name)))
3425 (setq file-A (ediff-make-temp-file ediff-buffer-A)))
3426 (unless (and buf-B-file-name
3427 (file-exists-p buf-B-file-name)
3428 (not (ediff-file-remote-p buf-B-file-name)))
3429 (setq file-B (ediff-make-temp-file ediff-buffer-B)))
3430 (or (ediff-buffer-live-p ediff-custom-diff-buffer)
3431 (setq ediff-custom-diff-buffer
3432 (get-buffer-create
3433 (ediff-unique-buffer-name "*ediff-custom-diff" "*"))))
3434 (ediff-with-current-buffer ediff-custom-diff-buffer
3435 (setq buffer-read-only nil)
3436 (erase-buffer))
3437 (ediff-exec-process
3438 ediff-custom-diff-program ediff-custom-diff-buffer 'synchronize
3439 ediff-custom-diff-options
3440 (or file-A buf-A-file-name)
3441 (or file-B buf-B-file-name))
3442 ;; put the diff file in diff-mode, if it is available
3443 (if (fboundp 'diff-mode)
3444 (with-current-buffer ediff-custom-diff-buffer
3445 (diff-mode)))
3446 (and file-A (file-exists-p file-A) (delete-file file-A))
3447 (and file-B (file-exists-p file-B) (delete-file file-B))
3450 (defun ediff-show-diff-output (arg)
3451 (interactive "P")
3452 (ediff-barf-if-not-control-buffer)
3453 (ediff-compute-custom-diffs-maybe)
3454 (save-excursion
3455 (ediff-skip-unsuitable-frames ' ok-unsplittable))
3456 (let ((buf (cond ((and arg (ediff-buffer-live-p ediff-diff-buffer))
3457 ediff-diff-buffer)
3458 ((ediff-buffer-live-p ediff-custom-diff-buffer)
3459 ediff-custom-diff-buffer)
3460 ((ediff-buffer-live-p ediff-diff-buffer)
3461 ediff-diff-buffer)
3463 (beep)
3464 (message "Output from `diff' not found")
3465 nil))))
3466 (if buf
3467 (progn
3468 (ediff-with-current-buffer buf
3469 (goto-char (point-min)))
3470 (switch-to-buffer buf)
3471 (raise-frame))))
3472 (if (frame-live-p ediff-control-frame)
3473 (ediff-reset-mouse ediff-control-frame))
3474 (if (window-live-p ediff-control-window)
3475 (select-window ediff-control-window)))
3477 (declare-function ediff-regions-internal "ediff"
3478 (buffer-a beg-a end-a buffer-b beg-b end-b
3479 startup-hooks job-name word-mode setup-parameters))
3481 (defun ediff-inferior-compare-regions ()
3482 "Compare regions in an active Ediff session.
3483 Like `ediff-regions-linewise' but is called from under an active Ediff session on
3484 the files that belong to that session.
3486 After quitting the session invoked via this function, type C-l to the parent
3487 Ediff Control Panel to restore highlighting."
3488 (interactive)
3489 (let ((answer "")
3490 (possibilities (list ?A ?B ?C))
3491 (zmacs-regions t)
3492 use-current-diff-p
3493 begA begB endA endB bufA bufB)
3495 (if (ediff-valid-difference-p ediff-current-difference)
3496 (progn
3497 (ediff-set-fine-diff-properties ediff-current-difference 'default)
3498 (ediff-unhighlight-diff)))
3499 (ediff-paint-background-regions 'unhighlight)
3501 (cond ((ediff-merge-job)
3502 (setq bufB ediff-buffer-C)
3503 ;; ask which buffer to compare to the merge buffer
3504 (while (cond ((eq answer ?A)
3505 (setq bufA ediff-buffer-A
3506 possibilities '(?B))
3507 nil)
3508 ((eq answer ?B)
3509 (setq bufA ediff-buffer-B
3510 possibilities '(?A))
3511 nil)
3512 ((equal answer ""))
3513 (t (beep 1)
3514 (message "Valid values are A or B")
3515 (sit-for 2)
3517 (let ((cursor-in-echo-area t))
3518 (message
3519 "Which buffer to compare to the merge buffer (A or B)? ")
3520 (setq answer (capitalize (read-char-exclusive))))))
3522 ((ediff-3way-comparison-job)
3523 ;; ask which two buffers to compare
3524 (while (cond ((memq answer possibilities)
3525 (setq possibilities (delq answer possibilities))
3526 (setq bufA
3527 (eval
3528 (ediff-get-symbol-from-alist
3529 answer ediff-buffer-alist)))
3530 nil)
3531 ((equal answer ""))
3532 (t (beep 1)
3533 (message
3534 "Valid values are %s"
3535 (mapconcat 'char-to-string possibilities " or "))
3536 (sit-for 2)
3538 (let ((cursor-in-echo-area t))
3539 (message "Enter the 1st buffer you want to compare (%s): "
3540 (mapconcat 'char-to-string possibilities " or "))
3541 (setq answer (capitalize (read-char-exclusive)))))
3542 (setq answer "") ; silence error msg
3543 (while (cond ((memq answer possibilities)
3544 (setq possibilities (delq answer possibilities))
3545 (setq bufB
3546 (eval
3547 (ediff-get-symbol-from-alist
3548 answer ediff-buffer-alist)))
3549 nil)
3550 ((equal answer ""))
3551 (t (beep 1)
3552 (message
3553 "Valid values are %s"
3554 (mapconcat 'char-to-string possibilities " or "))
3555 (sit-for 2)
3557 (let ((cursor-in-echo-area t))
3558 (message "Enter the 2nd buffer you want to compare (%s): "
3559 (mapconcat 'char-to-string possibilities "/"))
3560 (setq answer (capitalize (read-char-exclusive))))))
3561 (t ; 2way comparison
3562 (setq bufA ediff-buffer-A
3563 bufB ediff-buffer-B
3564 possibilities nil)))
3566 (if (and (ediff-valid-difference-p ediff-current-difference)
3567 (y-or-n-p "Compare currently highlighted difference regions? "))
3568 (setq use-current-diff-p t))
3570 (setq bufA (if use-current-diff-p
3571 (ediff-clone-buffer-for-current-diff-comparison
3572 bufA "-Region.A-")
3573 (ediff-clone-buffer-for-region-comparison bufA "-Region.A-")))
3574 (ediff-with-current-buffer bufA
3575 (setq begA (region-beginning)
3576 endA (region-end))
3577 (goto-char begA)
3578 (beginning-of-line)
3579 (setq begA (point))
3580 (goto-char endA)
3581 (end-of-line)
3582 (or (eobp) (forward-char)) ; include the newline char
3583 (setq endA (point)))
3585 (setq bufB (if use-current-diff-p
3586 (ediff-clone-buffer-for-current-diff-comparison
3587 bufB "-Region.B-")
3588 (ediff-clone-buffer-for-region-comparison bufB "-Region.B-")))
3589 (ediff-with-current-buffer bufB
3590 (setq begB (region-beginning)
3591 endB (region-end))
3592 (goto-char begB)
3593 (beginning-of-line)
3594 (setq begB (point))
3595 (goto-char endB)
3596 (end-of-line)
3597 (or (eobp) (forward-char)) ; include the newline char
3598 (setq endB (point)))
3601 (ediff-regions-internal
3602 bufA begA endA bufB begB endB
3603 nil ; setup-hook
3604 (if use-current-diff-p ; job name
3605 'ediff-regions-wordwise
3606 'ediff-regions-linewise)
3607 (if use-current-diff-p ; word mode, if diffing current diff
3608 t nil)
3609 ;; setup param to pass to ediff-setup
3610 (list (cons 'ediff-split-window-function ediff-split-window-function)))
3615 (defun ediff-remove-flags-from-buffer (buffer overlay)
3616 (ediff-with-current-buffer buffer
3617 (let ((inhibit-read-only t))
3618 (if (featurep 'xemacs)
3619 (ediff-overlay-put overlay 'begin-glyph nil)
3620 (ediff-overlay-put overlay 'before-string nil))
3622 (if (featurep 'xemacs)
3623 (ediff-overlay-put overlay 'end-glyph nil)
3624 (ediff-overlay-put overlay 'after-string nil))
3629 (defun ediff-place-flags-in-buffer (buf-type buffer ctl-buffer diff)
3630 (ediff-with-current-buffer buffer
3631 (ediff-place-flags-in-buffer1 buf-type ctl-buffer diff)))
3634 (defun ediff-place-flags-in-buffer1 (buf-type ctl-buffer diff-no)
3635 (let* ((curr-overl (ediff-with-current-buffer ctl-buffer
3636 (ediff-get-diff-overlay diff-no buf-type)))
3637 (before (ediff-get-diff-posn buf-type 'beg diff-no ctl-buffer))
3638 after beg-of-line flag)
3640 ;; insert flag before the difference
3641 (goto-char before)
3642 (setq beg-of-line (bolp))
3644 (setq flag (ediff-with-current-buffer ctl-buffer
3645 (if (eq ediff-highlighting-style 'ascii)
3646 (if beg-of-line
3647 ediff-before-flag-bol ediff-before-flag-mol))))
3649 ;; insert the flag itself
3650 (if (featurep 'xemacs)
3651 (ediff-overlay-put curr-overl 'begin-glyph flag)
3652 (ediff-overlay-put curr-overl 'before-string flag))
3654 ;; insert the flag after the difference
3655 ;; `after' must be set here, after the before-flag was inserted
3656 (setq after (ediff-get-diff-posn buf-type 'end diff-no ctl-buffer))
3657 (goto-char after)
3658 (setq beg-of-line (bolp))
3660 (setq flag (ediff-with-current-buffer ctl-buffer
3661 (if (eq ediff-highlighting-style 'ascii)
3662 (if beg-of-line
3663 ediff-after-flag-eol ediff-after-flag-mol))))
3665 ;; insert the flag itself
3666 (if (featurep 'xemacs)
3667 (ediff-overlay-put curr-overl 'end-glyph flag)
3668 (ediff-overlay-put curr-overl 'after-string flag))
3672 ;;; Some diff region tests
3674 ;; t if diff region is empty.
3675 ;; In case of buffer C, t also if it is not a 3way
3676 ;; comparison job (merging jobs return t as well).
3677 (defun ediff-empty-diff-region-p (n buf-type)
3678 (if (eq buf-type 'C)
3679 (or (not ediff-3way-comparison-job)
3680 (= (ediff-get-diff-posn 'C 'beg n)
3681 (ediff-get-diff-posn 'C 'end n)))
3682 (= (ediff-get-diff-posn buf-type 'beg n)
3683 (ediff-get-diff-posn buf-type 'end n))))
3685 ;; Test if diff region is white space only.
3686 ;; If 2-way job and buf-type = C, then returns t.
3687 (defun ediff-whitespace-diff-region-p (n buf-type)
3688 (or (and (eq buf-type 'C) (not ediff-3way-job))
3689 (ediff-empty-diff-region-p n buf-type)
3690 (let ((beg (ediff-get-diff-posn buf-type 'beg n))
3691 (end (ediff-get-diff-posn buf-type 'end n)))
3692 (ediff-with-current-buffer (ediff-get-buffer buf-type)
3693 (save-excursion
3694 (goto-char beg)
3695 (skip-chars-forward ediff-whitespace)
3696 (>= (point) end))))))
3699 (defun ediff-get-region-contents (n buf-type ctrl-buf &optional start end)
3700 (ediff-with-current-buffer
3701 (ediff-with-current-buffer ctrl-buf (ediff-get-buffer buf-type))
3702 (buffer-substring
3703 (or start (ediff-get-diff-posn buf-type 'beg n ctrl-buf))
3704 (or end (ediff-get-diff-posn buf-type 'end n ctrl-buf)))))
3706 ;; Returns positions of difference sectors in the BUF-TYPE buffer.
3707 ;; BUF-TYPE should be a symbol -- `A', `B', or `C'.
3708 ;; POS is either `beg' or `end'--it specifies whether you want the position at
3709 ;; the beginning of a difference or at the end.
3711 ;; The optional argument N says which difference (default:
3712 ;; `ediff-current-difference'). N is the internal difference number (1- what
3713 ;; the user sees). The optional argument CONTROL-BUF says
3714 ;; which control buffer is in effect in case it is not the current
3715 ;; buffer.
3716 (defun ediff-get-diff-posn (buf-type pos &optional n control-buf)
3717 (let (diff-overlay)
3718 (or control-buf
3719 (setq control-buf (current-buffer)))
3721 (ediff-with-current-buffer control-buf
3722 (or n (setq n ediff-current-difference))
3723 (if (or (< n 0) (>= n ediff-number-of-differences))
3724 (if (> ediff-number-of-differences 0)
3725 (error ediff-BAD-DIFF-NUMBER
3726 this-command (1+ n) ediff-number-of-differences)
3727 (error ediff-NO-DIFFERENCES)))
3728 (setq diff-overlay (ediff-get-diff-overlay n buf-type)))
3729 (if (not (ediff-buffer-live-p (ediff-overlay-buffer diff-overlay)))
3730 (error ediff-KILLED-VITAL-BUFFER))
3731 (if (eq pos 'beg)
3732 (ediff-overlay-start diff-overlay)
3733 (ediff-overlay-end diff-overlay))
3737 ;; Restore highlighting to what it should be according to ediff-use-faces,
3738 ;; ediff-highlighting-style, and ediff-highlight-all-diffs variables.
3739 (defun ediff-restore-highlighting (&optional ctl-buf)
3740 (ediff-with-current-buffer (or ctl-buf (current-buffer))
3741 (if (and (ediff-has-face-support-p)
3742 ediff-use-faces
3743 ediff-highlight-all-diffs)
3744 (ediff-paint-background-regions))
3745 (ediff-select-difference ediff-current-difference)))
3749 ;; null out difference overlays so they won't slow down future
3750 ;; editing operations
3751 ;; VEC is either a difference vector or a fine-diff vector
3752 (defun ediff-clear-diff-vector (vec-var &optional fine-diffs-also)
3753 (if (vectorp (symbol-value vec-var))
3754 (mapc (lambda (elt)
3755 (ediff-delete-overlay
3756 (ediff-get-diff-overlay-from-diff-record elt))
3757 (if fine-diffs-also
3758 (ediff-clear-fine-diff-vector elt))
3760 (symbol-value vec-var)))
3761 ;; allow them to be garbage collected
3762 (set vec-var nil))
3766 ;;; Misc
3768 ;; In Emacs, this just makes overlay. In the future, when Emacs will start
3769 ;; supporting sticky overlays, this function will make a sticky overlay.
3770 ;; BEG and END are expressions telling where overlay starts.
3771 ;; If they are numbers or buffers, then all is well. Otherwise, they must
3772 ;; be expressions to be evaluated in buffer BUF in order to get the overlay
3773 ;; bounds.
3774 ;; If BUFF is not a live buffer, then return nil; otherwise, return the
3775 ;; newly created overlay.
3776 (defun ediff-make-bullet-proof-overlay (beg end buff)
3777 (if (ediff-buffer-live-p buff)
3778 (let (overl)
3779 (ediff-with-current-buffer buff
3780 (or (number-or-marker-p beg)
3781 (setq beg (eval beg)))
3782 (or (number-or-marker-p end)
3783 (setq end (eval end)))
3784 (setq overl
3785 (if (featurep 'xemacs)
3786 (make-extent beg end buff)
3787 ;; advance front and rear of the overlay
3788 (make-overlay beg end buff nil 'rear-advance)))
3790 ;; never detach
3791 (ediff-overlay-put
3792 overl (if (featurep 'emacs) 'evaporate 'detachable) nil)
3793 ;; make overlay open-ended
3794 ;; In emacs, it is made open ended at creation time
3795 (when (featurep 'xemacs)
3796 (ediff-overlay-put overl 'start-open nil)
3797 (ediff-overlay-put overl 'end-open nil))
3798 (ediff-overlay-put overl 'ediff-diff-num 0)
3799 overl))))
3802 (defun ediff-make-current-diff-overlay (type)
3803 (if (ediff-has-face-support-p)
3804 (let ((overlay (ediff-get-symbol-from-alist
3805 type ediff-current-diff-overlay-alist))
3806 (buffer (ediff-get-buffer type))
3807 (face (ediff-get-symbol-from-alist
3808 type ediff-current-diff-face-alist)))
3809 (set overlay
3810 (ediff-make-bullet-proof-overlay (point-max) (point-max) buffer))
3811 (ediff-set-overlay-face (symbol-value overlay) face)
3812 (ediff-overlay-put (symbol-value overlay) 'ediff ediff-control-buffer))
3816 ;; Like other-buffer, but prefers visible buffers and ignores temporary or
3817 ;; other insignificant buffers (those beginning with "^[ *]").
3818 ;; Gets one arg--buffer name or a list of buffer names (it won't return
3819 ;; these buffers).
3820 ;; EXCL-BUFF-LIST is an exclusion list.
3821 (defun ediff-other-buffer (excl-buff-lst)
3822 (or (listp excl-buff-lst) (setq excl-buff-lst (list excl-buff-lst)))
3823 (let* ((all-buffers (nconc (ediff-get-selected-buffers) (buffer-list)))
3824 ;; we compute this the second time because we need to do memq on it
3825 ;; later, and nconc above will break it. Either this or use slow
3826 ;; append instead of nconc
3827 (selected-buffers (ediff-get-selected-buffers))
3828 (preferred-buffer (car all-buffers))
3829 visible-dired-buffers
3830 (excl-buff-name-list
3831 (mapcar
3832 (lambda (b) (cond ((stringp b) b)
3833 ((bufferp b) (buffer-name b))))
3834 excl-buff-lst))
3835 ;; if at least one buffer on the exclusion list is dired, then force
3836 ;; all others to be dired. This is because this means that the user
3837 ;; has already chosen a dired buffer before
3838 (use-dired-major-mode
3839 (cond ((null (ediff-buffer-live-p (car excl-buff-lst))) 'unknown)
3840 ((eq (ediff-with-current-buffer (car excl-buff-lst) major-mode)
3841 'dired-mode)
3842 'yes)
3843 (t 'no)))
3844 ;; significant-buffers must be visible and not belong
3845 ;; to the exclusion list `buff-list'
3846 ;; We also exclude temporary buffers, but keep mail and gnus buffers
3847 ;; Furthermore, we exclude dired buffers, unless they are the only
3848 ;; ones visible (and there are at least two of them).
3849 ;; Also, any visible window not on the exclusion list that is first in
3850 ;; the buffer list is chosen regardless. (This is because the user
3851 ;; clicked on it or did something to distinguish it).
3852 (significant-buffers
3853 (mapcar
3854 (lambda (x)
3855 (cond ((member (buffer-name x) excl-buff-name-list) nil)
3856 ((memq x selected-buffers) x)
3857 ((not (ediff-get-visible-buffer-window x)) nil)
3858 ((eq x preferred-buffer) x)
3859 ;; if prev selected buffer is dired, look only at
3860 ;; dired.
3861 ((eq use-dired-major-mode 'yes)
3862 (if (eq (ediff-with-current-buffer x major-mode)
3863 'dired-mode)
3864 x nil))
3865 ((eq (ediff-with-current-buffer x major-mode)
3866 'dired-mode)
3867 (if (null use-dired-major-mode)
3868 ;; don't know if we must enforce dired.
3869 ;; Remember this buffer in case
3870 ;; dired buffs are the only ones visible.
3871 (setq visible-dired-buffers
3872 (cons x visible-dired-buffers)))
3873 ;; skip, if dired is not forced
3874 nil)
3875 ((memq (ediff-with-current-buffer x major-mode)
3876 '(rmail-mode
3877 vm-mode
3878 gnus-article-mode
3879 mh-show-mode))
3881 ((string-match "^[ *]" (buffer-name x)) nil)
3882 ((string= "*scratch*" (buffer-name x)) nil)
3883 (t x)))
3884 all-buffers))
3885 (clean-significant-buffers (delq nil significant-buffers))
3886 less-significant-buffers)
3888 (if (and (null clean-significant-buffers)
3889 (> (length visible-dired-buffers) 0))
3890 (setq clean-significant-buffers visible-dired-buffers))
3892 (cond (clean-significant-buffers (car clean-significant-buffers))
3893 ;; try also buffers that are not displayed in windows
3894 ((setq less-significant-buffers
3895 (delq nil
3896 (mapcar
3897 (lambda (x)
3898 (cond ((member (buffer-name x) excl-buff-name-list)
3899 nil)
3900 ((eq use-dired-major-mode 'yes)
3901 (if (eq (ediff-with-current-buffer
3902 x major-mode)
3903 'dired-mode)
3904 x nil))
3905 ((eq (ediff-with-current-buffer x major-mode)
3906 'dired-mode)
3907 nil)
3908 ((string-match "^[ *]" (buffer-name x)) nil)
3909 ((string= "*scratch*" (buffer-name x)) nil)
3910 (t x)))
3911 all-buffers)))
3912 (car less-significant-buffers))
3913 (t "*scratch*"))
3917 ;; If current buffer is a Buffer-menu buffer, then take the selected buffers
3918 ;; and append the buffer at the cursor to the end.
3919 ;; This list would be the preferred list.
3920 (defun ediff-get-selected-buffers ()
3921 (if (eq major-mode 'Buffer-menu-mode)
3922 (let ((lis (condition-case nil
3923 (list (Buffer-menu-buffer t))
3924 (error))
3926 (save-excursion
3927 (goto-char (point-max))
3928 (while (search-backward "\n>" nil t)
3929 (forward-char 1)
3930 (setq lis (cons (Buffer-menu-buffer t) lis)))
3931 lis))
3934 ;; Construct a unique buffer name.
3935 ;; The first one tried is prefixsuffix, then prefix<2>suffix,
3936 ;; prefix<3>suffix, etc.
3937 (defun ediff-unique-buffer-name (prefix suffix)
3938 (if (null (get-buffer (concat prefix suffix)))
3939 (concat prefix suffix)
3940 (let ((n 2))
3941 (while (get-buffer (format "%s<%d>%s" prefix n suffix))
3942 (setq n (1+ n)))
3943 (format "%s<%d>%s" prefix n suffix))))
3946 (defun ediff-submit-report ()
3947 "Submit bug report on Ediff."
3948 (interactive)
3949 (ediff-barf-if-not-control-buffer)
3950 (let ((reporter-prompt-for-summary-p t)
3951 (ctl-buf ediff-control-buffer)
3952 (ediff-device-type (ediff-device-type))
3953 varlist salutation buffer-name)
3954 (setq varlist '(ediff-diff-program ediff-diff-options
3955 ediff-diff3-program ediff-diff3-options
3956 ediff-patch-program ediff-patch-options
3957 ediff-shell
3958 ediff-use-faces
3959 ediff-auto-refine ediff-highlighting-style
3960 ediff-buffer-A ediff-buffer-B ediff-control-buffer
3961 ediff-forward-word-function
3962 ediff-control-frame
3963 ediff-control-frame-parameters
3964 ediff-control-frame-position-function
3965 ediff-prefer-iconified-control-frame
3966 ediff-window-setup-function
3967 ediff-split-window-function
3968 ediff-job-name
3969 ediff-word-mode
3970 buffer-name
3971 ediff-device-type
3973 (setq salutation "
3974 Congratulations! You may have unearthed a bug in Ediff!
3976 Please make a concise and accurate summary of what happened
3977 and mail it to the address above.
3978 -----------------------------------------------------------
3981 (ediff-skip-unsuitable-frames)
3982 (ediff-reset-mouse)
3984 (switch-to-buffer ediff-msg-buffer)
3985 (erase-buffer)
3986 (delete-other-windows)
3987 (insert "
3988 Please read this first:
3989 ----------------------
3991 Some ``bugs'' may actually be no bugs at all. For instance, if you are
3992 reporting that certain difference regions are not matched as you think they
3993 should, this is most likely due to the way Unix diff program decides what
3994 constitutes a difference region. Ediff is an Emacs interface to diff, and
3995 it has nothing to do with those decisions---it only takes the output from
3996 diff and presents it in a way that is better suited for human browsing and
3997 manipulation.
3999 If Emacs happens to dump core, this is NOT an Ediff problem---it is
4000 an Emacs bug. Report this to Emacs maintainers.
4002 Another popular topic for reports is compilation messages. Because Ediff
4003 interfaces to several other packages and runs under Emacs and XEmacs,
4004 byte-compilation may produce output like this:
4006 While compiling toplevel forms in file ediff.el:
4007 ** reference to free variable pm-color-alist
4008 ........................
4009 While compiling the end of the data:
4010 ** The following functions are not known to be defined:
4011 xxx, yyy
4012 ........................
4014 These are NOT errors, but inevitable warnings, which ought to be ignored.
4016 Please do not report those and similar things. However, comments and
4017 suggestions are always welcome.
4019 Mail anyway? (y or n) ")
4021 (if (y-or-n-p "Mail anyway? ")
4022 (progn
4023 (if (ediff-buffer-live-p ctl-buf)
4024 (set-buffer ctl-buf))
4025 (setq buffer-name (buffer-name))
4026 (require 'reporter)
4027 (reporter-submit-bug-report "kifer@cs.stonybrook.edu, bug-gnu-emacs@gnu.org"
4028 (ediff-version)
4029 varlist
4031 'delete-other-windows
4032 salutation))
4033 (bury-buffer)
4034 (beep 1)(message "Bug report aborted")
4035 (if (ediff-buffer-live-p ctl-buf)
4036 (ediff-with-current-buffer ctl-buf
4037 (ediff-recenter 'no-rehighlight))))
4041 ;; Find an appropriate syntax table for everyone to use
4042 ;; If buffer B is not fundamental or text mode, use its syntax table
4043 ;; Otherwise, use buffer B's.
4044 ;; The syntax mode is used in ediff-forward-word-function
4045 ;; The important thing is that every buffer should use the same syntax table
4046 ;; during the refinement operation
4047 (defun ediff-choose-syntax-table ()
4048 (setq ediff-syntax-table
4049 (ediff-with-current-buffer ediff-buffer-A
4050 (if (not (memq major-mode
4051 '(fundamental-mode text-mode indented-text-mode)))
4052 (syntax-table))))
4053 (if (not ediff-syntax-table)
4054 (setq ediff-syntax-table
4055 (ediff-with-current-buffer ediff-buffer-B
4056 (syntax-table))))
4060 (defun ediff-deactivate-mark ()
4061 (if (featurep 'xemacs)
4062 (zmacs-deactivate-region)
4063 (deactivate-mark)))
4065 (defun ediff-activate-mark ()
4066 (if (featurep 'xemacs)
4067 (zmacs-activate-region)
4068 (make-local-variable 'transient-mark-mode)
4069 (setq mark-active t transient-mark-mode t)))
4071 (defun ediff-nuke-selective-display ()
4072 (if (featurep 'xemacs)
4073 (nuke-selective-display)
4074 (save-excursion
4075 (save-restriction
4076 (widen)
4077 (goto-char (point-min))
4078 (let ((mod-p (buffer-modified-p))
4079 buffer-read-only end)
4080 (and (eq t selective-display)
4081 (while (search-forward "\^M" nil t)
4082 (end-of-line)
4083 (setq end (point))
4084 (beginning-of-line)
4085 (while (search-forward "\^M" end t)
4086 (delete-char -1)
4087 (insert "\^J"))))
4088 (set-buffer-modified-p mod-p)
4089 (setq selective-display nil))))))
4092 ;; The next two are modified versions from emerge.el.
4093 ;; VARS must be a list of symbols
4094 ;; ediff-save-variables returns an association list: ((var . val) ...)
4095 (defsubst ediff-save-variables (vars)
4096 (mapcar (lambda (v) (cons v (symbol-value v)))
4097 vars))
4098 ;; VARS is a list of variable symbols.
4099 (defun ediff-restore-variables (vars assoc-list)
4100 (while vars
4101 (set (car vars) (cdr (assoc (car vars) assoc-list)))
4102 (setq vars (cdr vars))))
4104 (defun ediff-change-saved-variable (var value buf-type)
4105 (let* ((assoc-list
4106 (symbol-value (ediff-get-symbol-from-alist
4107 buf-type
4108 ediff-buffer-values-orig-alist)))
4109 (assoc-elt (assoc var assoc-list)))
4110 (if assoc-elt
4111 (setcdr assoc-elt value))))
4114 ;; must execute in control buf
4115 (defun ediff-save-protected-variables ()
4116 (setq ediff-buffer-values-orig-A
4117 (ediff-with-current-buffer ediff-buffer-A
4118 (ediff-save-variables ediff-protected-variables)))
4119 (setq ediff-buffer-values-orig-B
4120 (ediff-with-current-buffer ediff-buffer-B
4121 (ediff-save-variables ediff-protected-variables)))
4122 (if ediff-3way-comparison-job
4123 (setq ediff-buffer-values-orig-C
4124 (ediff-with-current-buffer ediff-buffer-C
4125 (ediff-save-variables ediff-protected-variables))))
4126 (if (ediff-buffer-live-p ediff-ancestor-buffer)
4127 (setq ediff-buffer-values-orig-Ancestor
4128 (ediff-with-current-buffer ediff-ancestor-buffer
4129 (ediff-save-variables ediff-protected-variables)))))
4131 ;; must execute in control buf
4132 (defun ediff-restore-protected-variables ()
4133 (let ((values-A ediff-buffer-values-orig-A)
4134 (values-B ediff-buffer-values-orig-B)
4135 (values-C ediff-buffer-values-orig-C)
4136 (values-Ancestor ediff-buffer-values-orig-Ancestor))
4137 (ediff-with-current-buffer ediff-buffer-A
4138 (ediff-restore-variables ediff-protected-variables values-A))
4139 (ediff-with-current-buffer ediff-buffer-B
4140 (ediff-restore-variables ediff-protected-variables values-B))
4141 (if ediff-3way-comparison-job
4142 (ediff-with-current-buffer ediff-buffer-C
4143 (ediff-restore-variables ediff-protected-variables values-C)))
4144 (if (ediff-buffer-live-p ediff-ancestor-buffer)
4145 (ediff-with-current-buffer ediff-ancestor-buffer
4146 (ediff-restore-variables ediff-protected-variables values-Ancestor)))
4149 ;; save BUFFER in FILE. used in hooks.
4150 (defun ediff-save-buffer-in-file (buffer file)
4151 (ediff-with-current-buffer buffer
4152 (write-file file)))
4155 ;;; Debug
4157 (ediff-defvar-local ediff-command-begin-time '(0 0 0) "")
4159 ;; calculate time used by command
4160 (defun ediff-calc-command-time ()
4161 (or (equal ediff-command-begin-time '(0 0 0))
4162 (message "Elapsed time: %g second(s)"
4163 (float-time (time-since ediff-command-begin-time)))))
4165 (defsubst ediff-save-time ()
4166 (setq ediff-command-begin-time (current-time)))
4168 (defun ediff-profile ()
4169 "Toggle profiling Ediff commands."
4170 (interactive)
4171 (ediff-barf-if-not-control-buffer)
4173 (if (featurep 'xemacs)
4174 (make-local-hook 'post-command-hook))
4176 (let ((pre-hook 'pre-command-hook)
4177 (post-hook 'post-command-hook))
4178 (if (not (equal ediff-command-begin-time '(0 0 0)))
4179 (progn (remove-hook pre-hook 'ediff-save-time)
4180 (remove-hook post-hook 'ediff-calc-command-time)
4181 (setq ediff-command-begin-time '(0 0 0))
4182 (message "Ediff profiling disabled"))
4183 (add-hook pre-hook 'ediff-save-time t 'local)
4184 (add-hook post-hook 'ediff-calc-command-time nil 'local)
4185 (message "Ediff profiling enabled"))))
4187 (defun ediff-print-diff-vector (diff-vector-var)
4188 (princ (format "\n*** %S ***\n" diff-vector-var))
4189 (mapcar (lambda (overl-vec)
4190 (princ
4191 (format
4192 "Diff %d: \tOverlay: %S
4193 \t\tFine diffs: %s
4194 \t\tNo-fine-diff-flag: %S
4195 \t\tState-of-diff:\t %S
4196 \t\tState-of-merge:\t %S
4198 (1+ (ediff-overlay-get (aref overl-vec 0) 'ediff-diff-num))
4199 (aref overl-vec 0)
4200 ;; fine-diff-vector
4201 (if (= (length (aref overl-vec 1)) 0)
4202 "none\n"
4203 (mapconcat 'prin1-to-string
4204 (aref overl-vec 1) "\n\t\t\t "))
4205 (aref overl-vec 2) ; no fine diff flag
4206 (aref overl-vec 3) ; state-of-diff
4207 (aref overl-vec 4) ; state-of-merge
4209 (eval diff-vector-var)))
4213 (defun ediff-debug-info ()
4214 (interactive)
4215 (ediff-barf-if-not-control-buffer)
4216 (with-output-to-temp-buffer ediff-debug-buffer
4217 (ediff-with-current-buffer standard-output
4218 (fundamental-mode))
4219 (princ (format "\nCtl buffer: %S\n" ediff-control-buffer))
4220 (ediff-print-diff-vector (intern "ediff-difference-vector-A"))
4221 (ediff-print-diff-vector (intern "ediff-difference-vector-B"))
4222 (ediff-print-diff-vector (intern "ediff-difference-vector-C"))
4223 (ediff-print-diff-vector (intern "ediff-difference-vector-Ancestor"))
4227 ;;; General utilities
4229 ;; this uses comparison-func to decide who is a member
4230 (defun ediff-member (elt lis comparison-func)
4231 (while (and lis (not (funcall comparison-func (car lis) elt)))
4232 (setq lis (cdr lis)))
4233 lis)
4235 ;; Make a readable representation of the invocation sequence for FUNC-DEF.
4236 ;; It would either be a key or M-x something.
4237 (defun ediff-format-bindings-of (func-def)
4238 (let ((desc (car (where-is-internal func-def
4239 overriding-local-map
4240 nil nil))))
4241 (if desc
4242 (key-description desc)
4243 (format "M-x %s" func-def))))
4245 ;; this uses comparison-func to decide who is a member, and this determines how
4246 ;; intersection looks like
4247 (defun ediff-intersection (lis1 lis2 comparison-func)
4248 (let ((result (list 'a)))
4249 (while lis1
4250 (if (ediff-member (car lis1) lis2 comparison-func)
4251 (nconc result (list (car lis1))))
4252 (setq lis1 (cdr lis1)))
4253 (cdr result)))
4256 ;; eliminates duplicates using comparison-func
4257 (defun ediff-union (lis1 lis2 comparison-func)
4258 (let ((result (list 'a)))
4259 (while lis1
4260 (or (ediff-member (car lis1) (cdr result) comparison-func)
4261 (nconc result (list (car lis1))))
4262 (setq lis1 (cdr lis1)))
4263 (while lis2
4264 (or (ediff-member (car lis2) (cdr result) comparison-func)
4265 (nconc result (list (car lis2))))
4266 (setq lis2 (cdr lis2)))
4267 (cdr result)))
4269 ;; eliminates duplicates using comparison-func
4270 (defun ediff-set-difference (lis1 lis2 comparison-func)
4271 (let ((result (list 'a)))
4272 (while lis1
4273 (or (ediff-member (car lis1) (cdr result) comparison-func)
4274 (ediff-member (car lis1) lis2 comparison-func)
4275 (nconc result (list (car lis1))))
4276 (setq lis1 (cdr lis1)))
4277 (cdr result)))
4279 (defun ediff-add-to-history (history-var newelt)
4280 (if (fboundp 'add-to-history)
4281 (add-to-history history-var newelt)
4282 (set history-var (cons newelt (symbol-value history-var)))))
4284 (defalias 'ediff-copy-list 'copy-sequence)
4287 ;; don't report error if version control package wasn't found
4288 ;;(ediff-load-version-control 'silent)
4290 (run-hooks 'ediff-load-hook)
4293 ;; Local Variables:
4294 ;; eval: (put 'ediff-defvar-local 'lisp-indent-hook 'defun)
4295 ;; eval: (put 'ediff-with-current-buffer 'lisp-indent-hook 1)
4296 ;; eval: (put 'ediff-with-current-buffer 'edebug-form-spec '(form body))
4297 ;; End:
4299 ;;; ediff-util.el ends here