Mercurial > emacs
comparison lisp/vc/ediff-init.el @ 109404:e93288477c43
Merge from mainline.
author | Katsumi Yamaoka <yamaoka@jpl.org> |
---|---|
date | Sun, 13 Jun 2010 22:57:55 +0000 |
parents | lisp/ediff-init.el@1d1d5d9bd884 lisp/ediff-init.el@6ff48295959a |
children | 1b626601d32d |
comparison
equal
deleted
inserted
replaced
109403:681cd08dc0f7 | 109404:e93288477c43 |
---|---|
1 ;;; ediff-init.el --- Macros, variables, and defsubsts used by Ediff | |
2 | |
3 ;; Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, | |
4 ;; 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc. | |
5 | |
6 ;; Author: Michael Kifer <kifer@cs.stonybrook.edu> | |
7 | |
8 ;; This file is part of GNU Emacs. | |
9 | |
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. | |
14 | |
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. | |
19 | |
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/>. | |
22 | |
23 ;;; Commentary: | |
24 | |
25 ;;; Code: | |
26 | |
27 ;; Start compiler pacifier | |
28 (defvar ediff-metajob-name) | |
29 (defvar ediff-meta-buffer) | |
30 (defvar ediff-grab-mouse) | |
31 (defvar ediff-mouse-pixel-position) | |
32 (defvar ediff-mouse-pixel-threshold) | |
33 (defvar ediff-whitespace) | |
34 (defvar ediff-multiframe) | |
35 (defvar ediff-use-toolbar-p) | |
36 (defvar mswindowsx-bitmap-file-path) | |
37 ;; end pacifier | |
38 | |
39 (defvar ediff-force-faces nil | |
40 "If t, Ediff will think that it is running on a display that supports faces. | |
41 This is provided as a temporary relief for users of face-capable displays | |
42 that Ediff doesn't know about.") | |
43 | |
44 ;; Are we running as a window application or on a TTY? | |
45 (defsubst ediff-device-type () | |
46 (if (featurep 'xemacs) | |
47 (device-type (selected-device)) | |
48 window-system)) | |
49 | |
50 ;; in XEmacs: device-type is tty on tty and stream in batch. | |
51 (defun ediff-window-display-p () | |
52 (and (ediff-device-type) (not (memq (ediff-device-type) '(tty pc stream))))) | |
53 | |
54 ;; test if supports faces | |
55 (defun ediff-has-face-support-p () | |
56 (cond ((ediff-window-display-p)) | |
57 (ediff-force-faces) | |
58 ((ediff-color-display-p)) | |
59 ((featurep 'emacs) (memq (ediff-device-type) '(pc))) | |
60 ((featurep 'xemacs) (memq (ediff-device-type) '(tty pc))) | |
61 )) | |
62 | |
63 ;; toolbar support for emacs hasn't been implemented in ediff | |
64 (defun ediff-has-toolbar-support-p () | |
65 (if (featurep 'xemacs) | |
66 (if (featurep 'toolbar) (console-on-window-system-p)))) | |
67 | |
68 | |
69 (defun ediff-has-gutter-support-p () | |
70 (if (featurep 'xemacs) | |
71 (if (featurep 'gutter) (console-on-window-system-p)))) | |
72 | |
73 (defun ediff-use-toolbar-p () | |
74 (and (ediff-has-toolbar-support-p) ;Can it do it ? | |
75 (boundp 'ediff-use-toolbar-p) | |
76 ediff-use-toolbar-p)) ;Does the user want it ? | |
77 | |
78 ;; Defines VAR as an advertised local variable. | |
79 ;; Performs a defvar, then executes `make-variable-buffer-local' on | |
80 ;; the variable. Also sets the `permanent-local' property, | |
81 ;; so that `kill-all-local-variables' (called by major-mode setting | |
82 ;; commands) won't destroy Ediff control variables. | |
83 ;; | |
84 ;; Plagiarised from `emerge-defvar-local' for XEmacs. | |
85 (defmacro ediff-defvar-local (var value doc) | |
86 "Defines VAR as a local variable." | |
87 (declare (indent defun)) | |
88 `(progn | |
89 (defvar ,var ,value ,doc) | |
90 (make-variable-buffer-local ',var) | |
91 (put ',var 'permanent-local t))) | |
92 | |
93 | |
94 | |
95 ;; Variables that control each Ediff session---local to the control buffer. | |
96 | |
97 ;; Mode variables | |
98 ;; The buffer in which the A variant is stored. | |
99 (ediff-defvar-local ediff-buffer-A nil "") | |
100 ;; The buffer in which the B variant is stored. | |
101 (ediff-defvar-local ediff-buffer-B nil "") | |
102 ;; The buffer in which the C variant is stored or where the merge buffer lives. | |
103 (ediff-defvar-local ediff-buffer-C nil "") | |
104 ;; Ancestor buffer | |
105 (ediff-defvar-local ediff-ancestor-buffer nil "") | |
106 ;; The Ediff control buffer | |
107 (ediff-defvar-local ediff-control-buffer nil "") | |
108 | |
109 (ediff-defvar-local ediff-temp-indirect-buffer nil | |
110 "If t, the buffer is a temporary indirect buffer. | |
111 It needs to be killed when we quit the session.") | |
112 | |
113 | |
114 ;; Association between buff-type and ediff-buffer-* | |
115 (defconst ediff-buffer-alist | |
116 '((?A . ediff-buffer-A) | |
117 (?B . ediff-buffer-B) | |
118 (?C . ediff-buffer-C))) | |
119 | |
120 ;;; Macros | |
121 (defmacro ediff-odd-p (arg) | |
122 `(eq (logand ,arg 1) 1)) | |
123 | |
124 (defmacro ediff-buffer-live-p (buf) | |
125 `(and ,buf (get-buffer ,buf) (buffer-name (get-buffer ,buf)))) | |
126 | |
127 (defmacro ediff-get-buffer (arg) | |
128 `(cond ((eq ,arg 'A) ediff-buffer-A) | |
129 ((eq ,arg 'B) ediff-buffer-B) | |
130 ((eq ,arg 'C) ediff-buffer-C) | |
131 ((eq ,arg 'Ancestor) ediff-ancestor-buffer) | |
132 )) | |
133 | |
134 (defmacro ediff-get-value-according-to-buffer-type (buf-type list) | |
135 `(cond ((eq ,buf-type 'A) (nth 0 ,list)) | |
136 ((eq ,buf-type 'B) (nth 1 ,list)) | |
137 ((eq ,buf-type 'C) (nth 2 ,list)) | |
138 )) | |
139 | |
140 (defmacro ediff-char-to-buftype (arg) | |
141 `(cond ((memq ,arg '(?a ?A)) 'A) | |
142 ((memq ,arg '(?b ?B)) 'B) | |
143 ((memq ,arg '(?c ?C)) 'C) | |
144 )) | |
145 | |
146 | |
147 ;; A-list is supposed to be of the form (A . symb) (B . symb)...) | |
148 ;; where the first part of any association is a buffer type and the second is | |
149 ;; an appropriate symbol. Given buffer-type, this function returns the | |
150 ;; symbol. This is used to avoid using `intern' | |
151 (defsubst ediff-get-symbol-from-alist (buf-type alist) | |
152 (cdr (assoc buf-type alist))) | |
153 | |
154 (defconst ediff-difference-vector-alist | |
155 '((A . ediff-difference-vector-A) | |
156 (B . ediff-difference-vector-B) | |
157 (C . ediff-difference-vector-C) | |
158 (Ancestor . ediff-difference-vector-Ancestor))) | |
159 | |
160 (defmacro ediff-get-difference (n buf-type) | |
161 `(aref | |
162 (symbol-value | |
163 (ediff-get-symbol-from-alist | |
164 ,buf-type ediff-difference-vector-alist)) | |
165 ,n)) | |
166 | |
167 ;; Tell if it has been previously determined that the region has | |
168 ;; no diffs other than the white space and newlines | |
169 ;; The argument, N, is the diff region number used by Ediff to index the | |
170 ;; diff vector. It is 1 less than the number seen by the user. | |
171 ;; Returns: | |
172 ;; t if the diffs are whitespace in all buffers | |
173 ;; 'A (in 3-buf comparison only) if there are only whitespace | |
174 ;; diffs in bufs B and C | |
175 ;; 'B (in 3-buf comparison only) if there are only whitespace | |
176 ;; diffs in bufs A and C | |
177 ;; 'C (in 3-buf comparison only) if there are only whitespace | |
178 ;; diffs in bufs A and B | |
179 ;; | |
180 ;; A Difference Vector has the form: | |
181 ;; [diff diff diff ...] | |
182 ;; where each diff has the form: | |
183 ;; [overlay fine-diff-vector no-fine-diffs-flag state-of-difference] | |
184 ;; fine-diff-vector is a vector [fine-diff fine-diff fine-diff ...] | |
185 ;; no-fine-diffs-flag says if there are fine differences. | |
186 ;; state-of-difference is A, B, C, or nil, indicating which buffer is | |
187 ;; different from the other two (used only in 3-way jobs). | |
188 (defmacro ediff-no-fine-diffs-p (n) | |
189 `(aref (ediff-get-difference ,n 'A) 2)) | |
190 | |
191 (defmacro ediff-get-diff-overlay-from-diff-record (diff-rec) | |
192 `(aref ,diff-rec 0)) | |
193 | |
194 (defmacro ediff-get-diff-overlay (n buf-type) | |
195 `(ediff-get-diff-overlay-from-diff-record | |
196 (ediff-get-difference ,n ,buf-type))) | |
197 | |
198 (defmacro ediff-get-fine-diff-vector-from-diff-record (diff-rec) | |
199 `(aref ,diff-rec 1)) | |
200 | |
201 (defmacro ediff-set-fine-diff-vector (n buf-type fine-vec) | |
202 `(aset (ediff-get-difference ,n ,buf-type) 1 ,fine-vec)) | |
203 | |
204 (defmacro ediff-get-state-of-diff (n buf-type) | |
205 `(if (ediff-buffer-live-p ediff-buffer-C) | |
206 (aref (ediff-get-difference ,n ,buf-type) 3))) | |
207 (defmacro ediff-set-state-of-diff (n buf-type val) | |
208 `(aset (ediff-get-difference ,n ,buf-type) 3 ,val)) | |
209 | |
210 (defmacro ediff-get-state-of-merge (n) | |
211 `(if ediff-state-of-merge | |
212 (aref (aref ediff-state-of-merge ,n) 0))) | |
213 (defmacro ediff-set-state-of-merge (n val) | |
214 `(if ediff-state-of-merge | |
215 (aset (aref ediff-state-of-merge ,n) 0 ,val))) | |
216 | |
217 (defmacro ediff-get-state-of-ancestor (n) | |
218 `(if ediff-state-of-merge | |
219 (aref (aref ediff-state-of-merge ,n) 1))) | |
220 | |
221 ;; if flag is t, puts a mark on diff region saying that | |
222 ;; the differences are in white space only. If flag is nil, | |
223 ;; the region is marked as essential (i.e., differences are | |
224 ;; not just in the white space and newlines.) | |
225 (defmacro ediff-mark-diff-as-space-only (n flag) | |
226 `(aset (ediff-get-difference ,n 'A) 2 ,flag)) | |
227 | |
228 (defmacro ediff-get-fine-diff-vector (n buf-type) | |
229 `(ediff-get-fine-diff-vector-from-diff-record | |
230 (ediff-get-difference ,n ,buf-type))) | |
231 | |
232 ;; Macro to switch to BUFFER, evaluate BODY, returns to original buffer. | |
233 ;; Doesn't save the point and mark. | |
234 ;; This is `with-current-buffer' with the added test for live buffers." | |
235 (defmacro ediff-with-current-buffer (buffer &rest body) | |
236 "Evaluates BODY in BUFFER." | |
237 (declare (indent 1) (debug (form body))) | |
238 `(if (ediff-buffer-live-p ,buffer) | |
239 (save-current-buffer | |
240 (set-buffer ,buffer) | |
241 ,@body) | |
242 (or (eq this-command 'ediff-quit) | |
243 (error ediff-KILLED-VITAL-BUFFER)) | |
244 )) | |
245 | |
246 | |
247 (defsubst ediff-multiframe-setup-p () | |
248 (and (ediff-window-display-p) ediff-multiframe)) | |
249 | |
250 (defmacro ediff-narrow-control-frame-p () | |
251 `(and (ediff-multiframe-setup-p) | |
252 (equal ediff-help-message ediff-brief-message-string))) | |
253 | |
254 (defmacro ediff-3way-comparison-job () | |
255 `(memq | |
256 ediff-job-name | |
257 '(ediff-files3 ediff-buffers3))) | |
258 (ediff-defvar-local ediff-3way-comparison-job nil "") | |
259 | |
260 (defmacro ediff-merge-job () | |
261 `(memq | |
262 ediff-job-name | |
263 '(ediff-merge-files | |
264 ediff-merge-buffers | |
265 ediff-merge-files-with-ancestor | |
266 ediff-merge-buffers-with-ancestor | |
267 ediff-merge-revisions | |
268 ediff-merge-revisions-with-ancestor))) | |
269 (ediff-defvar-local ediff-merge-job nil "") | |
270 | |
271 (defmacro ediff-patch-job () | |
272 `(eq ediff-job-name 'epatch)) | |
273 | |
274 (defmacro ediff-merge-with-ancestor-job () | |
275 `(memq | |
276 ediff-job-name | |
277 '(ediff-merge-files-with-ancestor | |
278 ediff-merge-buffers-with-ancestor | |
279 ediff-merge-revisions-with-ancestor))) | |
280 (ediff-defvar-local ediff-merge-with-ancestor-job nil "") | |
281 | |
282 (defmacro ediff-3way-job () | |
283 `(or ediff-3way-comparison-job ediff-merge-job)) | |
284 (ediff-defvar-local ediff-3way-job nil "") | |
285 | |
286 ;; A diff3 job is like a 3way job, but ediff-merge doesn't require the use | |
287 ;; of diff3. | |
288 (defmacro ediff-diff3-job () | |
289 `(or ediff-3way-comparison-job | |
290 ediff-merge-with-ancestor-job)) | |
291 (ediff-defvar-local ediff-diff3-job nil "") | |
292 | |
293 (defmacro ediff-windows-job () | |
294 `(memq ediff-job-name '(ediff-windows-wordwise ediff-windows-linewise))) | |
295 (ediff-defvar-local ediff-windows-job nil "") | |
296 | |
297 (defmacro ediff-word-mode-job () | |
298 `(memq ediff-job-name '(ediff-windows-wordwise ediff-regions-wordwise))) | |
299 (ediff-defvar-local ediff-word-mode-job nil "") | |
300 | |
301 (defmacro ediff-narrow-job () | |
302 `(memq ediff-job-name '(ediff-windows-wordwise | |
303 ediff-regions-wordwise | |
304 ediff-windows-linewise | |
305 ediff-regions-linewise))) | |
306 (ediff-defvar-local ediff-narrow-job nil "") | |
307 | |
308 ;; Note: ediff-merge-directory-revisions-with-ancestor is not treated as an | |
309 ;; ancestor metajob, since it behaves differently. | |
310 (defsubst ediff-ancestor-metajob (&optional metajob) | |
311 (memq (or metajob ediff-metajob-name) | |
312 '(ediff-merge-directories-with-ancestor | |
313 ediff-merge-filegroups-with-ancestor))) | |
314 (defsubst ediff-revision-metajob (&optional metajob) | |
315 (memq (or metajob ediff-metajob-name) | |
316 '(ediff-directory-revisions | |
317 ediff-merge-directory-revisions | |
318 ediff-merge-directory-revisions-with-ancestor))) | |
319 (defsubst ediff-patch-metajob (&optional metajob) | |
320 (memq (or metajob ediff-metajob-name) | |
321 '(ediff-multifile-patch))) | |
322 ;; metajob involving only one group of files, such as multipatch or directory | |
323 ;; revision | |
324 (defsubst ediff-one-filegroup-metajob (&optional metajob) | |
325 (or (ediff-revision-metajob metajob) | |
326 (ediff-patch-metajob metajob) | |
327 ;; add more here | |
328 )) | |
329 ;; jobs suitable for the operation of collecting diffs into a multifile patch | |
330 (defsubst ediff-collect-diffs-metajob (&optional metajob) | |
331 (memq (or metajob ediff-metajob-name) | |
332 '(ediff-directories | |
333 ediff-merge-directories | |
334 ediff-merge-directories-with-ancestor | |
335 ediff-directory-revisions | |
336 ediff-merge-directory-revisions | |
337 ediff-merge-directory-revisions-with-ancestor | |
338 ;; add more here | |
339 ))) | |
340 (defsubst ediff-merge-metajob (&optional metajob) | |
341 (memq (or metajob ediff-metajob-name) | |
342 '(ediff-merge-directories | |
343 ediff-merge-directories-with-ancestor | |
344 ediff-merge-directory-revisions | |
345 ediff-merge-directory-revisions-with-ancestor | |
346 ediff-merge-filegroups-with-ancestor | |
347 ;; add more here | |
348 ))) | |
349 | |
350 (defsubst ediff-metajob3 (&optional metajob) | |
351 (memq (or metajob ediff-metajob-name) | |
352 '(ediff-merge-directories-with-ancestor | |
353 ediff-merge-filegroups-with-ancestor | |
354 ediff-directories3 | |
355 ediff-filegroups3))) | |
356 (defsubst ediff-comparison-metajob3 (&optional metajob) | |
357 (memq (or metajob ediff-metajob-name) | |
358 '(ediff-directories3 ediff-filegroups3))) | |
359 | |
360 ;; with no argument, checks if we are in ediff-control-buffer | |
361 ;; with argument, checks if we are in ediff-meta-buffer | |
362 (defun ediff-in-control-buffer-p (&optional meta-buf-p) | |
363 (and (boundp 'ediff-control-buffer) | |
364 (eq (if meta-buf-p ediff-meta-buffer ediff-control-buffer) | |
365 (current-buffer)))) | |
366 | |
367 (defsubst ediff-barf-if-not-control-buffer (&optional meta-buf-p) | |
368 (or (ediff-in-control-buffer-p meta-buf-p) | |
369 (error "%S: This command runs in Ediff Control Buffer only!" | |
370 this-command))) | |
371 | |
372 (defgroup ediff-highlighting nil | |
373 "Hilighting of difference regions in Ediff." | |
374 :prefix "ediff-" | |
375 :group 'ediff) | |
376 | |
377 (defgroup ediff-merge nil | |
378 "Merging utilities." | |
379 :prefix "ediff-" | |
380 :group 'ediff) | |
381 | |
382 (defgroup ediff-hook nil | |
383 "Hooks run by Ediff." | |
384 :prefix "ediff-" | |
385 :group 'ediff) | |
386 | |
387 ;; Hook variables | |
388 | |
389 (defcustom ediff-before-setup-hook nil | |
390 "Hooks to run before Ediff begins to set up windows and buffers. | |
391 This hook can be used to save the previous window config, which can be restored | |
392 on ediff-quit or ediff-suspend." | |
393 :type 'hook | |
394 :group 'ediff-hook) | |
395 (defcustom ediff-before-setup-windows-hook nil | |
396 "Hooks to run before Ediff sets its window configuration. | |
397 This hook is run every time when Ediff arranges its windows. | |
398 This happens each time Ediff detects that the windows were messed up by the | |
399 user." | |
400 :type 'hook | |
401 :group 'ediff-hook) | |
402 (defcustom ediff-after-setup-windows-hook nil | |
403 "Hooks to run after Ediff sets its window configuration. | |
404 This can be used to set up control window or icon in a desired place." | |
405 :type 'hook | |
406 :group 'ediff-hook) | |
407 (defcustom ediff-before-setup-control-frame-hook nil | |
408 "Hooks run before setting up the frame to display Ediff Control Panel. | |
409 Can be used to change control frame parameters to position it where it | |
410 is desirable." | |
411 :type 'hook | |
412 :group 'ediff-hook) | |
413 (defcustom ediff-after-setup-control-frame-hook nil | |
414 "Hooks run after setting up the frame to display Ediff Control Panel. | |
415 Can be used to move the frame where it is desired." | |
416 :type 'hook | |
417 :group 'ediff-hook) | |
418 (defcustom ediff-startup-hook nil | |
419 "Hooks to run in the control buffer after Ediff has been set up and is ready for the job." | |
420 :type 'hook | |
421 :group 'ediff-hook) | |
422 (defcustom ediff-select-hook nil | |
423 "Hooks to run after a difference has been selected." | |
424 :type 'hook | |
425 :group 'ediff-hook) | |
426 (defcustom ediff-unselect-hook nil | |
427 "Hooks to run after a difference has been unselected." | |
428 :type 'hook | |
429 :group 'ediff-hook) | |
430 (defcustom ediff-prepare-buffer-hook nil | |
431 "Hooks run after buffers A, B, and C are set up. | |
432 For each buffer, the hooks are run with that buffer made current." | |
433 :type 'hook | |
434 :group 'ediff-hook) | |
435 (defcustom ediff-load-hook nil | |
436 "Hook run after Ediff is loaded. Can be used to change defaults." | |
437 :type 'hook | |
438 :group 'ediff-hook) | |
439 | |
440 (defcustom ediff-mode-hook nil | |
441 "Hook run just after ediff-mode is set up in the control buffer. | |
442 This is done before any windows or frames are created. One can use it to | |
443 set local variables that determine how the display looks like." | |
444 :type 'hook | |
445 :group 'ediff-hook) | |
446 (defcustom ediff-keymap-setup-hook nil | |
447 "Hook run just after the default bindings in Ediff keymap are set up." | |
448 :type 'hook | |
449 :group 'ediff-hook) | |
450 | |
451 (defcustom ediff-display-help-hook nil | |
452 "Hooks run after preparing the help message." | |
453 :type 'hook | |
454 :group 'ediff-hook) | |
455 | |
456 (defcustom ediff-suspend-hook nil | |
457 "Hooks to run in the Ediff control buffer when Ediff is suspended." | |
458 :type 'hook | |
459 :group 'ediff-hook) | |
460 (defcustom ediff-quit-hook nil | |
461 "Hooks to run in the Ediff control buffer after finishing Ediff." | |
462 :type 'hook | |
463 :group 'ediff-hook) | |
464 (defcustom ediff-cleanup-hook nil | |
465 "Hooks to run on exiting Ediff but before killing the control and variant buffers." | |
466 :type 'hook | |
467 :group 'ediff-hook) | |
468 | |
469 ;; Error messages | |
470 (defconst ediff-KILLED-VITAL-BUFFER | |
471 "You have killed a vital Ediff buffer---you must leave Ediff now!") | |
472 (defconst ediff-NO-DIFFERENCES | |
473 "Sorry, comparison of identical variants is not what I am made for...") | |
474 (defconst ediff-BAD-DIFF-NUMBER | |
475 ;; %S stands for this-command, %d - diff number, %d - max diff | |
476 "%S: Bad diff region number, %d. Valid numbers are 1 to %d") | |
477 (defconst ediff-BAD-INFO (format " | |
478 *** The Info file for Ediff, a part of the standard distribution | |
479 *** of %sEmacs, does not seem to be properly installed. | |
480 *** | |
481 *** Please contact your system administrator. " | |
482 (if (featurep 'xemacs) "X" ""))) | |
483 | |
484 ;; Selective browsing | |
485 | |
486 (ediff-defvar-local ediff-skip-diff-region-function 'ediff-show-all-diffs | |
487 "Function that determines the next/previous diff region to show. | |
488 Should return t for regions to be ignored and nil otherwise. | |
489 This function gets a region number as an argument. The region number | |
490 is the one used internally by Ediff. It is 1 less than the number seen | |
491 by the user.") | |
492 | |
493 (ediff-defvar-local ediff-hide-regexp-matches-function | |
494 'ediff-hide-regexp-matches | |
495 "Function to use in determining which regions to hide. | |
496 See the documentation string of `ediff-hide-regexp-matches' for details.") | |
497 (ediff-defvar-local ediff-focus-on-regexp-matches-function | |
498 'ediff-focus-on-regexp-matches | |
499 "Function to use in determining which regions to focus on. | |
500 See the documentation string of `ediff-focus-on-regexp-matches' for details.") | |
501 | |
502 ;; Regexp that determines buf A regions to focus on when skipping to diff | |
503 (ediff-defvar-local ediff-regexp-focus-A "" "") | |
504 ;; Regexp that determines buf B regions to focus on when skipping to diff | |
505 (ediff-defvar-local ediff-regexp-focus-B "" "") | |
506 ;; Regexp that determines buf C regions to focus on when skipping to diff | |
507 (ediff-defvar-local ediff-regexp-focus-C "" "") | |
508 ;; connective that determines whether to focus regions that match both or | |
509 ;; one of the regexps | |
510 (ediff-defvar-local ediff-focus-regexp-connective 'and "") | |
511 | |
512 ;; Regexp that determines buf A regions to ignore when skipping to diff | |
513 (ediff-defvar-local ediff-regexp-hide-A "" "") | |
514 ;; Regexp that determines buf B regions to ignore when skipping to diff | |
515 (ediff-defvar-local ediff-regexp-hide-B "" "") | |
516 ;; Regexp that determines buf C regions to ignore when skipping to diff | |
517 (ediff-defvar-local ediff-regexp-hide-C "" "") | |
518 ;; connective that determines whether to hide regions that match both or | |
519 ;; one of the regexps | |
520 (ediff-defvar-local ediff-hide-regexp-connective 'and "") | |
521 | |
522 | |
523 ;;; Copying difference regions between buffers. | |
524 | |
525 ;; A list of killed diffs. | |
526 ;; A diff is saved here if it is replaced by a diff | |
527 ;; from another buffer. This alist has the form: | |
528 ;; \((num (buff-object . diff) (buff-object . diff) (buff-object . diff)) ...), | |
529 ;; where some buffer-objects may be missing. | |
530 (ediff-defvar-local ediff-killed-diffs-alist nil "") | |
531 | |
532 ;; Syntax table to use in ediff-forward-word-function | |
533 ;; This is chosen by a heuristic. The important thing is for all buffers to | |
534 ;; have the same syntax table. Which is not too important. | |
535 (ediff-defvar-local ediff-syntax-table nil "") | |
536 | |
537 | |
538 ;; Highlighting | |
539 (defcustom ediff-before-flag-bol (if (featurep 'xemacs) (make-glyph "->>") "->>") | |
540 "Flag placed before a highlighted block of differences, if block starts at beginning of a line." | |
541 :type 'string | |
542 :tag "Region before-flag at beginning of line" | |
543 :group 'ediff) | |
544 | |
545 (defcustom ediff-after-flag-eol (if (featurep 'xemacs) (make-glyph "<<-") "<<-") | |
546 "Flag placed after a highlighted block of differences, if block ends at end of a line." | |
547 :type 'string | |
548 :tag "Region after-flag at end of line" | |
549 :group 'ediff) | |
550 | |
551 (defcustom ediff-before-flag-mol (if (featurep 'xemacs) (make-glyph "->>") "->>") | |
552 "Flag placed before a highlighted block of differences, if block starts in mid-line." | |
553 :type 'string | |
554 :tag "Region before-flag in the middle of line" | |
555 :group 'ediff) | |
556 (defcustom ediff-after-flag-mol (if (featurep 'xemacs) (make-glyph "<<-") "<<-") | |
557 "Flag placed after a highlighted block of differences, if block ends in mid-line." | |
558 :type 'string | |
559 :tag "Region after-flag in the middle of line" | |
560 :group 'ediff) | |
561 | |
562 | |
563 (ediff-defvar-local ediff-use-faces t "") | |
564 (defcustom ediff-use-faces t | |
565 "If t, differences are highlighted using faces, if device supports faces. | |
566 If nil, differences are highlighted using ASCII flags, ediff-before-flag | |
567 and ediff-after-flag. On a non-window system, differences are always | |
568 highlighted using ASCII flags." | |
569 :type 'boolean | |
570 :group 'ediff-highlighting) | |
571 | |
572 ;; this indicates that diff regions are word-size, so fine diffs are | |
573 ;; permanently nixed; used in ediff-windows-wordwise and ediff-regions-wordwise | |
574 (ediff-defvar-local ediff-word-mode nil "") | |
575 ;; Name of the job (ediff-files, ediff-windows, etc.) | |
576 (ediff-defvar-local ediff-job-name nil "") | |
577 | |
578 ;; Narrowing and ediff-region/windows support | |
579 ;; This is a list (overlay-A overlay-B overlay-C) | |
580 ;; If set, Ediff compares only those parts of buffers A/B/C that lie within | |
581 ;; the bounds of these overlays. | |
582 (ediff-defvar-local ediff-narrow-bounds nil "") | |
583 | |
584 ;; List (overlay-A overlay-B overlay-C), where each overlay spans the | |
585 ;; entire corresponding buffer. | |
586 (ediff-defvar-local ediff-wide-bounds nil "") | |
587 | |
588 ;; Current visibility boundaries in buffers A, B, and C. | |
589 ;; This is also a list of overlays. When the user toggles narrow/widen, | |
590 ;; this list changes from ediff-wide-bounds to ediff-narrow-bounds. | |
591 ;; and back. | |
592 (ediff-defvar-local ediff-visible-bounds nil "") | |
593 | |
594 (ediff-defvar-local ediff-start-narrowed t | |
595 "Non-nil means start narrowed, if doing ediff-windows-* or ediff-regions-*") | |
596 (ediff-defvar-local ediff-quit-widened t | |
597 "*Non-nil means: when finished, Ediff widens buffers A/B. | |
598 Actually, Ediff restores the scope of visibility that existed at startup.") | |
599 | |
600 (defcustom ediff-keep-variants t | |
601 "nil means prompt to remove unmodified buffers A/B/C at session end. | |
602 Supplying a prefix argument to the quit command `q' temporarily reverses the | |
603 meaning of this variable." | |
604 :type 'boolean | |
605 :group 'ediff) | |
606 | |
607 (ediff-defvar-local ediff-highlight-all-diffs t "") | |
608 (defcustom ediff-highlight-all-diffs t | |
609 "If nil, only the selected differences are highlighted. | |
610 Otherwise, all difference regions are highlighted, but the selected region is | |
611 shown in brighter colors." | |
612 :type 'boolean | |
613 :group 'ediff-highlighting) | |
614 | |
615 | |
616 ;; The suffix of the control buffer name. | |
617 (ediff-defvar-local ediff-control-buffer-suffix nil "") | |
618 ;; Same as ediff-control-buffer-suffix, but without <,>. | |
619 ;; It's a number rather than string. | |
620 (ediff-defvar-local ediff-control-buffer-number nil "") | |
621 | |
622 | |
623 ;; The original values of ediff-protected-variables for buffer A | |
624 (ediff-defvar-local ediff-buffer-values-orig-A nil "") | |
625 ;; The original values of ediff-protected-variables for buffer B | |
626 (ediff-defvar-local ediff-buffer-values-orig-B nil "") | |
627 ;; The original values of ediff-protected-variables for buffer C | |
628 (ediff-defvar-local ediff-buffer-values-orig-C nil "") | |
629 ;; The original values of ediff-protected-variables for buffer Ancestor | |
630 (ediff-defvar-local ediff-buffer-values-orig-Ancestor nil "") | |
631 | |
632 ;; association between buff-type and ediff-buffer-values-orig-* | |
633 (defconst ediff-buffer-values-orig-alist | |
634 '((A . ediff-buffer-values-orig-A) | |
635 (B . ediff-buffer-values-orig-B) | |
636 (C . ediff-buffer-values-orig-C) | |
637 (Ancestor . ediff-buffer-values-orig-Ancestor))) | |
638 | |
639 ;; Buffer-local variables to be saved then restored during Ediff sessions | |
640 (defconst ediff-protected-variables '( | |
641 ;;buffer-read-only | |
642 mode-line-format)) | |
643 | |
644 ;; Vector of differences between the variants. Each difference is | |
645 ;; represented by a vector of two overlays plus a vector of fine diffs, | |
646 ;; plus a no-fine-diffs flag. The first overlay spans the | |
647 ;; difference region in the A buffer and the second overlays the diff in | |
648 ;; the B buffer. If a difference section is empty, the corresponding | |
649 ;; overlay's endpoints coincide. | |
650 ;; | |
651 ;; The precise form of a Difference Vector for one buffer is: | |
652 ;; [diff diff diff ...] | |
653 ;; where each diff has the form: | |
654 ;; [diff-overlay fine-diff-vector no-fine-diffs-flag state-of-diff] | |
655 ;; fine-diff-vector is a vector [fine-diff-overlay fine-diff-overlay ...] | |
656 ;; no-fine-diffs-flag says if there are fine differences. | |
657 ;; state-of-difference is A, B, C, or nil, indicating which buffer is | |
658 ;; different from the other two (used only in 3-way jobs. | |
659 (ediff-defvar-local ediff-difference-vector-A nil "") | |
660 (ediff-defvar-local ediff-difference-vector-B nil "") | |
661 (ediff-defvar-local ediff-difference-vector-C nil "") | |
662 (ediff-defvar-local ediff-difference-vector-Ancestor nil "") | |
663 ;; A-list of diff vector types associated with buffer types | |
664 (defconst ediff-difference-vector-alist | |
665 '((A . ediff-difference-vector-A) | |
666 (B . ediff-difference-vector-B) | |
667 (C . ediff-difference-vector-C) | |
668 (Ancestor . ediff-difference-vector-Ancestor))) | |
669 | |
670 ;; [ status status status ...] | |
671 ;; Each status: [state-of-merge state-of-ancestor] | |
672 ;; state-of-merge is default-A, default-B, prefer-A, or prefer-B. It | |
673 ;; indicates the way a diff region was created in buffer C. | |
674 ;; state-of-ancestor says if the corresponding region in ancestor buffer is | |
675 ;; empty. | |
676 (ediff-defvar-local ediff-state-of-merge nil "") | |
677 | |
678 ;; The difference that is currently selected. | |
679 (ediff-defvar-local ediff-current-difference -1 "") | |
680 ;; Number of differences found. | |
681 (ediff-defvar-local ediff-number-of-differences nil "") | |
682 | |
683 ;; Buffer containing the output of diff, which is used by Ediff to step | |
684 ;; through files. | |
685 (ediff-defvar-local ediff-diff-buffer nil "") | |
686 ;; Like ediff-diff-buffer, but contains context diff. It is not used by | |
687 ;; Ediff, but it is saved in a file, if user requests so. | |
688 (ediff-defvar-local ediff-custom-diff-buffer nil "") | |
689 ;; Buffer used for diff-style fine differences between regions. | |
690 (ediff-defvar-local ediff-fine-diff-buffer nil "") | |
691 ;; Temporary buffer used for computing fine differences. | |
692 (defconst ediff-tmp-buffer " *ediff-tmp*" "") | |
693 ;; Buffer used for messages | |
694 (defconst ediff-msg-buffer " *ediff-message*" "") | |
695 ;; Buffer containing the output of diff when diff returns errors. | |
696 (ediff-defvar-local ediff-error-buffer nil "") | |
697 ;; Buffer to display debug info | |
698 (ediff-defvar-local ediff-debug-buffer "*ediff-debug*" "") | |
699 | |
700 ;; List of ediff control panels associated with each buffer A/B/C/Ancestor. | |
701 ;; Not used any more, but may be needed in the future. | |
702 (ediff-defvar-local ediff-this-buffer-ediff-sessions nil "") | |
703 | |
704 ;; to be deleted in due time | |
705 ;; List of difference overlays disturbed by working with the current diff. | |
706 (defvar ediff-disturbed-overlays nil "") | |
707 | |
708 ;; Priority of non-selected overlays. | |
709 (defvar ediff-shadow-overlay-priority 100 "") | |
710 | |
711 (defcustom ediff-version-control-package 'vc | |
712 "Version control package used. | |
713 Currently, Ediff supports vc.el, rcs.el, pcl-cvs.el, and generic-sc.el. The | |
714 standard Emacs interface to RCS, CVS, SCCS, etc., is vc.el. However, some | |
715 people find the other two packages more convenient. Set this variable to the | |
716 appropriate symbol: `rcs', `pcl-cvs', or `generic-sc' if you so desire." | |
717 :type 'symbol | |
718 :group 'ediff) | |
719 | |
720 (defcustom ediff-coding-system-for-read 'raw-text | |
721 "The coding system for read to use when running the diff program as a subprocess. | |
722 In most cases, the default will do. However, under certain circumstances in | |
723 MS-Windows you might need to use something like 'raw-text-dos here. | |
724 So, if the output that your diff program sends to Emacs contains extra ^M's, | |
725 you might need to experiment here, if the default or 'raw-text-dos doesn't | |
726 work." | |
727 :type 'symbol | |
728 :group 'ediff) | |
729 | |
730 (defcustom ediff-coding-system-for-write (if (featurep 'xemacs) | |
731 'escape-quoted | |
732 'emacs-internal) | |
733 "The coding system for write to use when writing out difference regions | |
734 to temp files in buffer jobs and when Ediff needs to find fine differences." | |
735 :type 'symbol | |
736 :group 'ediff) | |
737 | |
738 | |
739 (defalias 'ediff-read-event | |
740 (if (featurep 'xemacs) 'next-command-event 'read-event)) | |
741 | |
742 (defalias 'ediff-overlayp | |
743 (if (featurep 'xemacs) 'extentp 'overlayp)) | |
744 | |
745 (defalias 'ediff-make-overlay | |
746 (if (featurep 'xemacs) 'make-extent 'make-overlay)) | |
747 | |
748 (defalias 'ediff-delete-overlay | |
749 (if (featurep 'xemacs) 'delete-extent 'delete-overlay)) | |
750 | |
751 ;; Assumes that emacs-major-version and emacs-minor-version are defined. | |
752 (defun ediff-check-version (op major minor &optional type-of-emacs) | |
753 "Check the current version against MAJOR and MINOR version numbers. | |
754 The comparison uses operator OP, which may be any of: =, >, >=, <, <=. | |
755 TYPE-OF-EMACS is either 'xemacs or 'emacs." | |
756 (and (cond ((eq type-of-emacs 'xemacs) (featurep 'xemacs)) | |
757 ((eq type-of-emacs 'emacs) (featurep 'emacs)) | |
758 (t)) | |
759 (cond ((eq op '=) (and (= emacs-minor-version minor) | |
760 (= emacs-major-version major))) | |
761 ((memq op '(> >= < <=)) | |
762 (and (or (funcall op emacs-major-version major) | |
763 (= emacs-major-version major)) | |
764 (if (= emacs-major-version major) | |
765 (funcall op emacs-minor-version minor) | |
766 t))) | |
767 (t | |
768 (error "%S: Invalid op in ediff-check-version" op))))) | |
769 | |
770 ;; ediff-check-version seems to be totally unused anyway. | |
771 (make-obsolete 'ediff-check-version 'version< "23.1") | |
772 | |
773 (defun ediff-color-display-p () | |
774 (condition-case nil | |
775 (if (featurep 'xemacs) | |
776 (eq (device-class (selected-device)) 'color) ; xemacs form | |
777 (display-color-p)) ; emacs form | |
778 (error nil))) | |
779 | |
780 | |
781 ;; A var local to each control panel buffer. Indicates highlighting style | |
782 ;; in effect for this buffer: `face', `ascii', | |
783 ;; `off' -- turned off \(on a dumb terminal only\). | |
784 (ediff-defvar-local ediff-highlighting-style | |
785 (if (and (ediff-has-face-support-p) ediff-use-faces) 'face 'ascii) | |
786 "") | |
787 | |
788 | |
789 (if (ediff-has-face-support-p) | |
790 (if (featurep 'xemacs) | |
791 (progn | |
792 (defalias 'ediff-valid-color-p 'valid-color-name-p) | |
793 (defalias 'ediff-get-face 'get-face)) | |
794 (defalias 'ediff-valid-color-p (if (fboundp 'color-defined-p) | |
795 'color-defined-p | |
796 'x-color-defined-p)) | |
797 (defalias 'ediff-get-face 'internal-get-face))) | |
798 | |
799 (if (ediff-window-display-p) | |
800 (if (featurep 'xemacs) | |
801 (progn | |
802 (defalias 'ediff-display-pixel-width 'device-pixel-width) | |
803 (defalias 'ediff-display-pixel-height 'device-pixel-height)) | |
804 (defalias 'ediff-display-pixel-width | |
805 (if (fboundp 'display-pixel-width) | |
806 'display-pixel-width | |
807 'x-display-pixel-width)) | |
808 (defalias 'ediff-display-pixel-height | |
809 (if (fboundp 'display-pixel-height) | |
810 'display-pixel-height | |
811 'x-display-pixel-height)))) | |
812 | |
813 ;; A-list of current-diff-overlay symbols associated with buf types | |
814 (defconst ediff-current-diff-overlay-alist | |
815 '((A . ediff-current-diff-overlay-A) | |
816 (B . ediff-current-diff-overlay-B) | |
817 (C . ediff-current-diff-overlay-C) | |
818 (Ancestor . ediff-current-diff-overlay-Ancestor))) | |
819 | |
820 ;; A-list of current-diff-face-* symbols associated with buf types | |
821 (defconst ediff-current-diff-face-alist | |
822 '((A . ediff-current-diff-A) | |
823 (B . ediff-current-diff-B) | |
824 (C . ediff-current-diff-C) | |
825 (Ancestor . ediff-current-diff-Ancestor))) | |
826 | |
827 | |
828 (defun ediff-set-overlay-face (extent face) | |
829 (ediff-overlay-put extent 'face face) | |
830 (ediff-overlay-put extent 'help-echo 'ediff-region-help-echo)) | |
831 | |
832 (defun ediff-region-help-echo (extent-or-window &optional overlay point) | |
833 (unless overlay | |
834 (setq overlay extent-or-window)) | |
835 (let ((is-current (ediff-overlay-get overlay 'ediff)) | |
836 (face (ediff-overlay-get overlay 'face)) | |
837 (diff-num (ediff-overlay-get overlay 'ediff-diff-num)) | |
838 face-help) | |
839 | |
840 ;; This happens only for refinement overlays | |
841 (if (stringp face) | |
842 (setq face (intern face))) | |
843 (setq face-help (and face (get face 'ediff-help-echo))) | |
844 | |
845 (cond ((and is-current diff-num) ; current diff region | |
846 (format "Difference region %S -- current" (1+ diff-num))) | |
847 (face-help) ; refinement of current diff region | |
848 (diff-num ; non-current | |
849 (format "Difference region %S -- non-current" (1+ diff-num))) | |
850 (t "")) ; none | |
851 )) | |
852 | |
853 | |
854 (defun ediff-set-face-pixmap (face pixmap) | |
855 "Set face pixmap on a monochrome display." | |
856 (if (and (ediff-window-display-p) (not (ediff-color-display-p))) | |
857 (condition-case nil | |
858 (set-face-background-pixmap face pixmap) | |
859 (error | |
860 (message "Pixmap not found for %S: %s" (face-name face) pixmap) | |
861 (sit-for 1))))) | |
862 | |
863 (defun ediff-hide-face (face) | |
864 (if (and (ediff-has-face-support-p) | |
865 (boundp 'add-to-list) | |
866 (boundp 'facemenu-unlisted-faces)) | |
867 (add-to-list 'facemenu-unlisted-faces face))) | |
868 | |
869 | |
870 | |
871 (defface ediff-current-diff-A | |
872 (if (featurep 'emacs) | |
873 '((((class color) (min-colors 16)) | |
874 (:foreground "firebrick" :background "pale green")) | |
875 (((class color)) | |
876 (:foreground "blue3" :background "yellow3")) | |
877 (t (:inverse-video t))) | |
878 '((((type tty)) (:foreground "blue3" :background "yellow3")) | |
879 (((class color)) (:foreground "firebrick" :background "pale green")) | |
880 (t (:inverse-video t)))) | |
881 "Face for highlighting the selected difference in buffer A." | |
882 :group 'ediff-highlighting) | |
883 ;; An internal variable. Ediff takes the face from here. When unhighlighting, | |
884 ;; this variable is set to nil, then again to the appropriate face. | |
885 (defvar ediff-current-diff-face-A 'ediff-current-diff-A | |
886 "Face for highlighting the selected difference in buffer A. | |
887 DO NOT CHANGE this variable. Instead, use the customization | |
888 widget to customize the actual face object `ediff-current-diff-A' | |
889 this variable represents.") | |
890 (ediff-hide-face ediff-current-diff-face-A) | |
891 ;; Until custom.el for XEmacs starts supporting :inverse-video we do this. | |
892 ;; This means that some user customization may be trashed. | |
893 (and (featurep 'xemacs) | |
894 (ediff-has-face-support-p) | |
895 (not (ediff-color-display-p)) | |
896 (copy-face 'modeline ediff-current-diff-face-A)) | |
897 | |
898 | |
899 | |
900 (defface ediff-current-diff-B | |
901 (if (featurep 'emacs) | |
902 '((((class color) (min-colors 16)) | |
903 (:foreground "DarkOrchid" :background "Yellow")) | |
904 (((class color)) | |
905 (:foreground "magenta3" :background "yellow3" | |
906 :weight bold)) | |
907 (t (:inverse-video t))) | |
908 '((((type tty)) (:foreground "magenta3" :background "yellow3" | |
909 :weight bold)) | |
910 (((class color)) (:foreground "DarkOrchid" :background "Yellow")) | |
911 (t (:inverse-video t)))) | |
912 "Face for highlighting the selected difference in buffer B." | |
913 :group 'ediff-highlighting) | |
914 ;; An internal variable. Ediff takes the face from here. When unhighlighting, | |
915 ;; this variable is set to nil, then again to the appropriate face. | |
916 (defvar ediff-current-diff-face-B 'ediff-current-diff-B | |
917 "Face for highlighting the selected difference in buffer B. | |
918 this variable. Instead, use the customization | |
919 widget to customize the actual face `ediff-current-diff-B' | |
920 this variable represents.") | |
921 (ediff-hide-face ediff-current-diff-face-B) | |
922 ;; Until custom.el for XEmacs starts supporting :inverse-video we do this. | |
923 ;; This means that some user customization may be trashed. | |
924 (and (featurep 'xemacs) | |
925 (ediff-has-face-support-p) | |
926 (not (ediff-color-display-p)) | |
927 (copy-face 'modeline ediff-current-diff-face-B)) | |
928 | |
929 | |
930 (defface ediff-current-diff-C | |
931 (if (featurep 'emacs) | |
932 '((((class color) (min-colors 16)) | |
933 (:foreground "Navy" :background "Pink")) | |
934 (((class color)) | |
935 (:foreground "cyan3" :background "yellow3" :weight bold)) | |
936 (t (:inverse-video t))) | |
937 '((((type tty)) (:foreground "cyan3" :background "yellow3" :weight bold)) | |
938 (((class color)) (:foreground "Navy" :background "Pink")) | |
939 (t (:inverse-video t)))) | |
940 "Face for highlighting the selected difference in buffer C." | |
941 :group 'ediff-highlighting) | |
942 ;; An internal variable. Ediff takes the face from here. When unhighlighting, | |
943 ;; this variable is set to nil, then again to the appropriate face. | |
944 (defvar ediff-current-diff-face-C 'ediff-current-diff-C | |
945 "Face for highlighting the selected difference in buffer C. | |
946 DO NOT CHANGE this variable. Instead, use the customization | |
947 widget to customize the actual face object `ediff-current-diff-C' | |
948 this variable represents.") | |
949 (ediff-hide-face ediff-current-diff-face-C) | |
950 ;; Until custom.el for XEmacs starts supporting :inverse-video we do this. | |
951 ;; This means that some user customization may be trashed. | |
952 (and (featurep 'xemacs) | |
953 (ediff-has-face-support-p) | |
954 (not (ediff-color-display-p)) | |
955 (copy-face 'modeline ediff-current-diff-face-C)) | |
956 | |
957 | |
958 (defface ediff-current-diff-Ancestor | |
959 (if (featurep 'emacs) | |
960 '((((class color) (min-colors 16)) | |
961 (:foreground "Black" :background "VioletRed")) | |
962 (((class color)) | |
963 (:foreground "black" :background "magenta3")) | |
964 (t (:inverse-video t))) | |
965 '((((type tty)) (:foreground "black" :background "magenta3")) | |
966 (((class color)) (:foreground "Black" :background "VioletRed")) | |
967 (t (:inverse-video t)))) | |
968 "Face for highlighting the selected difference in buffer Ancestor." | |
969 :group 'ediff-highlighting) | |
970 ;; An internal variable. Ediff takes the face from here. When unhighlighting, | |
971 ;; this variable is set to nil, then again to the appropriate face. | |
972 (defvar ediff-current-diff-face-Ancestor 'ediff-current-diff-Ancestor | |
973 "Face for highlighting the selected difference in buffer Ancestor. | |
974 DO NOT CHANGE this variable. Instead, use the customization | |
975 widget to customize the actual face object `ediff-current-diff-Ancestor' | |
976 this variable represents.") | |
977 (ediff-hide-face ediff-current-diff-face-Ancestor) | |
978 ;; Until custom.el for XEmacs starts supporting :inverse-video we do this. | |
979 ;; This means that some user customization may be trashed. | |
980 (and (featurep 'xemacs) | |
981 (ediff-has-face-support-p) | |
982 (not (ediff-color-display-p)) | |
983 (copy-face 'modeline ediff-current-diff-face-Ancestor)) | |
984 | |
985 | |
986 (defface ediff-fine-diff-A | |
987 (if (featurep 'emacs) | |
988 '((((class color) (min-colors 16)) | |
989 (:foreground "Navy" :background "sky blue")) | |
990 (((class color)) | |
991 (:foreground "white" :background "sky blue" :weight bold)) | |
992 (t (:underline t :stipple "gray3"))) | |
993 '((((type tty)) (:foreground "white" :background "sky blue" :weight bold)) | |
994 (((class color)) (:foreground "Navy" :background "sky blue")) | |
995 (t (:underline t :stipple "gray3")))) | |
996 "Face for highlighting the refinement of the selected diff in buffer A." | |
997 :group 'ediff-highlighting) | |
998 ;; An internal variable. Ediff takes the face from here. When unhighlighting, | |
999 ;; this variable is set to nil, then again to the appropriate face. | |
1000 (defvar ediff-fine-diff-face-A 'ediff-fine-diff-A | |
1001 "Face for highlighting the fine differences in buffer A. | |
1002 DO NOT CHANGE this variable. Instead, use the customization | |
1003 widget to customize the actual face object `ediff-fine-diff-A' | |
1004 this variable represents.") | |
1005 (ediff-hide-face ediff-fine-diff-face-A) | |
1006 | |
1007 (defface ediff-fine-diff-B | |
1008 (if (featurep 'emacs) | |
1009 '((((class color) (min-colors 16)) | |
1010 (:foreground "Black" :background "cyan")) | |
1011 (((class color)) | |
1012 (:foreground "magenta3" :background "cyan3")) | |
1013 (t (:underline t :stipple "gray3"))) | |
1014 '((((type tty)) (:foreground "magenta3" :background "cyan3")) | |
1015 (((class color)) (:foreground "Black" :background "cyan")) | |
1016 (t (:underline t :stipple "gray3")))) | |
1017 "Face for highlighting the refinement of the selected diff in buffer B." | |
1018 :group 'ediff-highlighting) | |
1019 ;; An internal variable. Ediff takes the face from here. When unhighlighting, | |
1020 ;; this variable is set to nil, then again to the appropriate face. | |
1021 (defvar ediff-fine-diff-face-B 'ediff-fine-diff-B | |
1022 "Face for highlighting the fine differences in buffer B. | |
1023 DO NOT CHANGE this variable. Instead, use the customization | |
1024 widget to customize the actual face object `ediff-fine-diff-B' | |
1025 this variable represents.") | |
1026 (ediff-hide-face ediff-fine-diff-face-B) | |
1027 | |
1028 (defface ediff-fine-diff-C | |
1029 (if (featurep 'emacs) | |
1030 '((((type pc)) | |
1031 (:foreground "white" :background "Turquoise")) | |
1032 (((class color) (min-colors 16)) | |
1033 (:foreground "Black" :background "Turquoise")) | |
1034 (((class color)) | |
1035 (:foreground "yellow3" :background "Turquoise" | |
1036 :weight bold)) | |
1037 (t (:underline t :stipple "gray3"))) | |
1038 '((((type tty)) (:foreground "yellow3" :background "Turquoise" | |
1039 :weight bold)) | |
1040 (((type pc)) (:foreground "white" :background "Turquoise")) | |
1041 (((class color)) (:foreground "Black" :background "Turquoise")) | |
1042 (t (:underline t :stipple "gray3")))) | |
1043 "Face for highlighting the refinement of the selected diff in buffer C." | |
1044 :group 'ediff-highlighting) | |
1045 ;; An internal variable. Ediff takes the face from here. When unhighlighting, | |
1046 ;; this variable is set to nil, then again to the appropriate face. | |
1047 (defvar ediff-fine-diff-face-C 'ediff-fine-diff-C | |
1048 "Face for highlighting the fine differences in buffer C. | |
1049 DO NOT CHANGE this variable. Instead, use the customization | |
1050 widget to customize the actual face object `ediff-fine-diff-C' | |
1051 this variable represents.") | |
1052 (ediff-hide-face ediff-fine-diff-face-C) | |
1053 | |
1054 (defface ediff-fine-diff-Ancestor | |
1055 (if (featurep 'emacs) | |
1056 '((((class color) (min-colors 16)) | |
1057 (:foreground "Black" :background "Green")) | |
1058 (((class color)) | |
1059 (:foreground "red3" :background "green")) | |
1060 (t (:underline t :stipple "gray3"))) | |
1061 '((((type tty)) (:foreground "red3" :background "green")) | |
1062 (((class color)) (:foreground "Black" :background "Green")) | |
1063 (t (:underline t :stipple "gray3")))) | |
1064 "Face for highlighting the refinement of the selected diff in the ancestor buffer. | |
1065 At present, this face is not used and no fine differences are computed for the | |
1066 ancestor buffer." | |
1067 :group 'ediff-highlighting) | |
1068 ;; An internal variable. Ediff takes the face from here. When unhighlighting, | |
1069 ;; this variable is set to nil, then again to the appropriate face. | |
1070 (defvar ediff-fine-diff-face-Ancestor 'ediff-fine-diff-Ancestor | |
1071 "Face for highlighting the fine differences in buffer Ancestor. | |
1072 DO NOT CHANGE this variable. Instead, use the customization | |
1073 widget to customize the actual face object `ediff-fine-diff-Ancestor' | |
1074 this variable represents.") | |
1075 (ediff-hide-face ediff-fine-diff-face-Ancestor) | |
1076 | |
1077 ;; Some installs don't have stipple or Stipple. So, try them in turn. | |
1078 (defvar stipple-pixmap | |
1079 (cond ((not (ediff-has-face-support-p)) nil) | |
1080 ((and (boundp 'x-bitmap-file-path) | |
1081 (locate-library "stipple" t x-bitmap-file-path)) "stipple") | |
1082 ((and (boundp 'mswindowsx-bitmap-file-path) | |
1083 (locate-library "stipple" t mswindowsx-bitmap-file-path)) "stipple") | |
1084 (t "Stipple"))) | |
1085 | |
1086 (defface ediff-even-diff-A | |
1087 (if (featurep 'emacs) | |
1088 `((((type pc)) | |
1089 (:foreground "green3" :background "light grey")) | |
1090 (((class color) (min-colors 16)) | |
1091 (:foreground "Black" :background "light grey")) | |
1092 (((class color)) | |
1093 (:foreground "red3" :background "light grey" | |
1094 :weight bold)) | |
1095 (t (:italic t :stipple ,stipple-pixmap))) | |
1096 `((((type tty)) (:foreground "red3" :background "light grey" | |
1097 :weight bold)) | |
1098 (((type pc)) (:foreground "green3" :background "light grey")) | |
1099 (((class color)) (:foreground "Black" :background "light grey")) | |
1100 (t (:italic t :stipple ,stipple-pixmap)))) | |
1101 "Face for highlighting even-numbered non-current differences in buffer A." | |
1102 :group 'ediff-highlighting) | |
1103 ;; An internal variable. Ediff takes the face from here. When unhighlighting, | |
1104 ;; this variable is set to nil, then again to the appropriate face. | |
1105 (defvar ediff-even-diff-face-A 'ediff-even-diff-A | |
1106 "Face for highlighting even-numbered non-current differences in buffer A. | |
1107 DO NOT CHANGE this variable. Instead, use the customization | |
1108 widget to customize the actual face object `ediff-even-diff-A' | |
1109 this variable represents.") | |
1110 (ediff-hide-face ediff-even-diff-face-A) | |
1111 | |
1112 (defface ediff-even-diff-B | |
1113 (if (featurep 'emacs) | |
1114 `((((class color) (min-colors 16)) | |
1115 (:foreground "White" :background "Grey")) | |
1116 (((class color)) | |
1117 (:foreground "blue3" :background "Grey" :weight bold)) | |
1118 (t (:italic t :stipple ,stipple-pixmap))) | |
1119 `((((type tty)) (:foreground "blue3" :background "Grey" :weight bold)) | |
1120 (((class color)) (:foreground "White" :background "Grey")) | |
1121 (t (:italic t :stipple ,stipple-pixmap)))) | |
1122 "Face for highlighting even-numbered non-current differences in buffer B." | |
1123 :group 'ediff-highlighting) | |
1124 ;; An internal variable. Ediff takes the face from here. When unhighlighting, | |
1125 ;; this variable is set to nil, then again to the appropriate face. | |
1126 (defvar ediff-even-diff-face-B 'ediff-even-diff-B | |
1127 "Face for highlighting even-numbered non-current differences in buffer B. | |
1128 DO NOT CHANGE this variable. Instead, use the customization | |
1129 widget to customize the actual face object `ediff-even-diff-B' | |
1130 this variable represents.") | |
1131 (ediff-hide-face ediff-even-diff-face-B) | |
1132 | |
1133 (defface ediff-even-diff-C | |
1134 (if (featurep 'emacs) | |
1135 `((((type pc)) | |
1136 (:foreground "yellow3" :background "light grey")) | |
1137 (((class color) (min-colors 16)) | |
1138 (:foreground "Black" :background "light grey")) | |
1139 (((class color)) | |
1140 (:foreground "yellow3" :background "light grey" | |
1141 :weight bold)) | |
1142 (t (:italic t :stipple ,stipple-pixmap))) | |
1143 `((((type tty)) (:foreground "yellow3" :background "light grey" | |
1144 :weight bold)) | |
1145 (((type pc)) (:foreground "yellow3" :background "light grey")) | |
1146 (((class color)) (:foreground "Black" :background "light grey")) | |
1147 (t (:italic t :stipple ,stipple-pixmap)))) | |
1148 "Face for highlighting even-numbered non-current differences in buffer C." | |
1149 :group 'ediff-highlighting) | |
1150 ;; An internal variable. Ediff takes the face from here. When unhighlighting, | |
1151 ;; this variable is set to nil, then again to the appropriate face. | |
1152 (defvar ediff-even-diff-face-C 'ediff-even-diff-C | |
1153 "Face for highlighting even-numbered non-current differences in buffer C. | |
1154 DO NOT CHANGE this variable. Instead, use the customization | |
1155 widget to customize the actual face object `ediff-even-diff-C' | |
1156 this variable represents.") | |
1157 (ediff-hide-face ediff-even-diff-face-C) | |
1158 | |
1159 (defface ediff-even-diff-Ancestor | |
1160 (if (featurep 'emacs) | |
1161 `((((type pc)) | |
1162 (:foreground "cyan3" :background "light grey")) | |
1163 (((class color) (min-colors 16)) | |
1164 (:foreground "White" :background "Grey")) | |
1165 (((class color)) | |
1166 (:foreground "cyan3" :background "light grey" | |
1167 :weight bold)) | |
1168 (t (:italic t :stipple ,stipple-pixmap))) | |
1169 `((((type tty)) (:foreground "cyan3" :background "light grey" | |
1170 :weight bold)) | |
1171 (((type pc)) (:foreground "cyan3" :background "light grey")) | |
1172 (((class color)) (:foreground "White" :background "Grey")) | |
1173 (t (:italic t :stipple ,stipple-pixmap)))) | |
1174 "Face for highlighting even-numbered non-current differences in the ancestor buffer." | |
1175 :group 'ediff-highlighting) | |
1176 ;; An internal variable. Ediff takes the face from here. When unhighlighting, | |
1177 ;; this variable is set to nil, then again to the appropriate face. | |
1178 (defvar ediff-even-diff-face-Ancestor 'ediff-even-diff-Ancestor | |
1179 "Face for highlighting even-numbered non-current differences in buffer Ancestor. | |
1180 DO NOT CHANGE this variable. Instead, use the customization | |
1181 widget to customize the actual face object `ediff-even-diff-Ancestor' | |
1182 this variable represents.") | |
1183 (ediff-hide-face ediff-even-diff-face-Ancestor) | |
1184 | |
1185 ;; Association between buffer types and even-diff-face symbols | |
1186 (defconst ediff-even-diff-face-alist | |
1187 '((A . ediff-even-diff-A) | |
1188 (B . ediff-even-diff-B) | |
1189 (C . ediff-even-diff-C) | |
1190 (Ancestor . ediff-even-diff-Ancestor))) | |
1191 | |
1192 (defface ediff-odd-diff-A | |
1193 (if (featurep 'emacs) | |
1194 '((((type pc)) | |
1195 (:foreground "green3" :background "gray40")) | |
1196 (((class color) (min-colors 16)) | |
1197 (:foreground "White" :background "Grey")) | |
1198 (((class color)) | |
1199 (:foreground "red3" :background "black" :weight bold)) | |
1200 (t (:italic t :stipple "gray1"))) | |
1201 '((((type tty)) (:foreground "red3" :background "black" :weight bold)) | |
1202 (((type pc)) (:foreground "green3" :background "gray40")) | |
1203 (((class color)) (:foreground "White" :background "Grey")) | |
1204 (t (:italic t :stipple "gray1")))) | |
1205 "Face for highlighting odd-numbered non-current differences in buffer A." | |
1206 :group 'ediff-highlighting) | |
1207 ;; An internal variable. Ediff takes the face from here. When unhighlighting, | |
1208 ;; this variable is set to nil, then again to the appropriate face. | |
1209 (defvar ediff-odd-diff-face-A 'ediff-odd-diff-A | |
1210 "Face for highlighting odd-numbered non-current differences in buffer A. | |
1211 DO NOT CHANGE this variable. Instead, use the customization | |
1212 widget to customize the actual face object `ediff-odd-diff-A' | |
1213 this variable represents.") | |
1214 (ediff-hide-face ediff-odd-diff-face-A) | |
1215 | |
1216 | |
1217 (defface ediff-odd-diff-B | |
1218 (if (featurep 'emacs) | |
1219 '((((type pc)) | |
1220 (:foreground "White" :background "gray40")) | |
1221 (((class color) (min-colors 16)) | |
1222 (:foreground "Black" :background "light grey")) | |
1223 (((class color)) | |
1224 (:foreground "cyan3" :background "black" :weight bold)) | |
1225 (t (:italic t :stipple "gray1"))) | |
1226 '((((type tty)) (:foreground "cyan3" :background "black" :weight bold)) | |
1227 (((type pc)) (:foreground "White" :background "gray40")) | |
1228 (((class color)) (:foreground "Black" :background "light grey")) | |
1229 (t (:italic t :stipple "gray1")))) | |
1230 "Face for highlighting odd-numbered non-current differences in buffer B." | |
1231 :group 'ediff-highlighting) | |
1232 ;; An internal variable. Ediff takes the face from here. When unhighlighting, | |
1233 ;; this variable is set to nil, then again to the appropriate face. | |
1234 (defvar ediff-odd-diff-face-B 'ediff-odd-diff-B | |
1235 "Face for highlighting odd-numbered non-current differences in buffer B. | |
1236 DO NOT CHANGE this variable. Instead, use the customization | |
1237 widget to customize the actual face object `ediff-odd-diff-B' | |
1238 this variable represents.") | |
1239 (ediff-hide-face ediff-odd-diff-face-B) | |
1240 | |
1241 (defface ediff-odd-diff-C | |
1242 (if (featurep 'emacs) | |
1243 '((((type pc)) | |
1244 (:foreground "yellow3" :background "gray40")) | |
1245 (((class color) (min-colors 16)) | |
1246 (:foreground "White" :background "Grey")) | |
1247 (((class color)) | |
1248 (:foreground "yellow3" :background "black" :weight bold)) | |
1249 (t (:italic t :stipple "gray1"))) | |
1250 '((((type tty)) (:foreground "yellow3" :background "black" :weight bold)) | |
1251 (((type pc)) (:foreground "yellow3" :background "gray40")) | |
1252 (((class color)) (:foreground "White" :background "Grey")) | |
1253 (t (:italic t :stipple "gray1")))) | |
1254 "Face for highlighting odd-numbered non-current differences in buffer C." | |
1255 :group 'ediff-highlighting) | |
1256 ;; An internal variable. Ediff takes the face from here. When unhighlighting, | |
1257 ;; this variable is set to nil, then again to the appropriate face. | |
1258 (defvar ediff-odd-diff-face-C 'ediff-odd-diff-C | |
1259 "Face for highlighting odd-numbered non-current differences in buffer C. | |
1260 DO NOT CHANGE this variable. Instead, use the customization | |
1261 widget to customize the actual face object `ediff-odd-diff-C' | |
1262 this variable represents.") | |
1263 (ediff-hide-face ediff-odd-diff-face-C) | |
1264 | |
1265 (defface ediff-odd-diff-Ancestor | |
1266 (if (featurep 'emacs) | |
1267 '((((class color) (min-colors 16)) | |
1268 (:foreground "cyan3" :background "gray40")) | |
1269 (((class color)) | |
1270 (:foreground "green3" :background "black" :weight bold)) | |
1271 (t (:italic t :stipple "gray1"))) | |
1272 '((((type tty)) (:foreground "green3" :background "black" :weight bold)) | |
1273 (((class color)) (:foreground "cyan3" :background "gray40")) | |
1274 (t (:italic t :stipple "gray1")))) | |
1275 "Face for highlighting odd-numbered non-current differences in the ancestor buffer." | |
1276 :group 'ediff-highlighting) | |
1277 ;; An internal variable. Ediff takes the face from here. When unhighlighting, | |
1278 ;; this variable is set to nil, then again to the appropriate face. | |
1279 (defvar ediff-odd-diff-face-Ancestor 'ediff-odd-diff-Ancestor | |
1280 "Face for highlighting odd-numbered non-current differences in buffer Ancestor. | |
1281 DO NOT CHANGE this variable. Instead, use the customization | |
1282 widget to customize the actual face object `ediff-odd-diff-Ancestor' | |
1283 this variable represents.") | |
1284 (ediff-hide-face ediff-odd-diff-face-Ancestor) | |
1285 | |
1286 ;; Association between buffer types and odd-diff-face symbols | |
1287 (defconst ediff-odd-diff-face-alist | |
1288 '((A . ediff-odd-diff-A) | |
1289 (B . ediff-odd-diff-B) | |
1290 (C . ediff-odd-diff-C) | |
1291 (Ancestor . ediff-odd-diff-Ancestor))) | |
1292 | |
1293 ;; A-list of fine-diff face symbols associated with buffer types | |
1294 (defconst ediff-fine-diff-face-alist | |
1295 '((A . ediff-fine-diff-A) | |
1296 (B . ediff-fine-diff-B) | |
1297 (C . ediff-fine-diff-C) | |
1298 (Ancestor . ediff-fine-diff-Ancestor))) | |
1299 | |
1300 ;; Help echo | |
1301 (put ediff-fine-diff-face-A 'ediff-help-echo | |
1302 "A `refinement' of the current difference region") | |
1303 (put ediff-fine-diff-face-B 'ediff-help-echo | |
1304 "A `refinement' of the current difference region") | |
1305 (put ediff-fine-diff-face-C 'ediff-help-echo | |
1306 "A `refinement' of the current difference region") | |
1307 (put ediff-fine-diff-face-Ancestor 'ediff-help-echo | |
1308 "A `refinement' of the current difference region") | |
1309 | |
1310 (add-hook 'ediff-quit-hook 'ediff-cleanup-mess) | |
1311 (add-hook 'ediff-suspend-hook 'ediff-default-suspend-function) | |
1312 | |
1313 | |
1314 ;;; Overlays | |
1315 | |
1316 (ediff-defvar-local ediff-current-diff-overlay-A nil | |
1317 "Overlay for the current difference region in buffer A.") | |
1318 (ediff-defvar-local ediff-current-diff-overlay-B nil | |
1319 "Overlay for the current difference region in buffer B.") | |
1320 (ediff-defvar-local ediff-current-diff-overlay-C nil | |
1321 "Overlay for the current difference region in buffer C.") | |
1322 (ediff-defvar-local ediff-current-diff-overlay-Ancestor nil | |
1323 "Overlay for the current difference region in the ancestor buffer.") | |
1324 | |
1325 ;; Compute priority of a current ediff overlay. | |
1326 (defun ediff-highest-priority (start end buffer) | |
1327 (let ((pos (max 1 (1- start))) | |
1328 ovr-list) | |
1329 (if (featurep 'xemacs) | |
1330 (1+ ediff-shadow-overlay-priority) | |
1331 (ediff-with-current-buffer buffer | |
1332 (while (< pos (min (point-max) (1+ end))) | |
1333 (setq ovr-list (append (overlays-at pos) ovr-list)) | |
1334 (setq pos (next-overlay-change pos))) | |
1335 (+ 1 ediff-shadow-overlay-priority | |
1336 (apply 'max | |
1337 (cons | |
1338 1 | |
1339 (mapcar | |
1340 (lambda (ovr) | |
1341 (if (and ovr | |
1342 ;; exclude ediff overlays from priority | |
1343 ;; calculation, or else priority will keep | |
1344 ;; increasing | |
1345 (null (ediff-overlay-get ovr 'ediff)) | |
1346 (null (ediff-overlay-get ovr 'ediff-diff-num))) | |
1347 ;; use the overlay priority or 0 | |
1348 (or (ediff-overlay-get ovr 'priority) 0) | |
1349 0)) | |
1350 ovr-list)))))))) | |
1351 | |
1352 | |
1353 (defvar ediff-toggle-read-only-function nil | |
1354 "*Specifies the function to be used to toggle read-only. | |
1355 If nil, Ediff tries to deduce the function from the binding of C-x C-q. | |
1356 Normally, this is the `toggle-read-only' function, but, if version | |
1357 control is used, it could be `vc-toggle-read-only' or `rcs-toggle-read-only'.") | |
1358 | |
1359 (defcustom ediff-make-buffers-readonly-at-startup nil | |
1360 "Make all variant buffers read-only when Ediff starts up. | |
1361 This property can be toggled interactively." | |
1362 :type 'boolean | |
1363 :group 'ediff) | |
1364 | |
1365 | |
1366 ;;; Misc | |
1367 | |
1368 ;; if nil, this silences some messages | |
1369 (defvar ediff-verbose-p t) | |
1370 | |
1371 (defcustom ediff-autostore-merges 'group-jobs-only | |
1372 "Save the results of merge jobs automatically. | |
1373 With value nil, don't save automatically. With value t, always | |
1374 save. Anything else means save automatically only if the merge | |
1375 job is part of a group of jobs, such as `ediff-merge-directory' | |
1376 or `ediff-merge-directory-revisions'." | |
1377 :type '(choice (const nil) (const t) (const group-jobs-only)) | |
1378 :group 'ediff-merge) | |
1379 (make-variable-buffer-local 'ediff-autostore-merges) | |
1380 | |
1381 ;; file where the result of the merge is to be saved. used internally | |
1382 (ediff-defvar-local ediff-merge-store-file nil "") | |
1383 | |
1384 (defcustom ediff-merge-filename-prefix "merge_" | |
1385 "Prefix to be attached to saved merge buffers." | |
1386 :type 'string | |
1387 :group 'ediff-merge) | |
1388 | |
1389 (defcustom ediff-no-emacs-help-in-control-buffer nil | |
1390 "Non-nil means C-h should not invoke Emacs help in control buffer. | |
1391 Instead, C-h would jump to previous difference." | |
1392 :type 'boolean | |
1393 :group 'ediff) | |
1394 | |
1395 ;; This is the same as temporary-file-directory from Emacs 20.3. | |
1396 ;; Copied over here because XEmacs doesn't have this variable. | |
1397 (defcustom ediff-temp-file-prefix | |
1398 (file-name-as-directory | |
1399 (cond ((boundp 'temporary-file-directory) temporary-file-directory) | |
1400 ((fboundp 'temp-directory) (temp-directory)) | |
1401 (t "/tmp/"))) | |
1402 ;;; (file-name-as-directory | |
1403 ;;; (cond ((memq system-type '(ms-dos windows-nt)) | |
1404 ;;; (or (getenv "TEMP") (getenv "TMPDIR") (getenv "TMP") "c:/temp")) | |
1405 ;;; (t | |
1406 ;;; (or (getenv "TMPDIR") (getenv "TMP") (getenv "TEMP") "/tmp")))) | |
1407 "Prefix to put on Ediff temporary file names. | |
1408 Do not start with `~/' or `~USERNAME/'." | |
1409 :type 'string | |
1410 :group 'ediff) | |
1411 | |
1412 (defcustom ediff-temp-file-mode 384 ; u=rw only | |
1413 "Mode for Ediff temporary files." | |
1414 :type 'integer | |
1415 :group 'ediff) | |
1416 | |
1417 ;; Metacharacters that have to be protected from the shell when executing | |
1418 ;; a diff/diff3 command. | |
1419 (defcustom ediff-metachars "[ \t\n!\"#$&'()*;<=>?[\\^`{|~]" | |
1420 "Regexp that matches characters that must be quoted with `\\' in shell command line. | |
1421 This default should work without changes." | |
1422 :type 'string | |
1423 :group 'ediff) | |
1424 | |
1425 ;; needed to simulate frame-char-width in XEmacs. | |
1426 (defvar ediff-H-glyph (if (featurep 'xemacs) (make-glyph "H"))) | |
1427 | |
1428 | |
1429 ;; Temporary file used for refining difference regions in buffer A. | |
1430 (ediff-defvar-local ediff-temp-file-A nil "") | |
1431 ;; Temporary file used for refining difference regions in buffer B. | |
1432 (ediff-defvar-local ediff-temp-file-B nil "") | |
1433 ;; Temporary file used for refining difference regions in buffer C. | |
1434 (ediff-defvar-local ediff-temp-file-C nil "") | |
1435 | |
1436 | |
1437 (defun ediff-file-remote-p (file-name) | |
1438 (file-remote-p file-name)) | |
1439 | |
1440 ;; File for which we can get attributes, such as size or date | |
1441 (defun ediff-listable-file (file-name) | |
1442 (let ((handler (find-file-name-handler file-name 'file-local-copy))) | |
1443 (or (null handler) (eq handler 'dired-handler-fn)))) | |
1444 | |
1445 | |
1446 (defsubst ediff-frame-unsplittable-p (frame) | |
1447 (cdr (assq 'unsplittable (frame-parameters frame)))) | |
1448 | |
1449 (defsubst ediff-get-next-window (wind prev-wind) | |
1450 (cond ((window-live-p wind) wind) | |
1451 (prev-wind (next-window wind)) | |
1452 (t (selected-window)) | |
1453 )) | |
1454 | |
1455 | |
1456 (defsubst ediff-kill-buffer-carefully (buf) | |
1457 "Kill buffer BUF if it exists." | |
1458 (if (ediff-buffer-live-p buf) | |
1459 (kill-buffer (get-buffer buf)))) | |
1460 | |
1461 (defsubst ediff-background-face (buf-type dif-num) | |
1462 ;; The value of dif-num is always 1- the one that user sees. | |
1463 ;; This is why even face is used when dif-num is odd. | |
1464 (ediff-get-symbol-from-alist | |
1465 buf-type (if (ediff-odd-p dif-num) | |
1466 ediff-even-diff-face-alist | |
1467 ediff-odd-diff-face-alist) | |
1468 )) | |
1469 | |
1470 | |
1471 ;; activate faces on diff regions in buffer | |
1472 (defun ediff-paint-background-regions-in-one-buffer (buf-type unhighlight) | |
1473 (let ((diff-vector | |
1474 (eval (ediff-get-symbol-from-alist | |
1475 buf-type ediff-difference-vector-alist))) | |
1476 overl diff-num) | |
1477 (mapcar (lambda (rec) | |
1478 (setq overl (ediff-get-diff-overlay-from-diff-record rec) | |
1479 diff-num (ediff-overlay-get overl 'ediff-diff-num)) | |
1480 (if (ediff-overlay-buffer overl) | |
1481 ;; only if overlay is alive | |
1482 (ediff-set-overlay-face | |
1483 overl | |
1484 (if (not unhighlight) | |
1485 (ediff-background-face buf-type diff-num)))) | |
1486 ) | |
1487 diff-vector))) | |
1488 | |
1489 | |
1490 ;; activate faces on diff regions in all buffers | |
1491 (defun ediff-paint-background-regions (&optional unhighlight) | |
1492 (ediff-paint-background-regions-in-one-buffer | |
1493 'A unhighlight) | |
1494 (ediff-paint-background-regions-in-one-buffer | |
1495 'B unhighlight) | |
1496 (ediff-paint-background-regions-in-one-buffer | |
1497 'C unhighlight) | |
1498 (ediff-paint-background-regions-in-one-buffer | |
1499 'Ancestor unhighlight)) | |
1500 | |
1501 | |
1502 ;; arg is a record for a given diff in a difference vector | |
1503 ;; this record is itself a vector | |
1504 (defsubst ediff-clear-fine-diff-vector (diff-record) | |
1505 (if diff-record | |
1506 (mapc 'ediff-delete-overlay | |
1507 (ediff-get-fine-diff-vector-from-diff-record diff-record)))) | |
1508 | |
1509 (defsubst ediff-clear-fine-differences-in-one-buffer (n buf-type) | |
1510 (ediff-clear-fine-diff-vector (ediff-get-difference n buf-type)) | |
1511 (ediff-set-fine-diff-vector n buf-type nil)) | |
1512 | |
1513 (defsubst ediff-clear-fine-differences (n) | |
1514 (ediff-clear-fine-differences-in-one-buffer n 'A) | |
1515 (ediff-clear-fine-differences-in-one-buffer n 'B) | |
1516 (if ediff-3way-job | |
1517 (ediff-clear-fine-differences-in-one-buffer n 'C))) | |
1518 | |
1519 | |
1520 (defsubst ediff-mouse-event-p (event) | |
1521 (if (featurep 'xemacs) | |
1522 (button-event-p event) | |
1523 (string-match "mouse" (format "%S" (event-basic-type event))))) | |
1524 | |
1525 | |
1526 (defsubst ediff-key-press-event-p (event) | |
1527 (if (featurep 'xemacs) | |
1528 (key-press-event-p event) | |
1529 (or (char-or-string-p event) (symbolp event)))) | |
1530 | |
1531 (defun ediff-event-point (event) | |
1532 (cond ((ediff-mouse-event-p event) | |
1533 (if (featurep 'xemacs) | |
1534 (event-point event) | |
1535 (posn-point (event-start event)))) | |
1536 ((ediff-key-press-event-p event) | |
1537 (point)) | |
1538 (t (error "Error")))) | |
1539 | |
1540 (defun ediff-event-buffer (event) | |
1541 (cond ((ediff-mouse-event-p event) | |
1542 (if (featurep 'xemacs) | |
1543 (event-buffer event) | |
1544 (window-buffer (posn-window (event-start event))))) | |
1545 ((ediff-key-press-event-p event) | |
1546 (current-buffer)) | |
1547 (t (error "Error")))) | |
1548 | |
1549 (defun ediff-event-key (event-or-key) | |
1550 (if (featurep 'xemacs) | |
1551 ;;(if (eventp event-or-key) (event-key event-or-key) event-or-key) | |
1552 (if (eventp event-or-key) (event-to-character event-or-key t t) event-or-key) | |
1553 event-or-key)) | |
1554 | |
1555 (defun ediff-last-command-char () | |
1556 (ediff-event-key last-command-event)) | |
1557 | |
1558 | |
1559 (defsubst ediff-frame-iconified-p (frame) | |
1560 (and (ediff-window-display-p) (frame-live-p frame) | |
1561 (if (featurep 'xemacs) | |
1562 (frame-iconified-p frame) | |
1563 (eq (frame-visible-p frame) 'icon)))) | |
1564 | |
1565 (defsubst ediff-window-visible-p (wind) | |
1566 ;; under TTY, window-live-p also means window is visible | |
1567 (and (window-live-p wind) | |
1568 (or (not (ediff-window-display-p)) | |
1569 (frame-visible-p (window-frame wind))))) | |
1570 | |
1571 | |
1572 (defsubst ediff-frame-char-width (frame) | |
1573 (if (featurep 'xemacs) | |
1574 (/ (frame-pixel-width frame) (frame-width frame)) | |
1575 (frame-char-width frame))) | |
1576 | |
1577 (defun ediff-reset-mouse (&optional frame do-not-grab-mouse) | |
1578 (or frame (setq frame (selected-frame))) | |
1579 (if (ediff-window-display-p) | |
1580 (let ((frame-or-wind frame)) | |
1581 (if (featurep 'xemacs) | |
1582 (setq frame-or-wind (frame-selected-window frame))) | |
1583 (or do-not-grab-mouse | |
1584 ;; don't set mouse if the user said to never do this | |
1585 (not ediff-grab-mouse) | |
1586 ;; Don't grab on quit, if the user doesn't want to. | |
1587 ;; If ediff-grab-mouse = t, then mouse won't be grabbed for | |
1588 ;; sessions that are not part of a group (this is done in | |
1589 ;; ediff-recenter). The condition below affects only terminating | |
1590 ;; sessions in session groups (in which case mouse is warped into | |
1591 ;; a meta buffer). | |
1592 (and (eq ediff-grab-mouse 'maybe) | |
1593 (memq this-command '(ediff-quit ediff-update-diffs))) | |
1594 (set-mouse-position frame-or-wind 1 0)) | |
1595 ))) | |
1596 | |
1597 (defsubst ediff-spy-after-mouse () | |
1598 (setq ediff-mouse-pixel-position (mouse-pixel-position))) | |
1599 | |
1600 ;; It is not easy to find out when the user grabs the mouse, since emacs and | |
1601 ;; xemacs behave differently when mouse is not in any frame. Also, this is | |
1602 ;; sensitive to when the user grabbed mouse. Not used for now. | |
1603 (defun ediff-user-grabbed-mouse () | |
1604 (if ediff-mouse-pixel-position | |
1605 (cond ((not (eq (car ediff-mouse-pixel-position) | |
1606 (car (mouse-pixel-position))))) | |
1607 ((and (car (cdr ediff-mouse-pixel-position)) | |
1608 (car (cdr (mouse-pixel-position))) | |
1609 (cdr (cdr ediff-mouse-pixel-position)) | |
1610 (cdr (cdr (mouse-pixel-position)))) | |
1611 (not (and (< (abs (- (car (cdr ediff-mouse-pixel-position)) | |
1612 (car (cdr (mouse-pixel-position))))) | |
1613 ediff-mouse-pixel-threshold) | |
1614 (< (abs (- (cdr (cdr ediff-mouse-pixel-position)) | |
1615 (cdr (cdr (mouse-pixel-position))))) | |
1616 ediff-mouse-pixel-threshold)))) | |
1617 (t nil)))) | |
1618 | |
1619 (defsubst ediff-frame-char-height (frame) | |
1620 (if (featurep 'xemacs) | |
1621 (glyph-height ediff-H-glyph (frame-selected-window frame)) | |
1622 (frame-char-height frame))) | |
1623 | |
1624 ;; Some overlay functions | |
1625 | |
1626 (defsubst ediff-overlay-start (overl) | |
1627 (if (ediff-overlayp overl) | |
1628 (if (featurep 'xemacs) | |
1629 (extent-start-position overl) | |
1630 (overlay-start overl)))) | |
1631 | |
1632 (defsubst ediff-overlay-end (overl) | |
1633 (if (ediff-overlayp overl) | |
1634 (if (featurep 'xemacs) | |
1635 (extent-end-position overl) | |
1636 (overlay-end overl)))) | |
1637 | |
1638 (defsubst ediff-empty-overlay-p (overl) | |
1639 (= (ediff-overlay-start overl) (ediff-overlay-end overl))) | |
1640 | |
1641 ;; like overlay-buffer in Emacs. In XEmacs, returns nil if the extent is | |
1642 ;; dead. Otherwise, works like extent-buffer | |
1643 (defun ediff-overlay-buffer (overl) | |
1644 (if (featurep 'xemacs) | |
1645 (and (extent-live-p overl) (extent-object overl)) | |
1646 (overlay-buffer overl))) | |
1647 | |
1648 ;; like overlay-get in Emacs. In XEmacs, returns nil if the extent is | |
1649 ;; dead. Otherwise, like extent-property | |
1650 (defun ediff-overlay-get (overl property) | |
1651 (if (featurep 'xemacs) | |
1652 (and (extent-live-p overl) (extent-property overl property)) | |
1653 (overlay-get overl property))) | |
1654 | |
1655 | |
1656 ;; These two functions are here because XEmacs refuses to | |
1657 ;; handle overlays whose buffers were deleted. | |
1658 (defun ediff-move-overlay (overlay beg end &optional buffer) | |
1659 "Calls `move-overlay' in Emacs and `set-extent-endpoints' in Lemacs. | |
1660 Checks if overlay's buffer exists before actually doing the move." | |
1661 (let ((buf (and overlay (ediff-overlay-buffer overlay)))) | |
1662 (if (ediff-buffer-live-p buf) | |
1663 (if (featurep 'xemacs) | |
1664 (set-extent-endpoints overlay beg end) | |
1665 (move-overlay overlay beg end buffer)) | |
1666 ;; buffer's dead | |
1667 (if overlay | |
1668 (ediff-delete-overlay overlay))))) | |
1669 | |
1670 (defun ediff-overlay-put (overlay prop value) | |
1671 "Calls `overlay-put' or `set-extent-property' depending on Emacs version. | |
1672 Checks if overlay's buffer exists." | |
1673 (if (ediff-buffer-live-p (ediff-overlay-buffer overlay)) | |
1674 (if (featurep 'xemacs) | |
1675 (set-extent-property overlay prop value) | |
1676 (overlay-put overlay prop value)) | |
1677 (ediff-delete-overlay overlay))) | |
1678 | |
1679 ;; temporarily uses DIR to abbreviate file name | |
1680 ;; if DIR is nil, use default-directory | |
1681 (defun ediff-abbreviate-file-name (file &optional dir) | |
1682 (cond ((stringp dir) | |
1683 (let ((directory-abbrev-alist (list (cons dir "")))) | |
1684 (abbreviate-file-name file))) | |
1685 (t | |
1686 (if (featurep 'xemacs) | |
1687 ;; XEmacs requires addl argument | |
1688 (abbreviate-file-name file t) | |
1689 (abbreviate-file-name file))))) | |
1690 | |
1691 ;; Takes a directory and returns the parent directory. | |
1692 ;; does nothing to `/'. If the ARG is a regular file, | |
1693 ;; strip the file AND the last dir. | |
1694 (defun ediff-strip-last-dir (dir) | |
1695 (if (not (stringp dir)) (setq dir default-directory)) | |
1696 (setq dir (expand-file-name dir)) | |
1697 (or (file-directory-p dir) (setq dir (file-name-directory dir))) | |
1698 (let* ((pos (1- (length dir))) | |
1699 (last-char (aref dir pos))) | |
1700 (if (and (> pos 0) (= last-char ?/)) | |
1701 (setq dir (substring dir 0 pos))) | |
1702 (ediff-abbreviate-file-name (file-name-directory dir)))) | |
1703 | |
1704 (defun ediff-truncate-string-left (str newlen) | |
1705 ;; leave space for ... on the left | |
1706 (let ((len (length str)) | |
1707 substr) | |
1708 (if (<= len newlen) | |
1709 str | |
1710 (setq newlen (max 0 (- newlen 3))) | |
1711 (setq substr (substring str (max 0 (- len 1 newlen)))) | |
1712 (concat "..." substr)))) | |
1713 | |
1714 (defsubst ediff-nonempty-string-p (string) | |
1715 (and (stringp string) (not (string= string "")))) | |
1716 | |
1717 (unless (fboundp 'subst-char-in-string) | |
1718 (defun subst-char-in-string (fromchar tochar string &optional inplace) | |
1719 "Replace FROMCHAR with TOCHAR in STRING each time it occurs. | |
1720 Unless optional argument INPLACE is non-nil, return a new string." | |
1721 (let ((i (length string)) | |
1722 (newstr (if inplace string (copy-sequence string)))) | |
1723 (while (> i 0) | |
1724 (setq i (1- i)) | |
1725 (if (eq (aref newstr i) fromchar) | |
1726 (aset newstr i tochar))) | |
1727 newstr))) | |
1728 | |
1729 (defun ediff-abbrev-jobname (jobname) | |
1730 (cond ((eq jobname 'ediff-directories) | |
1731 "Compare two directories") | |
1732 ((eq jobname 'ediff-files) | |
1733 "Compare two files") | |
1734 ((eq jobname 'ediff-buffers) | |
1735 "Compare two buffers") | |
1736 ((eq jobname 'ediff-directories3) | |
1737 "Compare three directories") | |
1738 ((eq jobname 'ediff-files3) | |
1739 "Compare three files") | |
1740 ((eq jobname 'ediff-buffers3) | |
1741 "Compare three buffers") | |
1742 ((eq jobname 'ediff-revision) | |
1743 "Compare file with a version") | |
1744 ((eq jobname 'ediff-directory-revisions) | |
1745 "Compare dir files with versions") | |
1746 ((eq jobname 'ediff-merge-directory-revisions) | |
1747 "Merge dir files with versions") | |
1748 ((eq jobname 'ediff-merge-directory-revisions-with-ancestor) | |
1749 "Merge dir versions via ancestors") | |
1750 (t | |
1751 (capitalize | |
1752 (subst-char-in-string ?- ?\s (substring (symbol-name jobname) 6)))) | |
1753 )) | |
1754 | |
1755 | |
1756 ;; If ediff modified mode line, strip the modification | |
1757 (defsubst ediff-strip-mode-line-format () | |
1758 (if (member (car mode-line-format) '(" A: " " B: " " C: " " Ancestor: ")) | |
1759 (setq mode-line-format (nth 2 mode-line-format)))) | |
1760 | |
1761 ;; Verify that we have a difference selected. | |
1762 (defsubst ediff-valid-difference-p (&optional n) | |
1763 (or n (setq n ediff-current-difference)) | |
1764 (and (>= n 0) (< n ediff-number-of-differences))) | |
1765 | |
1766 (defsubst ediff-show-all-diffs (n) | |
1767 "Don't skip difference regions." | |
1768 nil) | |
1769 | |
1770 (defsubst ediff-message-if-verbose (string &rest args) | |
1771 (if ediff-verbose-p | |
1772 (apply 'message string args))) | |
1773 | |
1774 (defun ediff-file-attributes (filename attr-number) | |
1775 (if (ediff-listable-file filename) | |
1776 (nth attr-number (file-attributes filename)) | |
1777 -1) | |
1778 ) | |
1779 | |
1780 (defsubst ediff-file-size (filename) | |
1781 (ediff-file-attributes filename 7)) | |
1782 (defsubst ediff-file-modtime (filename) | |
1783 (ediff-file-attributes filename 5)) | |
1784 | |
1785 | |
1786 (defun ediff-convert-standard-filename (fname) | |
1787 (if (fboundp 'convert-standard-filename) | |
1788 (convert-standard-filename fname) | |
1789 fname)) | |
1790 | |
1791 (if (featurep 'emacs) | |
1792 (defalias 'ediff-with-syntax-table 'with-syntax-table) | |
1793 (if (fboundp 'with-syntax-table) | |
1794 (defalias 'ediff-with-syntax-table 'with-syntax-table) | |
1795 ;; stolen from subr.el in emacs 21 | |
1796 (defmacro ediff-with-syntax-table (table &rest body) | |
1797 (let ((old-table (make-symbol "table")) | |
1798 (old-buffer (make-symbol "buffer"))) | |
1799 `(let ((,old-table (syntax-table)) | |
1800 (,old-buffer (current-buffer))) | |
1801 (unwind-protect | |
1802 (progn | |
1803 (set-syntax-table (copy-syntax-table ,table)) | |
1804 ,@body) | |
1805 (save-current-buffer | |
1806 (set-buffer ,old-buffer) | |
1807 (set-syntax-table ,old-table)))))))) | |
1808 | |
1809 | |
1810 (provide 'ediff-init) | |
1811 | |
1812 | |
1813 | |
1814 ;; Local Variables: | |
1815 ;; eval: (put 'ediff-defvar-local 'lisp-indent-hook 'defun) | |
1816 ;; eval: (put 'ediff-with-current-buffer 'lisp-indent-hook 1) | |
1817 ;; eval: (put 'ediff-with-current-buffer 'edebug-form-spec '(form body)) | |
1818 ;; End: | |
1819 | |
1820 ;; arch-tag: fa31d384-1e70-4d4b-82a7-3e96307c46f5 | |
1821 ;;; ediff-init.el ends here |