|
0
|
1 ;;; ediff-init.el --- Macros, variables, and defsubsts used by Ediff
|
|
|
2
|
|
|
3 ;; Copyright (C) 1994, 1995, 1996 Free Software Foundation, Inc.
|
|
|
4
|
|
|
5 ;; Author: Michael Kifer <kifer@cs.sunysb.edu>
|
|
|
6
|
|
|
7 ;; This file is part of GNU Emacs.
|
|
|
8
|
|
|
9 ;; GNU Emacs is free software; you can redistribute it and/or modify
|
|
|
10 ;; it under the terms of the GNU General Public License as published by
|
|
|
11 ;; the Free Software Foundation; either version 2, or (at your option)
|
|
|
12 ;; any later version.
|
|
|
13
|
|
|
14 ;; GNU Emacs is distributed in the hope that it will be useful,
|
|
|
15 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
16 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
17 ;; GNU General Public License for more details.
|
|
|
18
|
|
|
19 ;; You should have received a copy of the GNU General Public License
|
|
|
20 ;; along with GNU Emacs; see the file COPYING. If not, write to the
|
|
|
21 ;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
|
|
22 ;; Boston, MA 02111-1307, USA.
|
|
|
23
|
|
|
24 ;;; Code:
|
|
|
25
|
|
|
26 ;; Start compiler pacifier
|
|
|
27 (defvar ediff-metajob-name)
|
|
|
28 (defvar ediff-meta-buffer)
|
|
|
29 (defvar pm-color-alist)
|
|
|
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 ;; end pacifier
|
|
|
36
|
|
|
37 ;; Is it XEmacs?
|
|
|
38 (defconst ediff-xemacs-p (string-match "XEmacs" emacs-version))
|
|
|
39 ;; Is it Emacs?
|
|
|
40 (defconst ediff-emacs-p (not ediff-xemacs-p))
|
|
|
41
|
|
|
42 (defvar ediff-force-faces nil
|
|
|
43 "If t, Ediff will think that it is running on a display that supports faces.
|
|
|
44 This is provided as a temporary relief for users of face-capable displays
|
|
|
45 that Ediff doesn't know about.")
|
|
|
46
|
|
|
47 ;; Are we running as a window application or on a TTY?
|
|
|
48 (defsubst ediff-device-type ()
|
|
|
49 (if ediff-emacs-p
|
|
|
50 window-system
|
|
|
51 (device-type (selected-device))))
|
|
|
52
|
|
|
53 ;; in XEmacs: device-type is tty on tty and stream in batch.
|
|
|
54 (defun ediff-window-display-p ()
|
|
|
55 (and (ediff-device-type) (not (memq (ediff-device-type) '(tty pc stream)))))
|
|
|
56
|
|
|
57 ;; test if supports faces
|
|
|
58 ;; ediff-force-faces is for those devices that support faces, but we don't know
|
|
|
59 ;; this yet
|
|
|
60 (defun ediff-has-face-support-p ()
|
|
|
61 (cond ((ediff-window-display-p))
|
|
|
62 (ediff-force-faces)
|
|
|
63 (ediff-emacs-p (memq (ediff-device-type) '(pc)))
|
|
|
64 (ediff-xemacs-p (memq (ediff-device-type) '(tty pc)))))
|
|
|
65
|
|
|
66
|
|
|
67 ;; Defines SYMBOL as an advertised local variable.
|
|
|
68 ;; Performs a defvar, then executes `make-variable-buffer-local' on
|
|
|
69 ;; the variable. Also sets the `permanent-local' property,
|
|
|
70 ;; so that `kill-all-local-variables' (called by major-mode setting
|
|
|
71 ;; commands) won't destroy Ediff control variables.
|
|
|
72 ;;
|
|
|
73 ;; Plagiarised from `emerge-defvar-local' for XEmacs.
|
|
|
74 (defmacro ediff-defvar-local (var value doc)
|
|
|
75 (` (progn
|
|
|
76 (defvar (, var) (, value) (, doc))
|
|
|
77 (make-variable-buffer-local '(, var))
|
|
|
78 (put '(, var) 'permanent-local t))))
|
|
|
79
|
|
|
80
|
|
|
81
|
|
|
82 ;; Variables that control each Ediff session---local to the control buffer.
|
|
|
83
|
|
|
84 ;; Mode variables
|
|
|
85 ;; The buffer in which the A variant is stored.
|
|
|
86 (ediff-defvar-local ediff-buffer-A nil "")
|
|
|
87 ;; The buffer in which the B variant is stored.
|
|
|
88 (ediff-defvar-local ediff-buffer-B nil "")
|
|
|
89 ;; The buffer in which the C variant is stored.
|
|
|
90 (ediff-defvar-local ediff-buffer-C nil "")
|
|
|
91 ;; Ancestor buffer
|
|
|
92 (ediff-defvar-local ediff-ancestor-buffer nil "")
|
|
|
93 ;; The control buffer of ediff.
|
|
|
94 (ediff-defvar-local ediff-control-buffer nil "")
|
|
|
95
|
|
|
96 ;;; Macros
|
|
|
97 (defmacro ediff-odd-p (arg)
|
|
|
98 (` (eq (logand (, arg) 1) 1)))
|
|
|
99
|
|
|
100 (defmacro ediff-buffer-live-p (buf)
|
|
|
101 (` (and (, buf) (get-buffer (, buf)) (buffer-name (get-buffer (, buf))))))
|
|
|
102
|
|
|
103 (defmacro ediff-get-buffer (arg)
|
|
|
104 (` (cond ((eq (, arg) 'A) ediff-buffer-A)
|
|
|
105 ((eq (, arg) 'B) ediff-buffer-B)
|
|
|
106 ((eq (, arg) 'C) ediff-buffer-C)
|
|
|
107 ((eq (, arg) 'Ancestor) ediff-ancestor-buffer)
|
|
|
108 )
|
|
|
109 ))
|
|
|
110
|
|
|
111 (defmacro ediff-get-value-according-to-buffer-type (buf-type list)
|
|
|
112 (` (cond ((eq (, buf-type) 'A) (nth 0 (, list)))
|
|
|
113 ((eq (, buf-type) 'B) (nth 1 (, list)))
|
|
|
114 ((eq (, buf-type) 'C) (nth 2 (, list))))))
|
|
|
115
|
|
|
116 (defmacro ediff-char-to-buftype (arg)
|
|
|
117 (` (cond ((memq (, arg) '(?a ?A)) 'A)
|
|
|
118 ((memq (, arg) '(?b ?B)) 'B)
|
|
|
119 ((memq (, arg) '(?c ?C)) 'C)
|
|
|
120 )
|
|
|
121 ))
|
|
|
122
|
|
|
123 (defmacro ediff-get-difference (n buf-type)
|
|
|
124 (` (aref
|
|
|
125 (symbol-value
|
|
|
126 (intern (format "ediff-difference-vector-%S" (, buf-type)))) (, n))))
|
|
|
127
|
|
|
128 ;; tell if it has been previously determined that the region has
|
|
|
129 ;; no diffs other than the white space and newlines
|
|
|
130 ;; The argument, N, is the diff region number used by Ediff to index the
|
|
|
131 ;; diff vector. It is 1 less than the number seen by the user.
|
|
|
132 ;;
|
|
|
133 ;; A difference vector has the form:
|
|
|
134 ;; [diff diff diff ...]
|
|
|
135 ;; where each diff has the form:
|
|
|
136 ;; [overlay fine-diff-vector no-fine-diffs-flag]
|
|
|
137 ;; fine-diff-vector is a vector [fine-diff fine-diff fine-diff ...]
|
|
|
138 (defmacro ediff-no-fine-diffs-p (n)
|
|
|
139 (` (aref (ediff-get-difference (, n) 'A) 2)))
|
|
|
140
|
|
|
141 (defmacro ediff-get-diff-overlay-from-diff-record (diff-rec)
|
|
|
142 (` (aref (, diff-rec) 0)))
|
|
|
143
|
|
|
144 (defmacro ediff-get-diff-overlay (n buf-type)
|
|
|
145 (` (ediff-get-diff-overlay-from-diff-record
|
|
|
146 (ediff-get-difference (, n) (, buf-type)))))
|
|
|
147
|
|
|
148 (defmacro ediff-get-fine-diff-vector-from-diff-record (diff-rec)
|
|
|
149 (` (aref (, diff-rec) 1)))
|
|
|
150
|
|
|
151 (defmacro ediff-set-fine-diff-vector (n buf-type fine-vec)
|
|
|
152 (` (aset (ediff-get-difference (, n) (, buf-type)) 1 (, fine-vec))))
|
|
|
153
|
|
|
154 (defmacro ediff-get-state-of-diff (n buf-type)
|
|
|
155 (` (if (ediff-buffer-live-p ediff-buffer-C)
|
|
|
156 (aref (ediff-get-difference (, n) (, buf-type)) 3))))
|
|
|
157 (defmacro ediff-set-state-of-diff (n buf-type val)
|
|
|
158 (` (aset (ediff-get-difference (, n) (, buf-type)) 3 (, val))))
|
|
|
159 (defmacro ediff-get-state-of-merge (n)
|
|
|
160 (` (if ediff-state-of-merge
|
|
|
161 (aref (aref ediff-state-of-merge (, n)) 0))))
|
|
|
162 (defmacro ediff-get-state-of-ancestor (n)
|
|
|
163 (` (if ediff-state-of-merge
|
|
|
164 (aref (aref ediff-state-of-merge (, n)) 1))))
|
|
|
165 (defmacro ediff-set-state-of-merge (n val)
|
|
|
166 (` (if ediff-state-of-merge
|
|
|
167 (aset (aref ediff-state-of-merge (, n)) 0 (, val)))))
|
|
|
168
|
|
|
169 ;; if flag is t, puts a mark on diff region saying that
|
|
|
170 ;; the differences are in white space only. If flag is nil,
|
|
|
171 ;; the region is marked as essential (i.e., differences are
|
|
|
172 ;; not just in the white space and newlines.)
|
|
|
173 (defmacro ediff-mark-diff-as-space-only (n flag)
|
|
|
174 (` (aset (ediff-get-difference (, n) 'A) 2 (, flag))))
|
|
|
175
|
|
|
176 (defmacro ediff-get-fine-diff-vector (n buf-type)
|
|
|
177 (` (ediff-get-fine-diff-vector-from-diff-record
|
|
|
178 (ediff-get-difference (, n) (, buf-type)))))
|
|
|
179
|
|
|
180 ;; Macro to switch to BUFFER, evaluate FORMS, returns to original buffer.
|
|
|
181 ;; Differs from `save-excursion' in that it doesn't save the point and mark.
|
|
|
182 ;; This is essentially `emerge-eval-in-buffer' with the test for live buffers."
|
|
|
183 (defmacro ediff-eval-in-buffer (buffer &rest forms)
|
|
|
184 (` (let ((StartBuffer (current-buffer)))
|
|
|
185 (if (ediff-buffer-live-p (, buffer))
|
|
|
186 (unwind-protect
|
|
|
187 (progn
|
|
|
188 (set-buffer (, buffer))
|
|
|
189 (,@ forms))
|
|
|
190 (set-buffer StartBuffer))
|
|
|
191 (or (eq this-command 'ediff-quit)
|
|
|
192 (error ediff-KILLED-VITAL-BUFFER))
|
|
|
193 ))))
|
|
|
194
|
|
|
195
|
|
|
196 (defsubst ediff-multiframe-setup-p ()
|
|
|
197 (and (ediff-window-display-p) ediff-multiframe))
|
|
|
198
|
|
|
199 (defmacro ediff-narrow-control-frame-p ()
|
|
|
200 (` (and (ediff-multiframe-setup-p)
|
|
|
201 (equal ediff-help-message ediff-brief-message-string))))
|
|
|
202
|
|
|
203 (defmacro ediff-3way-comparison-job ()
|
|
|
204 (` (memq
|
|
|
205 ediff-job-name
|
|
|
206 '(ediff-files3 ediff-buffers3))))
|
|
|
207 (ediff-defvar-local ediff-3way-comparison-job nil "")
|
|
|
208
|
|
|
209 (defmacro ediff-merge-job ()
|
|
|
210 (` (memq
|
|
|
211 ediff-job-name
|
|
|
212 '(ediff-merge-files
|
|
|
213 ediff-merge-buffers
|
|
|
214 ediff-merge-files-with-ancestor
|
|
|
215 ediff-merge-buffers-with-ancestor
|
|
|
216 ediff-merge-revisions
|
|
|
217 ediff-merge-revisions-with-ancestor))))
|
|
|
218 (ediff-defvar-local ediff-merge-job nil "")
|
|
|
219
|
|
|
220 (defmacro ediff-merge-with-ancestor-job ()
|
|
|
221 (` (memq
|
|
|
222 ediff-job-name
|
|
|
223 '(ediff-merge-files-with-ancestor
|
|
|
224 ediff-merge-buffers-with-ancestor
|
|
|
225 ediff-merge-revisions-with-ancestor))))
|
|
|
226 (ediff-defvar-local ediff-merge-with-ancestor-job nil "")
|
|
|
227
|
|
|
228 (defmacro ediff-3way-job ()
|
|
|
229 (` (or ediff-3way-comparison-job ediff-merge-job)))
|
|
|
230 (ediff-defvar-local ediff-3way-job nil "")
|
|
|
231
|
|
|
232 ;; A diff3 job is like a 3way job, but ediff-merge doesn't require the use
|
|
|
233 ;; of diff3.
|
|
|
234 (defmacro ediff-diff3-job ()
|
|
|
235 (` (or ediff-3way-comparison-job
|
|
|
236 ediff-merge-with-ancestor-job)))
|
|
|
237 (ediff-defvar-local ediff-diff3-job nil "")
|
|
|
238
|
|
|
239 (defmacro ediff-windows-job ()
|
|
|
240 (` (memq ediff-job-name '(ediff-windows-wordwise ediff-windows-linewise))))
|
|
|
241 (ediff-defvar-local ediff-windows-job nil "")
|
|
|
242
|
|
|
243 (defmacro ediff-word-mode-job ()
|
|
|
244 (` (memq ediff-job-name '(ediff-windows-wordwise ediff-regions-wordwise))))
|
|
|
245 (ediff-defvar-local ediff-word-mode-job nil "")
|
|
|
246
|
|
|
247 (defmacro ediff-narrow-job ()
|
|
|
248 (` (memq ediff-job-name '(ediff-windows-wordwise
|
|
|
249 ediff-regions-wordwise
|
|
|
250 ediff-windows-linewise
|
|
|
251 ediff-regions-linewise))))
|
|
|
252 (ediff-defvar-local ediff-narrow-job nil "")
|
|
|
253
|
|
|
254 ;; Note: ediff-merge-directory-revisions-with-ancestor is not treated as an
|
|
|
255 ;; ancestor metajob, since it behaves differently.
|
|
|
256 (defsubst ediff-ancestor-metajob (&optional metajob)
|
|
|
257 (memq (or metajob ediff-metajob-name)
|
|
|
258 '(ediff-merge-directories-with-ancestor
|
|
|
259 ediff-merge-filegroups-with-ancestor)))
|
|
|
260 (defsubst ediff-revision-metajob (&optional metajob)
|
|
|
261 (memq (or metajob ediff-metajob-name)
|
|
|
262 '(ediff-directory-revisions
|
|
|
263 ediff-merge-directory-revisions
|
|
|
264 ediff-merge-directory-revisions-with-ancestor)))
|
|
|
265 (defsubst ediff-patch-metajob (&optional metajob)
|
|
|
266 (memq (or metajob ediff-metajob-name)
|
|
|
267 '(ediff-multifile-patch)))
|
|
|
268 ;; metajob involving only one group of files, such as multipatch or directory
|
|
|
269 ;; revision
|
|
|
270 (defsubst ediff-one-filegroup-metajob (&optional metajob)
|
|
|
271 (or (ediff-revision-metajob metajob)
|
|
|
272 (ediff-patch-metajob metajob)
|
|
|
273 ;; add more here
|
|
|
274 ))
|
|
|
275 (defsubst ediff-collect-diffs-metajob (&optional metajob)
|
|
|
276 (memq (or metajob ediff-metajob-name)
|
|
|
277 '(ediff-directories
|
|
|
278 ediff-directory-revisions
|
|
|
279 ediff-merge-directories
|
|
|
280 ediff-merge-directories-with-ancestor
|
|
|
281 ediff-merge-directory-revisions
|
|
|
282 ediff-merge-directory-revisions-with-ancestor
|
|
|
283 ;; add more here
|
|
|
284 )))
|
|
|
285
|
|
|
286 (defsubst ediff-metajob3 (&optional metajob)
|
|
|
287 (memq (or metajob ediff-metajob-name)
|
|
|
288 '(ediff-merge-directories-with-ancestor
|
|
|
289 ediff-merge-filegroups-with-ancestor
|
|
|
290 ediff-directories3
|
|
|
291 ediff-filegroups3)))
|
|
|
292 (defsubst ediff-comparison-metajob3 (&optional metajob)
|
|
|
293 (memq (or metajob ediff-metajob-name)
|
|
|
294 '(ediff-directories3 ediff-filegroups3)))
|
|
|
295
|
|
|
296 (defsubst ediff-barf-if-not-control-buffer (&optional meta-buf)
|
|
|
297 (or (eq (if meta-buf ediff-meta-buffer ediff-control-buffer)
|
|
|
298 (current-buffer))
|
|
|
299 (error "%S: This command runs in Ediff Control Buffer only!"
|
|
|
300 this-command)))
|
|
|
301
|
|
|
302
|
|
|
303 ;; Hook variables
|
|
|
304
|
|
|
305 (defvar ediff-before-setup-windows-hook nil
|
|
|
306 "*Hooks to run before Ediff sets its window configuration.
|
|
|
307 This can be used to save the previous window config, which can be restored
|
|
|
308 on ediff-quit or ediff-suspend.")
|
|
|
309 (defvar ediff-after-setup-windows-hook nil
|
|
|
310 "*Hooks to run after Ediff sets its window configuration.
|
|
|
311 This can be used to set up control window or icon in a desired place.")
|
|
|
312 (defvar ediff-before-setup-control-frame-hook nil
|
|
|
313 "*Hooks run before setting up the frame to display Ediff Control Panel.
|
|
|
314 Can be used to change control frame parameters to position it where it
|
|
|
315 is desirable.")
|
|
|
316 (defvar ediff-after-setup-control-frame-hook nil
|
|
|
317 "*Hooks run after setting up the frame to display Ediff Control Panel.
|
|
|
318 Can be used to move the frame where it is desired.")
|
|
|
319 (defvar ediff-startup-hook nil
|
|
|
320 "*Hooks to run in the control buffer after Ediff has been set up.")
|
|
|
321 (defvar ediff-select-hook nil
|
|
|
322 "*Hooks to run after a difference has been selected.")
|
|
|
323 (defvar ediff-unselect-hook nil
|
|
|
324 "*Hooks to run after a difference has been unselected.")
|
|
|
325 (defvar ediff-prepare-buffer-hook nil
|
|
|
326 "*Hooks called after buffers A, B, and C are set up.")
|
|
|
327 (defvar ediff-load-hook nil
|
|
|
328 "*Hook run after Ediff is loaded. Can be used to change defaults.")
|
|
|
329
|
|
|
330 (defvar ediff-mode-hook nil
|
|
|
331 "*Hook run just after ediff-mode is set up in the control buffer.
|
|
|
332 This is done before any windows or frames are created. One can use it to
|
|
|
333 set local variables that determine how the display looks like.")
|
|
|
334 (defvar ediff-keymap-setup-hook nil
|
|
|
335 "*Hook run just after the default bindings in Ediff keymap are set up.")
|
|
|
336
|
|
|
337 (defvar ediff-display-help-hook nil
|
|
|
338 "*Hooks run after preparing the help message.")
|
|
|
339
|
|
|
340 (defvar ediff-suspend-hook (list 'ediff-default-suspend-function)
|
|
|
341 "*Hooks to run in the Ediff control buffer when Ediff is suspended.")
|
|
|
342 (defvar ediff-quit-hook (list 'ediff-cleanup-mess)
|
|
|
343 "*Hooks to run in the Ediff control buffer after finishing Ediff.")
|
|
|
344 (defvar ediff-cleanup-hook nil
|
|
|
345 "*Hooks to run on exiting Ediff but before killing the control buffer.
|
|
|
346 This is a place to do various cleanups, such as deleting the variant buffers.
|
|
|
347 Ediff provides a function, `ediff-janitor', as one such possible hook.")
|
|
|
348
|
|
|
349
|
|
|
350 ;; Help messages
|
|
|
351
|
|
|
352 (defconst ediff-long-help-message-head
|
|
|
353 " Moving around | Toggling features | Manipulations
|
|
|
354 =====================|===========================|============================="
|
|
|
355 "The head of the full help message.")
|
|
|
356 (defconst ediff-long-help-message-tail
|
|
|
357 "=====================|===========================|=============================
|
|
|
358 R -show registry | | M -show session group
|
|
|
359 D -diff output | E -browse Ediff manual| G -send bug report
|
|
|
360 i -status info | ? -help off | z/q -suspend/quit
|
|
|
361 -------------------------------------------------------------------------------
|
|
|
362 X,Y (x,y) on the left are meta-symbols for the keys A,B,C (a,b,c).
|
|
|
363 X,Y on the right are meta-symbols for buffers A,B,C.
|
|
|
364 A,B,C on the right denote the working buffers A,B,C, respectively."
|
|
|
365 "The tail of the full-help message.")
|
|
|
366
|
|
|
367 (defconst ediff-long-help-message-compare3
|
|
|
368 "
|
|
|
369 p,DEL -previous diff | | -vert/horiz split | xy -copy buf X's region to Y
|
|
|
370 n,SPC -next diff | h -hiliting | rx -restore buf X's old diff
|
|
|
371 j -jump to diff | @ -auto-refinement | * -refine current region
|
|
|
372 gx -goto X's point| | ! -update diff regions
|
|
|
373 C-l -recenter | ## -ignore whitespace |
|
|
|
374 v/V -scroll up/dn | #f/#h -focus/hide regions | wx -save buf X
|
|
|
375 </> -scroll lt/rt | X -read-only in buf X | wd -save diff output
|
|
|
376 | m -wide display | ~ -rotate buffers
|
|
|
377 "
|
|
|
378 "Help message usually used for 3-way comparison.
|
|
|
379 Normally, not a user option. See `ediff-help-message' for details.")
|
|
|
380
|
|
|
381 (defconst ediff-long-help-message-compare2
|
|
|
382 "
|
|
|
383 p,DEL -previous diff | | -vert/horiz split |a/b -copy A/B's region to B/A
|
|
|
384 n,SPC -next diff | h -hiliting | rx -restore buf X's old diff
|
|
|
385 j -jump to diff | @ -auto-refinement | * -refine current region
|
|
|
386 gx -goto X's point| | ! -update diff regions
|
|
|
387 C-l -recenter | ## -ignore whitespace |
|
|
|
388 v/V -scroll up/dn | #f/#h -focus/hide regions | wx -save buf X
|
|
|
389 </> -scroll lt/rt | X -read-only in buf X | wd -save diff output
|
|
|
390 ~ -swap variants | m -wide display |
|
|
|
391 "
|
|
|
392 "Help message usually used for 2-way comparison.
|
|
|
393 Normally, not a user option. See `ediff-help-message' for details.")
|
|
|
394
|
|
|
395 (defconst ediff-long-help-message-narrow2
|
|
|
396 "
|
|
|
397 p,DEL -previous diff | | -vert/horiz split |a/b -copy A/B's region to B/A
|
|
|
398 n,SPC -next diff | h -hiliting | rx -restore buf X's old diff
|
|
|
399 j -jump to diff | @ -auto-refinement | * -refine current region
|
|
|
400 gx -goto X's point| % -narrow/widen buffs | ! -update diff regions
|
|
|
401 C-l -recenter | ## -ignore whitespace |
|
|
|
402 v/V -scroll up/dn | #f/#h -focus/hide regions | wx -save buf X
|
|
|
403 </> -scroll lt/rt | X -read-only in buf X | wd -save diff output
|
|
|
404 ~ -swap variants | m -wide display |
|
|
|
405 "
|
|
|
406 "Help message when comparing windows or regions line-by-line.
|
|
|
407 Normally, not a user option. See `ediff-help-message' for details.")
|
|
|
408
|
|
|
409 (defconst ediff-long-help-message-word-mode
|
|
|
410 "
|
|
|
411 p,DEL -previous diff | | -vert/horiz split | xy -copy buf X's region to Y
|
|
|
412 n,SPC -next diff | h -hiliting | rx -restore buf X's old diff
|
|
|
413 j -jump to diff | |
|
|
|
414 gx -goto X's point| % -narrow/widen buffs | ! -recompute diffs
|
|
|
415 C-l -recenter | |
|
|
|
416 v/V -scroll up/dn | #f/#h -focus/hide regions | wx -save buf X
|
|
|
417 </> -scroll lt/rt | X -read-only in buf X | wd -save diff output
|
|
|
418 ~ -swap variants | m -wide display |
|
|
|
419 "
|
|
|
420 "Help message when comparing windows or regions word-by-word.
|
|
|
421 Normally, not a user option. See `ediff-help-message' for details.")
|
|
|
422
|
|
|
423 (defconst ediff-long-help-message-merge
|
|
|
424 "
|
|
|
425 p,DEL -previous diff | | -vert/horiz split | x -copy buf X's region to C
|
|
|
426 n,SPC -next diff | h -hiliting | r -restore buf C's old diff
|
|
|
427 j -jump to diff | @ -auto-refinement | * -refine current region
|
|
|
428 gx -goto X's point| ## -ignore whitespace | ! -update diff regions
|
|
|
429 C-l -recenter | #f/#h -focus/hide regions | + -combine diff regions
|
|
|
430 v/V -scroll up/dn | X -read-only in buf X | wx -save buf X
|
|
|
431 </> -scroll lt/rt | m -wide display | wd -save diff output
|
|
|
432 ~ -swap variants | s -shrink window C | / -show ancestor buff
|
|
|
433 | $ -show clashes only | & -merge w/new default
|
|
|
434 "
|
|
|
435 "Help message during merging.
|
|
|
436 Normally, not a user option. See `ediff-help-message' for details.")
|
|
|
437
|
|
|
438 ;; The actual long help message.
|
|
|
439 (ediff-defvar-local ediff-long-help-message ""
|
|
|
440 "Normally, not a user option. See `ediff-help-message' for details.")
|
|
|
441
|
|
|
442 (defconst ediff-brief-message-string
|
|
|
443 " ? - help "
|
|
|
444 "Contents of the brief help message.")
|
|
|
445 ;; The actual brief help message
|
|
|
446 (ediff-defvar-local ediff-brief-help-message ""
|
|
|
447 "Normally, not a user option. See `ediff-help-message' for details.")
|
|
|
448
|
|
|
449 (ediff-defvar-local ediff-brief-help-message-function nil
|
|
|
450 "The brief help message that the user can customize.
|
|
|
451 If the user sets this to a parameter-less function, Ediff will use it to
|
|
|
452 produce the brief help message. This function must return a string.")
|
|
|
453 (ediff-defvar-local ediff-long-help-message-function nil
|
|
|
454 "The long help message that the user can customize.
|
|
|
455 See `ediff-brief-help-message-function' for more.")
|
|
|
456
|
|
|
457 (defvar ediff-use-long-help-message nil
|
|
|
458 "*If t, Ediff displays a long help message. Short help message otherwise.")
|
|
|
459
|
|
|
460 ;; The actual help message.
|
|
|
461 (ediff-defvar-local ediff-help-message ""
|
|
|
462 "The actual help message.
|
|
|
463 Normally, the user shouldn't touch this. However, if you want Ediff to
|
|
|
464 start up with different help messages for different jobs, you can change
|
|
|
465 the value of this variable and the variables `ediff-help-message-*' in
|
|
|
466 `ediff-startup-hook'.")
|
|
|
467
|
|
|
468 ;; Error messages
|
|
|
469 (defconst ediff-KILLED-VITAL-BUFFER
|
|
|
470 "You have killed a vital Ediff buffer---you must leave Ediff now!")
|
|
|
471 (defconst ediff-NO-DIFFERENCES
|
|
|
472 "Sorry, comparison of identical variants is not what I am made for...")
|
|
|
473 (defconst ediff-BAD-DIFF-NUMBER
|
|
|
474 ;; %S stands for this-command, %d - diff number, %d - max diff
|
|
|
475 "%S: Bad diff region number, %d. Valid numbers are 1 to %d")
|
|
|
476
|
|
|
477 ;; Selective browsing
|
|
|
478
|
|
|
479 (ediff-defvar-local ediff-skip-diff-region-function 'ediff-show-all-diffs
|
|
|
480 "Function that determines the next/previous diff region to show.
|
|
|
481 Should return t for regions to be ignored and nil otherwise.
|
|
|
482 This function gets a region number as an argument. The region number
|
|
|
483 is the one used internally by Ediff. It is 1 less than the number seen
|
|
|
484 by the user.")
|
|
|
485
|
|
|
486 (ediff-defvar-local ediff-hide-regexp-matches-function
|
|
|
487 'ediff-hide-regexp-matches
|
|
|
488 "Function to use in determining which regions to hide.
|
|
|
489 See the documentation string of `ediff-hide-regexp-matches' for details.")
|
|
|
490 (ediff-defvar-local ediff-focus-on-regexp-matches-function
|
|
|
491 'ediff-focus-on-regexp-matches
|
|
|
492 "Function to use in determining which regions to focus on.
|
|
|
493 See the documentation string of `ediff-focus-on-regexp-matches' for details.")
|
|
|
494
|
|
|
495 ;; Regexp that determines buf A regions to focus on when skipping to diff
|
|
|
496 (ediff-defvar-local ediff-regexp-focus-A "" "")
|
|
|
497 ;; Regexp that determines buf B regions to focus on when skipping to diff
|
|
|
498 (ediff-defvar-local ediff-regexp-focus-B "" "")
|
|
|
499 ;; Regexp that determines buf C regions to focus on when skipping to diff
|
|
|
500 (ediff-defvar-local ediff-regexp-focus-C "" "")
|
|
|
501 ;; connective that determines whether to focus regions that match both or
|
|
|
502 ;; one of the regexps
|
|
|
503 (ediff-defvar-local ediff-focus-regexp-connective 'and "")
|
|
|
504
|
|
|
505 ;; Regexp that determines buf A regions to ignore when skipping to diff
|
|
|
506 (ediff-defvar-local ediff-regexp-hide-A "" "")
|
|
|
507 ;; Regexp that determines buf B regions to ignore when skipping to diff
|
|
|
508 (ediff-defvar-local ediff-regexp-hide-B "" "")
|
|
|
509 ;; Regexp that determines buf C regions to ignore when skipping to diff
|
|
|
510 (ediff-defvar-local ediff-regexp-hide-C "" "")
|
|
|
511 ;; connective that determines whether to hide regions that match both or
|
|
|
512 ;; one of the regexps
|
|
|
513 (ediff-defvar-local ediff-hide-regexp-connective 'and "")
|
|
|
514
|
|
|
515
|
|
|
516 (defvar ediff-ange-ftp-ftp-name (if ediff-xemacs-p
|
|
|
517 'ange-ftp-ftp-path
|
|
|
518 'ange-ftp-ftp-name)
|
|
|
519 "Function ange-ftp uses to find out if file is remote.")
|
|
|
520
|
|
|
521
|
|
|
522 ;; Copying difference regions between buffers.
|
|
|
523 (ediff-defvar-local ediff-killed-diffs-alist nil
|
|
|
524 "A list of killed diffs.
|
|
|
525 A diff is saved here if it is replaced by a diff
|
|
|
526 from another buffer. This alist has the form:
|
|
|
527 \((num (buff-object . diff) (buff-object . diff) (buff-object . diff)) ...),
|
|
|
528 where some buffer-objects may be missing.")
|
|
|
529
|
|
|
530
|
|
|
531 ;; Highlighting
|
|
|
532 ;;(defvar ediff-before-flag-bol (if ediff-emacs-p "->>\n" (make-glyph "->>\n"))
|
|
|
533 (defvar ediff-before-flag-bol (if ediff-xemacs-p (make-glyph "->>") "->>")
|
|
|
534 "*Flag placed above the highlighted block of differences.
|
|
|
535 Must end with newline.")
|
|
|
536 ;;(defvar ediff-after-flag-eol (if ediff-emacs-p "<<-\n" (make-glyph "<<-"))
|
|
|
537 (defvar ediff-after-flag-eol (if ediff-xemacs-p (make-glyph "<<-") "<<-")
|
|
|
538 "*Flag placed below the highlighted block of differences.
|
|
|
539 Must end with newline.")
|
|
|
540
|
|
|
541 (defvar ediff-before-flag-mol (if ediff-xemacs-p (make-glyph "->>") "->>")
|
|
|
542 "*Like ediff-before-flag, used when a difference starts in mid-line.")
|
|
|
543 (defvar ediff-after-flag-mol (if ediff-xemacs-p (make-glyph "<<-") "<<-")
|
|
|
544 "*Like ediff-after-flag, used when a difference starts in mid-line.")
|
|
|
545
|
|
|
546
|
|
|
547 (ediff-defvar-local ediff-use-faces t
|
|
|
548 "If t, differences are highlighted using faces, if device supports faces.
|
|
|
549 If nil, differences are highlighted using ASCII flags, ediff-before-flag
|
|
|
550 and ediff-after-flag. On a non-window system, differences are always
|
|
|
551 highlighted using ASCII flags.
|
|
|
552 This variable can be set either in .emacs or toggled interactively.
|
|
|
553 Use `setq-default' if setting it in .emacs")
|
|
|
554
|
|
|
555 ;; this indicates that diff regions are word-size, so fine diffs are
|
|
|
556 ;; permanently nixed; used in ediff-windows-wordwise and ediff-regions-wordwise
|
|
|
557 (ediff-defvar-local ediff-word-mode nil "")
|
|
|
558 ;; Name of the job (ediff-files, ediff-windows, etc.)
|
|
|
559 (ediff-defvar-local ediff-job-name nil "")
|
|
|
560
|
|
|
561 ;; Narrowing and ediff-region/windows support
|
|
|
562 ;; This is a list (overlay-A overlay-B overlay-C)
|
|
|
563 ;; If set, Ediff compares only those parts of buffers A/B/C that lie within
|
|
|
564 ;; the bounds of these overlays.
|
|
|
565 (ediff-defvar-local ediff-narrow-bounds nil "")
|
|
|
566
|
|
|
567 ;; List (overlay-A overlay-B overlay-C), where each overlay spans the
|
|
|
568 ;; entire corresponding buffer.
|
|
|
569 (ediff-defvar-local ediff-wide-bounds nil "")
|
|
|
570
|
|
|
571 ;; Current visibility boundaries in buffers A, B, and C.
|
|
|
572 ;; This is also a list of overlays. When the user toggles narrow/widen,
|
|
|
573 ;; this list changes from ediff-wide-bounds to ediff-narrow-bounds.
|
|
|
574 ;; and back.
|
|
|
575 (ediff-defvar-local ediff-visible-bounds nil "")
|
|
|
576
|
|
|
577 (ediff-defvar-local ediff-start-narrowed t
|
|
|
578 "Non-nil means start narrowed, if doing ediff-windows-* or ediff-regions-*")
|
|
|
579 (ediff-defvar-local ediff-quit-widened t
|
|
|
580 "*Non-nil means: when finished, Ediff widens buffers A/B.
|
|
|
581 Actually, Ediff restores the scope of visibility that existed at startup.")
|
|
|
582 (defvar ediff-keep-variants t
|
|
|
583 "*Nil means that non-modified variant buffers should be removed after some
|
|
|
584 interrogation.
|
|
|
585 Supplying a prefix argument to the quit command `q' temporarily reverses the
|
|
|
586 meaning of this variable.")
|
|
|
587
|
|
|
588 (ediff-defvar-local ediff-highlight-all-diffs t
|
|
|
589 "If nil, only the selected differences are highlighted.
|
|
|
590 This variable can be set either in .emacs or toggled interactively, using
|
|
|
591 ediff-toggle-hilit. Use `setq-default' to set it.")
|
|
|
592
|
|
|
593 ;; A var local to each control panel buffer. Indicates highlighting style
|
|
|
594 ;; in effect for this buffer: `face', `ascii', nil -- temporarily
|
|
|
595 ;; unhighlighted, `off' -- turned off \(on a dumb terminal only\).
|
|
|
596 (ediff-defvar-local ediff-highlighting-style nil "")
|
|
|
597
|
|
|
598
|
|
|
599 ;; The suffix of the control buffer name.
|
|
|
600 (ediff-defvar-local ediff-control-buffer-suffix nil "")
|
|
|
601 ;; Same as ediff-control-buffer-suffix, but without <,>.
|
|
|
602 ;; It's a number rather than string.
|
|
|
603 (ediff-defvar-local ediff-control-buffer-number nil "")
|
|
|
604
|
|
|
605
|
|
|
606 ;; The original values of ediff-protected-variables for buffer A
|
|
|
607 (ediff-defvar-local ediff-buffer-values-orig-A nil "")
|
|
|
608 ;; The original values of ediff-protected-variables for buffer B
|
|
|
609 (ediff-defvar-local ediff-buffer-values-orig-B nil "")
|
|
|
610 ;; The original values of ediff-protected-variables for buffer C
|
|
|
611 (ediff-defvar-local ediff-buffer-values-orig-C nil "")
|
|
|
612 ;; The original values of ediff-protected-variables for buffer Ancestor
|
|
|
613 (ediff-defvar-local ediff-buffer-values-orig-Ancestor nil "")
|
|
|
614 ;; Buffer-local variables to be saved then restored during Ediff sessions
|
|
|
615 ;; Buffer-local variables to be saved then restored during Ediff sessions
|
|
|
616 (defconst ediff-protected-variables '(buffer-read-only
|
|
|
617 ;;; synchronize-minibuffers
|
|
|
618 mode-line-format))
|
|
|
619
|
|
|
620 ;; Vector of differences between the variants. Each difference is
|
|
|
621 ;; represented by a vector of two overlays plus a vector of fine diffs,
|
|
|
622 ;; plus a no-fine-diffs flag. The first overlay spans the
|
|
|
623 ;; difference region in the A buffer and the second overlays the diff in
|
|
|
624 ;; the B buffer. If a difference section is empty, the corresponding
|
|
|
625 ;; overlay's endpoints coincide.
|
|
|
626 ;;
|
|
|
627 ;; The precise form of a difference vector for one buffer is:
|
|
|
628 ;; [diff diff diff ...]
|
|
|
629 ;; where each diff has the form:
|
|
|
630 ;; [diff-overlay fine-diff-vector no-fine-diffs-flag state-of-difference]
|
|
|
631 ;; fine-diff-vector is a vector [fine-diff-overlay fine-diff-overlay ...]
|
|
|
632 ;; no-fine-diffs-flag says if there are fine differences.
|
|
|
633 ;; state-of-difference is A, B, C, or nil, indicating which buffer is
|
|
|
634 ;; different from the other two (used only in 3-way jobs.
|
|
|
635 (ediff-defvar-local ediff-difference-vector-A nil "")
|
|
|
636 (ediff-defvar-local ediff-difference-vector-B nil "")
|
|
|
637 (ediff-defvar-local ediff-difference-vector-C nil "")
|
|
|
638 (ediff-defvar-local ediff-difference-vector-Ancestor nil "")
|
|
|
639
|
|
|
640 ;; [ status status status ...]
|
|
|
641 ;; Each status: [state-of-merge state-of-ancestor]
|
|
|
642 ;; state-of-merge is default-A, default-B, prefer-A, or prefer-B. It
|
|
|
643 ;; indicates the way a diff region was created in buffer C.
|
|
|
644 ;; state-of-ancestor says if the corresponding region in ancestor buffer is
|
|
|
645 ;; empty.
|
|
|
646 (ediff-defvar-local ediff-state-of-merge nil "")
|
|
|
647
|
|
|
648 ;; The difference that is currently selected.
|
|
|
649 (ediff-defvar-local ediff-current-difference -1 "")
|
|
|
650 ;; Number of differences found.
|
|
|
651 (ediff-defvar-local ediff-number-of-differences nil "")
|
|
|
652
|
|
|
653 ;; Buffer containing the output of diff, which is used by Ediff to step
|
|
|
654 ;; through files.
|
|
|
655 (ediff-defvar-local ediff-diff-buffer nil "")
|
|
|
656 ;; Like ediff-diff-buffer, but contains context diff. It is not used by
|
|
|
657 ;; Ediff, but it is saved in a file, if user requests so.
|
|
|
658 (ediff-defvar-local ediff-custom-diff-buffer nil "")
|
|
|
659 ;; Buffer used for diff-style fine differences between regions.
|
|
|
660 (ediff-defvar-local ediff-fine-diff-buffer nil "")
|
|
|
661 ;; Temporary buffer used for computing fine differences.
|
|
|
662 (defconst ediff-tmp-buffer " *ediff-tmp*" "")
|
|
|
663 ;; Buffer used for messages
|
|
|
664 (defconst ediff-msg-buffer " *ediff-message*" "")
|
|
|
665 ;; Buffer containing the output of diff when diff returns errors.
|
|
|
666 (ediff-defvar-local ediff-error-buffer nil "")
|
|
|
667 ;; Buffer to display debug info
|
|
|
668 (ediff-defvar-local ediff-debug-buffer "*ediff-debug*" "")
|
|
|
669
|
|
|
670 ;; List of ediff control panels associated with each buffer A/B/C/Ancestor.
|
|
|
671 ;; Not used any more, but may be needed in the future.
|
|
|
672 (ediff-defvar-local ediff-this-buffer-ediff-sessions nil "")
|
|
|
673
|
|
|
674 ;; to be deleted in due time
|
|
|
675 ;; List of difference overlays disturbed by working with the current diff.
|
|
|
676 (defvar ediff-disturbed-overlays nil "")
|
|
|
677
|
|
|
678 ;; Priority of non-selected overlays.
|
|
|
679 (defvar ediff-shadow-overlay-priority 100 "")
|
|
|
680
|
|
|
681 (defvar ediff-version-control-package 'vc
|
|
|
682 "Version control package used.
|
|
|
683 Currently, Ediff supports vc.el, rcs.el, pcl-cvs.el, and generic-sc.el. The
|
|
|
684 standard Emacs interface to RCS, CVS, SCCS, etc., is vc.el. However, some
|
|
|
685 people find the other two packages more convenient. Set this variable to the
|
|
|
686 appropriate symbol: `rcs', `pcl-cvs', or `generic-sc' if you so desire.")
|
|
|
687
|
|
|
688
|
|
|
689 (if ediff-xemacs-p
|
|
|
690 (progn
|
|
|
691 (fset 'ediff-read-event (symbol-function 'next-command-event))
|
|
|
692 (fset 'ediff-overlayp (symbol-function 'extentp))
|
|
|
693 (fset 'ediff-make-overlay (symbol-function 'make-extent))
|
|
|
694 (fset 'ediff-delete-overlay (symbol-function 'delete-extent)))
|
|
|
695 (fset 'ediff-read-event (symbol-function 'read-event))
|
|
|
696 (fset 'ediff-overlayp (symbol-function 'overlayp))
|
|
|
697 (fset 'ediff-overlayp (symbol-function 'overlayp))
|
|
|
698 (fset 'ediff-make-overlay (symbol-function 'make-overlay))
|
|
|
699 (fset 'ediff-delete-overlay (symbol-function 'delete-overlay)))
|
|
|
700
|
|
|
701 ;; Check the current version against the major and minor version numbers
|
|
|
702 ;; using op: cur-vers op major.minor If emacs-major-version or
|
|
|
703 ;; emacs-minor-version are not defined, we assume that the current version
|
|
|
704 ;; is hopelessly outdated. We assume that emacs-major-version and
|
|
|
705 ;; emacs-minor-version are defined. Otherwise, for Emacs/XEmacs 19, if the
|
|
|
706 ;; current minor version is < 10 (xemacs) or < 23 (emacs) the return value
|
|
|
707 ;; will be nil (when op is =, >, or >=) and t (when op is <, <=), which may be
|
|
|
708 ;; incorrect. However, this gives correct result in our cases, since we are
|
|
|
709 ;; testing for sufficiently high Emacs versions.
|
|
|
710 (defun ediff-check-version (op major minor &optional type-of-emacs)
|
|
|
711 (if (and (boundp 'emacs-major-version) (boundp 'emacs-minor-version))
|
|
|
712 (and (cond ((eq type-of-emacs 'xemacs) ediff-xemacs-p)
|
|
|
713 ((eq type-of-emacs 'emacs) ediff-emacs-p)
|
|
|
714 (t t))
|
|
|
715 (cond ((eq op '=) (and (= emacs-minor-version minor)
|
|
|
716 (= emacs-major-version major)))
|
|
|
717 ((memq op '(> >= < <=))
|
|
|
718 (and (or (funcall op emacs-major-version major)
|
|
|
719 (= emacs-major-version major))
|
|
|
720 (if (= emacs-major-version major)
|
|
|
721 (funcall op emacs-minor-version minor)
|
|
|
722 t)))
|
|
|
723 (t
|
|
|
724 (error "%S: Invalid op in ediff-check-version" op))))
|
|
|
725 (cond ((memq op '(= > >=)) nil)
|
|
|
726 ((memq op '(< <=)) t))))
|
|
|
727
|
|
|
728
|
|
|
729 ;;;; warn if it is a wrong version of emacs
|
|
|
730 ;;(if (or (ediff-check-version '< 19 29 'emacs)
|
|
|
731 ;; (ediff-check-version '< 19 12 'xemacs))
|
|
|
732 ;; (progn
|
|
|
733 ;; (with-output-to-temp-buffer ediff-msg-buffer
|
|
|
734 ;; (switch-to-buffer ediff-msg-buffer)
|
|
|
735 ;; (insert
|
|
|
736 ;; (format "
|
|
|
737 ;;
|
|
|
738 ;;This version of Ediff requires
|
|
|
739 ;;
|
|
|
740 ;;\t Emacs 19.29 and higher
|
|
|
741 ;;\t OR
|
|
|
742 ;;\t XEmacs 19.12 and higher
|
|
|
743 ;;
|
|
|
744 ;;It is unlikely to work under Emacs version %s
|
|
|
745 ;;that you are using... " emacs-version))
|
|
|
746 ;; (if noninteractive
|
|
|
747 ;; ()
|
|
|
748 ;; (beep 1)
|
|
|
749 ;; (beep 1)
|
|
|
750 ;; (insert "\n\nType any key to continue...")
|
|
|
751 ;; (ediff-read-event)))
|
|
|
752 ;; (kill-buffer ediff-msg-buffer)))
|
|
|
753
|
|
|
754 ;; A fix for NeXT Step
|
|
|
755 ;; Should probably be eliminated in later versions.
|
|
|
756 (if (and (ediff-window-display-p) (eq (ediff-device-type) 'ns))
|
|
|
757 (progn
|
|
|
758 (fset 'x-display-color-p (symbol-function 'ns-display-color-p))
|
|
|
759 (fset 'x-color-defined-p (symbol-function 'ns-color-defined-p))
|
|
|
760 (fset 'x-display-pixel-height (symbol-function 'ns-display-pixel-height))
|
|
|
761 (fset 'x-display-pixel-width (symbol-function 'ns-display-pixel-width))
|
|
|
762 ))
|
|
|
763
|
|
|
764
|
|
|
765 (defsubst ediff-color-display-p ()
|
|
|
766 (if ediff-emacs-p
|
|
|
767 (x-display-color-p)
|
|
|
768 (eq (device-class (selected-device)) 'color)))
|
|
|
769
|
|
|
770
|
|
|
771 (if (ediff-has-face-support-p)
|
|
|
772 (if ediff-xemacs-p
|
|
|
773 (progn
|
|
|
774 (fset 'ediff-valid-color-p (symbol-function 'valid-color-name-p))
|
|
|
775 (fset 'ediff-get-face (symbol-function 'get-face)))
|
|
|
776 ;; Temporary fix for OS/2 port of Emacs
|
|
|
777 ;; pm-win.el in PM-Emacs should be fixed.
|
|
|
778 (if (eq (ediff-device-type) 'pm)
|
|
|
779 (fset 'ediff-valid-color-p
|
|
|
780 (function (lambda (color) (assoc color pm-color-alist))))
|
|
|
781 (fset 'ediff-valid-color-p (symbol-function 'x-color-defined-p)))
|
|
|
782 (fset 'ediff-get-face (symbol-function 'internal-get-face))))
|
|
|
783
|
|
|
784 (if (ediff-window-display-p)
|
|
|
785 (if ediff-xemacs-p
|
|
|
786 (progn
|
|
|
787 (fset 'ediff-display-pixel-width
|
|
|
788 (symbol-function 'device-pixel-width))
|
|
|
789 (fset 'ediff-display-pixel-height
|
|
|
790 (symbol-function 'device-pixel-height)))
|
|
|
791 (fset 'ediff-display-pixel-width
|
|
|
792 (symbol-function 'x-display-pixel-width))
|
|
|
793 (fset 'ediff-display-pixel-height
|
|
|
794 (symbol-function 'x-display-pixel-height))))
|
|
|
795
|
|
|
796
|
|
|
797 (defun ediff-make-current-diff-overlay (type)
|
|
|
798 (if (ediff-has-face-support-p)
|
|
|
799 (let ((overlay (intern (format "ediff-current-diff-overlay-%S" type)))
|
|
|
800 (buffer (ediff-get-buffer type))
|
|
|
801 (face (face-name
|
|
|
802 (symbol-value
|
|
|
803 (intern (format "ediff-current-diff-face-%S" type))))))
|
|
|
804 (set overlay
|
|
|
805 (ediff-make-bullet-proof-overlay (point-max) (point-max) buffer))
|
|
|
806 (ediff-set-overlay-face (symbol-value overlay) face)
|
|
|
807 (ediff-overlay-put (symbol-value overlay) 'ediff ediff-control-buffer))
|
|
|
808 ))
|
|
|
809
|
|
|
810 (defun ediff-set-overlay-face (extent face)
|
|
|
811 (ediff-overlay-put extent 'face face)
|
|
|
812 (ediff-overlay-put extent 'help-echo 'ediff-region-help-echo))
|
|
|
813
|
|
|
814 ;; This does nothing in Emacs, since overlays there have no help-echo property
|
|
|
815 (defun ediff-region-help-echo (extent)
|
|
|
816 (let ((is-current (ediff-overlay-get extent 'ediff))
|
|
|
817 (face (ediff-overlay-get extent 'face))
|
|
|
818 (diff-num (ediff-overlay-get extent 'ediff-diff-num))
|
|
|
819 face-help)
|
|
|
820
|
|
|
821 ;; This happens only for refinement overlays
|
|
|
822 (setq face-help (and face (get face 'ediff-help-echo)))
|
|
|
823
|
|
|
824 (cond ((and is-current diff-num) ; current diff region
|
|
|
825 (format "Difference region %S -- current" (1+ diff-num)))
|
|
|
826 (face-help) ; refinement of current diff region
|
|
|
827 (diff-num ; non-current
|
|
|
828 (format "Difference region %S -- non-current" (1+ diff-num)))
|
|
|
829 (t "")) ; none
|
|
|
830 ))
|
|
|
831
|
|
|
832 (defun ediff-set-face (ground face color)
|
|
|
833 "Set face foreground/background."
|
|
|
834 (if (ediff-has-face-support-p)
|
|
|
835 (if (ediff-valid-color-p color)
|
|
|
836 (if (eq ground 'foreground)
|
|
|
837 (set-face-foreground face color)
|
|
|
838 (set-face-background face color))
|
|
|
839 (cond ((memq face
|
|
|
840 '(ediff-current-diff-face-A
|
|
|
841 ediff-current-diff-face-B
|
|
|
842 ediff-current-diff-face-C
|
|
|
843 ediff-current-diff-face-Ancestor))
|
|
|
844 (copy-face 'highlight face))
|
|
|
845 ((memq face
|
|
|
846 '(ediff-fine-diff-face-A
|
|
|
847 ediff-fine-diff-face-B
|
|
|
848 ediff-fine-diff-face-C
|
|
|
849 ediff-fine-diff-face-Ancestor))
|
|
|
850 (copy-face 'secondary-selection face)
|
|
|
851 (set-face-underline-p face t))
|
|
|
852 ((memq face
|
|
|
853 '(ediff-even-diff-face-A
|
|
|
854 ediff-odd-diff-face-A
|
|
|
855 ediff-even-diff-face-B ediff-odd-diff-face-B
|
|
|
856 ediff-even-diff-face-C ediff-odd-diff-face-C
|
|
|
857 ediff-even-diff-face-Ancestor
|
|
|
858 ediff-odd-diff-face-Ancestor))
|
|
|
859 (copy-face 'secondary-selection face))))
|
|
|
860 ))
|
|
|
861
|
|
|
862 (defun ediff-hide-face (face)
|
|
|
863 (if (and (ediff-has-face-support-p) ediff-emacs-p)
|
|
|
864 (add-to-list 'facemenu-unlisted-faces face)))
|
|
|
865
|
|
|
866 (defvar ediff-current-diff-face-A
|
|
|
867 (if (ediff-has-face-support-p)
|
|
|
868 (progn
|
|
|
869 (make-face 'ediff-current-diff-face-A)
|
|
|
870 (ediff-hide-face 'ediff-current-diff-face-A)
|
|
|
871 (or (face-differs-from-default-p 'ediff-current-diff-face-A)
|
|
|
872 (cond ((ediff-color-display-p)
|
|
|
873 (ediff-set-face
|
|
|
874 'foreground 'ediff-current-diff-face-A "firebrick")
|
|
|
875 (ediff-set-face
|
|
|
876 'background 'ediff-current-diff-face-A "pale green"))
|
|
|
877 (t
|
|
|
878 (if ediff-xemacs-p
|
|
|
879 (copy-face 'modeline 'ediff-current-diff-face-A)
|
|
|
880 (copy-face 'highlight 'ediff-current-diff-face-A))
|
|
|
881 )))
|
|
|
882 'ediff-current-diff-face-A))
|
|
|
883 "Face for highlighting the selected difference in buffer A.")
|
|
|
884
|
|
|
885 (defvar ediff-current-diff-face-B
|
|
|
886 (if (ediff-has-face-support-p)
|
|
|
887 (progn
|
|
|
888 (make-face 'ediff-current-diff-face-B)
|
|
|
889 (ediff-hide-face 'ediff-current-diff-face-B)
|
|
|
890 (or (face-differs-from-default-p 'ediff-current-diff-face-B)
|
|
|
891 (cond ((ediff-color-display-p)
|
|
|
892 (ediff-set-face
|
|
|
893 'foreground 'ediff-current-diff-face-B "DarkOrchid")
|
|
|
894 (ediff-set-face
|
|
|
895 'background 'ediff-current-diff-face-B "Yellow"))
|
|
|
896 (t
|
|
|
897 (if ediff-xemacs-p
|
|
|
898 (copy-face 'modeline 'ediff-current-diff-face-B)
|
|
|
899 (copy-face 'highlight 'ediff-current-diff-face-B))
|
|
|
900 )))
|
|
|
901 'ediff-current-diff-face-B))
|
|
|
902 "Face for highlighting the selected difference in buffer B.")
|
|
|
903
|
|
|
904
|
|
|
905 (defvar ediff-current-diff-face-C
|
|
|
906 (if (ediff-has-face-support-p)
|
|
|
907 (progn
|
|
|
908 (make-face 'ediff-current-diff-face-C)
|
|
|
909 (ediff-hide-face 'ediff-current-diff-face-C)
|
|
|
910 (or (face-differs-from-default-p 'ediff-current-diff-face-C)
|
|
|
911 (cond ((ediff-color-display-p)
|
|
|
912 (ediff-set-face
|
|
|
913 'foreground 'ediff-current-diff-face-C "Navy")
|
|
|
914 (ediff-set-face
|
|
|
915 'background 'ediff-current-diff-face-C "Pink"))
|
|
|
916 (t
|
|
|
917 (if ediff-xemacs-p
|
|
|
918 (copy-face 'modeline 'ediff-current-diff-face-C)
|
|
|
919 (copy-face 'highlight 'ediff-current-diff-face-C))
|
|
|
920 )))
|
|
|
921 'ediff-current-diff-face-C))
|
|
|
922 "Face for highlighting the selected difference in buffer C.")
|
|
|
923
|
|
|
924 (defvar ediff-current-diff-face-Ancestor
|
|
|
925 (if (ediff-has-face-support-p)
|
|
|
926 (progn
|
|
|
927 (make-face 'ediff-current-diff-face-Ancestor)
|
|
|
928 (ediff-hide-face 'ediff-current-diff-face-Ancestor)
|
|
|
929 (or (face-differs-from-default-p 'ediff-current-diff-face-Ancestor)
|
|
|
930 (copy-face
|
|
|
931 'ediff-current-diff-face-C 'ediff-current-diff-face-Ancestor))))
|
|
|
932 "Face for highlighting the selected difference in the ancestor buffer.")
|
|
|
933
|
|
|
934 (defvar ediff-fine-diff-face-A
|
|
|
935 (if (ediff-has-face-support-p)
|
|
|
936 (progn
|
|
|
937 (make-face 'ediff-fine-diff-face-A)
|
|
|
938 (ediff-hide-face 'ediff-fine-diff-face-A)
|
|
|
939 (or (face-differs-from-default-p 'ediff-fine-diff-face-A)
|
|
|
940 (cond ((ediff-color-display-p)
|
|
|
941 (ediff-set-face 'foreground 'ediff-fine-diff-face-A
|
|
|
942 "Navy")
|
|
|
943 (ediff-set-face 'background 'ediff-fine-diff-face-A
|
|
|
944 "sky blue"))
|
|
|
945 (t (set-face-underline-p 'ediff-fine-diff-face-A t))))
|
|
|
946 'ediff-fine-diff-face-A))
|
|
|
947 "Face for highlighting the refinement of the selected diff in buffer A.")
|
|
|
948
|
|
|
949 (defvar ediff-fine-diff-face-B
|
|
|
950 (if (ediff-has-face-support-p)
|
|
|
951 (progn
|
|
|
952 (make-face 'ediff-fine-diff-face-B)
|
|
|
953 (ediff-hide-face 'ediff-fine-diff-face-B)
|
|
|
954 (or (face-differs-from-default-p 'ediff-fine-diff-face-B)
|
|
|
955 (cond ((ediff-color-display-p)
|
|
|
956 (ediff-set-face 'foreground 'ediff-fine-diff-face-B "Black")
|
|
|
957 (ediff-set-face 'background 'ediff-fine-diff-face-B "cyan"))
|
|
|
958 (t (set-face-underline-p 'ediff-fine-diff-face-B t))))
|
|
|
959 'ediff-fine-diff-face-B))
|
|
|
960 "Face for highlighting the refinement of the selected diff in buffer B.")
|
|
|
961
|
|
|
962 (defvar ediff-fine-diff-face-C
|
|
|
963 (if (ediff-has-face-support-p)
|
|
|
964 (progn
|
|
|
965 (make-face 'ediff-fine-diff-face-C)
|
|
|
966 (ediff-hide-face 'ediff-fine-diff-face-C)
|
|
|
967 (or (face-differs-from-default-p 'ediff-fine-diff-face-C)
|
|
|
968 (cond ((ediff-color-display-p)
|
|
|
969 (ediff-set-face 'foreground 'ediff-fine-diff-face-C "black")
|
|
|
970 (ediff-set-face
|
|
|
971 'background 'ediff-fine-diff-face-C "Turquoise"))
|
|
|
972 (t (set-face-underline-p 'ediff-fine-diff-face-C t))))
|
|
|
973 'ediff-fine-diff-face-C))
|
|
|
974 "Face for highlighting the refinement of the selected diff in buffer C.")
|
|
|
975
|
|
|
976 (defvar ediff-fine-diff-face-Ancestor
|
|
|
977 (if (ediff-has-face-support-p)
|
|
|
978 (progn
|
|
|
979 (make-face 'ediff-fine-diff-face-Ancestor)
|
|
|
980 (ediff-hide-face 'ediff-fine-diff-face-Ancestor)
|
|
|
981 (or (face-differs-from-default-p 'ediff-fine-diff-face-Ancestor)
|
|
|
982 (copy-face
|
|
|
983 'ediff-fine-diff-face-C 'ediff-fine-diff-face-Ancestor))))
|
|
|
984 "Face highlighting refinements of the selected diff in ancestor buffer.
|
|
|
985 Presently, this is not used, as difference regions are not refined in the
|
|
|
986 ancestor buffer.")
|
|
|
987
|
|
|
988 (defvar ediff-even-diff-face-A
|
|
|
989 (if (ediff-has-face-support-p)
|
|
|
990 (progn
|
|
|
991 (make-face 'ediff-even-diff-face-A)
|
|
|
992 (ediff-hide-face 'ediff-even-diff-face-A)
|
|
|
993 (or (face-differs-from-default-p 'ediff-even-diff-face-A)
|
|
|
994 (cond ((ediff-color-display-p)
|
|
|
995 (ediff-set-face
|
|
|
996 'foreground 'ediff-even-diff-face-A "black")
|
|
|
997 (ediff-set-face
|
|
|
998 'background 'ediff-even-diff-face-A "light grey"))
|
|
|
999 (t
|
|
|
1000 (copy-face 'italic 'ediff-even-diff-face-A))))
|
|
|
1001 'ediff-even-diff-face-A))
|
|
|
1002 "Face used to highlight even-numbered differences in buffer A.")
|
|
|
1003
|
|
|
1004 (defvar ediff-even-diff-face-B
|
|
|
1005 (if (ediff-has-face-support-p)
|
|
|
1006 (progn
|
|
|
1007 (make-face 'ediff-even-diff-face-B)
|
|
|
1008 (ediff-hide-face 'ediff-even-diff-face-B)
|
|
|
1009 (or (face-differs-from-default-p 'ediff-even-diff-face-B)
|
|
|
1010 (cond ((ediff-color-display-p)
|
|
|
1011 (ediff-set-face
|
|
|
1012 'foreground 'ediff-even-diff-face-B "White")
|
|
|
1013 (ediff-set-face
|
|
|
1014 'background 'ediff-even-diff-face-B "Gray"))
|
|
|
1015 (t
|
|
|
1016 (copy-face 'italic 'ediff-even-diff-face-B))))
|
|
|
1017 'ediff-even-diff-face-B))
|
|
|
1018 "Face used to highlight even-numbered differences in buffer B.")
|
|
|
1019
|
|
|
1020 (defvar ediff-even-diff-face-C
|
|
|
1021 (if (ediff-has-face-support-p)
|
|
|
1022 (progn
|
|
|
1023 (make-face 'ediff-even-diff-face-C)
|
|
|
1024 (ediff-hide-face 'ediff-even-diff-face-C)
|
|
|
1025 (or (face-differs-from-default-p 'ediff-even-diff-face-C)
|
|
|
1026 (copy-face 'ediff-even-diff-face-A 'ediff-even-diff-face-C))
|
|
|
1027 'ediff-even-diff-face-C))
|
|
|
1028 "Face used to highlight even-numbered differences in buffer C.")
|
|
|
1029
|
|
|
1030 (defvar ediff-even-diff-face-Ancestor
|
|
|
1031 (if (ediff-has-face-support-p)
|
|
|
1032 (progn
|
|
|
1033 (make-face 'ediff-even-diff-face-Ancestor)
|
|
|
1034 (ediff-hide-face 'ediff-even-diff-face-Ancestor)
|
|
|
1035 (or (face-differs-from-default-p 'ediff-even-diff-face-Ancestor)
|
|
|
1036 (copy-face 'ediff-even-diff-face-C 'ediff-even-diff-face-Ancestor))
|
|
|
1037 'ediff-even-diff-face-Ancestor))
|
|
|
1038 "Face highlighting even-numbered differences in the ancestor buffer.")
|
|
|
1039
|
|
|
1040 (defvar ediff-odd-diff-face-A
|
|
|
1041 (if (ediff-has-face-support-p)
|
|
|
1042 (progn
|
|
|
1043 (make-face 'ediff-odd-diff-face-A)
|
|
|
1044 (ediff-hide-face 'ediff-odd-diff-face-A)
|
|
|
1045 (or (face-differs-from-default-p 'ediff-odd-diff-face-A)
|
|
|
1046 (cond ((ediff-color-display-p)
|
|
|
1047 (ediff-set-face
|
|
|
1048 'foreground 'ediff-odd-diff-face-A "White")
|
|
|
1049 (ediff-set-face
|
|
|
1050 'background 'ediff-odd-diff-face-A "Gray"))
|
|
|
1051 (t
|
|
|
1052 (copy-face 'italic 'ediff-odd-diff-face-A))))
|
|
|
1053 'ediff-odd-diff-face-A))
|
|
|
1054 "Face used to highlight odd-numbered differences in buffer A.")
|
|
|
1055
|
|
|
1056 (defvar ediff-odd-diff-face-B
|
|
|
1057 (if (ediff-has-face-support-p)
|
|
|
1058 (progn
|
|
|
1059 (make-face 'ediff-odd-diff-face-B)
|
|
|
1060 (ediff-hide-face 'ediff-odd-diff-face-B)
|
|
|
1061 (or (face-differs-from-default-p 'ediff-odd-diff-face-B)
|
|
|
1062 (cond ((ediff-color-display-p)
|
|
|
1063 (ediff-set-face
|
|
|
1064 'foreground 'ediff-odd-diff-face-B "Black")
|
|
|
1065 (ediff-set-face
|
|
|
1066 'background 'ediff-odd-diff-face-B "light grey"))
|
|
|
1067 (t
|
|
|
1068 (copy-face 'italic 'ediff-odd-diff-face-B))))
|
|
|
1069 'ediff-odd-diff-face-B))
|
|
|
1070 "Face used to highlight odd-numbered differences in buffer B.")
|
|
|
1071
|
|
|
1072 (defvar ediff-odd-diff-face-C
|
|
|
1073 (if (ediff-has-face-support-p)
|
|
|
1074 (progn
|
|
|
1075 (make-face 'ediff-odd-diff-face-C)
|
|
|
1076 (ediff-hide-face 'ediff-odd-diff-face-C)
|
|
|
1077 (or (face-differs-from-default-p 'ediff-odd-diff-face-C)
|
|
|
1078 (copy-face 'ediff-odd-diff-face-A 'ediff-odd-diff-face-C))
|
|
|
1079 'ediff-odd-diff-face-C))
|
|
|
1080 "Face used to highlight odd-numbered differences in buffer C.")
|
|
|
1081
|
|
|
1082 (defvar ediff-odd-diff-face-Ancestor
|
|
|
1083 (if (ediff-has-face-support-p)
|
|
|
1084 (progn
|
|
|
1085 (make-face 'ediff-odd-diff-face-Ancestor)
|
|
|
1086 (ediff-hide-face 'ediff-odd-diff-face-Ancestor)
|
|
|
1087 (or (face-differs-from-default-p 'ediff-odd-diff-face-Ancestor)
|
|
|
1088 (copy-face 'ediff-odd-diff-face-C 'ediff-odd-diff-face-Ancestor))
|
|
|
1089 'ediff-odd-diff-face-Ancestor))
|
|
|
1090 "Face used to highlight even-numbered differences in the ancestor buffer.")
|
|
|
1091
|
|
|
1092 ;; Help echo
|
|
|
1093 (put 'ediff-fine-diff-face-A 'ediff-help-echo
|
|
|
1094 "A `refinement' of the current difference region")
|
|
|
1095 (put 'ediff-fine-diff-face-B 'ediff-help-echo
|
|
|
1096 "A `refinement' of the current difference region")
|
|
|
1097 (put 'ediff-fine-diff-face-C 'ediff-help-echo
|
|
|
1098 "A `refinement' of the current difference region")
|
|
|
1099 (put 'ediff-fine-diff-face-Ancestor 'ediff-help-echo
|
|
|
1100 "A `refinement' of the current difference region")
|
|
|
1101
|
|
|
1102
|
|
|
1103 ;;; Overlays
|
|
|
1104
|
|
|
1105 (ediff-defvar-local ediff-current-diff-overlay-A nil
|
|
|
1106 "Overlay for the current difference region in buffer A.")
|
|
|
1107 (ediff-defvar-local ediff-current-diff-overlay-B nil
|
|
|
1108 "Overlay for the current difference region in buffer B.")
|
|
|
1109 (ediff-defvar-local ediff-current-diff-overlay-C nil
|
|
|
1110 "Overlay for the current difference region in buffer C.")
|
|
|
1111 (ediff-defvar-local ediff-current-diff-overlay-Ancestor nil
|
|
|
1112 "Overlay for the current difference region in the ancestor buffer.")
|
|
|
1113
|
|
|
1114 ;; Compute priority of ediff overlay.
|
|
|
1115 (defun ediff-highest-priority (start end buffer)
|
|
|
1116 (let ((pos (max 1 (1- start)))
|
|
|
1117 ovr-list)
|
|
|
1118 (if ediff-xemacs-p
|
|
|
1119 (1+ ediff-shadow-overlay-priority)
|
|
|
1120 (ediff-eval-in-buffer buffer
|
|
|
1121 (while (< pos (min (point-max) (1+ end)))
|
|
|
1122 (setq ovr-list (append (overlays-at pos) ovr-list))
|
|
|
1123 (setq pos (next-overlay-change pos)))
|
|
|
1124 (1+ (apply '+
|
|
|
1125 (mapcar (function
|
|
|
1126 (lambda (ovr)
|
|
|
1127 (if ovr
|
|
|
1128 (or (ediff-overlay-get ovr 'priority) 0)
|
|
|
1129 0)))
|
|
|
1130 ovr-list)
|
|
|
1131 ))
|
|
|
1132 ))))
|
|
|
1133
|
|
|
1134
|
|
|
1135 (defvar ediff-toggle-read-only-function nil
|
|
|
1136 "*Specifies the function to be used to toggle read-only.
|
|
|
1137 If nil, Ediff tries to deduce the function from the binding of C-x C-q.
|
|
|
1138 Normally, this is the `toggle-read-only' function, but, if version
|
|
|
1139 control is used, it could be `vc-toggle-read-only' or `rcs-toggle-read-only'.")
|
|
|
1140
|
|
|
1141
|
|
|
1142 ;;; Misc
|
|
|
1143
|
|
|
1144 ;; if nil, this silences some messages
|
|
|
1145 (defconst ediff-verbose-p t)
|
|
|
1146
|
|
|
1147 (defvar ediff-no-emacs-help-in-control-buffer nil
|
|
|
1148 "*Non-nil means C-h should not invoke Emacs help in control buffer.
|
|
|
1149 Instead, C-h jumps to previous difference.")
|
|
|
1150
|
|
|
1151 (defvar ediff-temp-file-prefix
|
|
|
1152 (let ((env (or (getenv "TMPDIR")
|
|
|
1153 (getenv "TMP")
|
|
|
1154 (getenv "TEMP")))
|
|
|
1155 d)
|
|
|
1156 (setq d (if (and env (> (length env) 0))
|
|
|
1157 env
|
|
|
1158 (cond ((memq system-type '(vax-vms axp-vms)) "SYS$SCRATCH:")
|
|
|
1159 ((eq system-type 'ms-dos) "c:/")
|
|
|
1160 (t "/tmp"))))
|
|
|
1161 ;; The following is to make sure we get something to which we can
|
|
|
1162 ;; add directory levels on VMS.
|
|
|
1163 (setq d (file-name-as-directory (directory-file-name d)))
|
|
|
1164 )
|
|
|
1165 "*Prefix to put on Ediff temporary file names.
|
|
|
1166 Do not start with `~/' or `~user-name/'.")
|
|
|
1167
|
|
|
1168 (defvar ediff-temp-file-mode 384 ; u=rw only
|
|
|
1169 "*Mode for Ediff temporary files.")
|
|
|
1170
|
|
|
1171 ;; Metacharacters that have to be protected from the shell when executing
|
|
|
1172 ;; a diff/diff3 command.
|
|
|
1173 (defvar ediff-metachars "[ \t\n!\"#$&'()*;<=>?[\\^`{|~]"
|
|
|
1174 "Characters that must be quoted with \\ when used in a shell command line.
|
|
|
1175 More precisely, a regexp to match any one such character.")
|
|
|
1176
|
|
|
1177 ;; needed to simulate frame-char-width in XEmacs.
|
|
|
1178 (defvar ediff-H-glyph (if ediff-xemacs-p (make-glyph "H")))
|
|
|
1179
|
|
|
1180
|
|
|
1181 (ediff-defvar-local ediff-temp-file-A nil
|
|
|
1182 "Temporary file used for refining difference regions in buffer A.")
|
|
|
1183 (ediff-defvar-local ediff-temp-file-B nil
|
|
|
1184 "Temporary file used for refining difference regions in buffer B.")
|
|
|
1185 (ediff-defvar-local ediff-temp-file-C nil
|
|
|
1186 "Temporary file used for refining difference regions in buffer C.")
|
|
|
1187
|
|
|
1188 ;;; In-line functions
|
|
|
1189
|
|
|
1190 (defsubst ediff-file-remote-p (file-name)
|
|
|
1191 (if (fboundp ediff-ange-ftp-ftp-name)
|
|
|
1192 (funcall ediff-ange-ftp-ftp-name file-name)))
|
|
|
1193
|
|
|
1194
|
|
|
1195 (defsubst ediff-frame-unsplittable-p (frame)
|
|
|
1196 (cdr (assq 'unsplittable (frame-parameters frame))))
|
|
|
1197
|
|
|
1198 (defsubst ediff-get-next-window (wind prev-wind)
|
|
|
1199 (or (window-live-p wind)
|
|
|
1200 (setq wind (if prev-wind
|
|
|
1201 (next-window wind)
|
|
|
1202 (selected-window)))))
|
|
|
1203
|
|
|
1204
|
|
|
1205 (defsubst ediff-kill-buffer-carefully (buf)
|
|
|
1206 "Kill buffer BUF if it exists."
|
|
|
1207 (if (ediff-buffer-live-p buf)
|
|
|
1208 (kill-buffer (get-buffer buf))))
|
|
|
1209
|
|
|
1210
|
|
|
1211 (defsubst ediff-highlight-diff (n)
|
|
|
1212 "Put face on diff N. Invoked for X displays only."
|
|
|
1213 (ediff-highlight-diff-in-one-buffer n 'A)
|
|
|
1214 (ediff-highlight-diff-in-one-buffer n 'B)
|
|
|
1215 (ediff-highlight-diff-in-one-buffer n 'C)
|
|
|
1216 (ediff-highlight-diff-in-one-buffer n 'Ancestor)
|
|
|
1217 )
|
|
|
1218
|
|
|
1219
|
|
|
1220 (defsubst ediff-unhighlight-diff ()
|
|
|
1221 "Remove overlays from buffers A, B, and C."
|
|
|
1222 (ediff-unhighlight-diff-in-one-buffer 'A)
|
|
|
1223 (ediff-unhighlight-diff-in-one-buffer 'B)
|
|
|
1224 (ediff-unhighlight-diff-in-one-buffer 'C)
|
|
|
1225 (ediff-unhighlight-diff-in-one-buffer 'Ancestor)
|
|
|
1226 )
|
|
|
1227
|
|
|
1228 ;; delete highlighting overlays, restore faces to their original form
|
|
|
1229 (defsubst ediff-unhighlight-diffs-totally ()
|
|
|
1230 (ediff-unhighlight-diffs-totally-in-one-buffer 'A)
|
|
|
1231 (ediff-unhighlight-diffs-totally-in-one-buffer 'B)
|
|
|
1232 (ediff-unhighlight-diffs-totally-in-one-buffer 'C)
|
|
|
1233 (ediff-unhighlight-diffs-totally-in-one-buffer 'Ancestor)
|
|
|
1234 )
|
|
|
1235
|
|
|
1236 (defsubst ediff-background-face (buf-type dif-num)
|
|
|
1237 ;; The value of dif-num is always 1- the one that user sees.
|
|
|
1238 ;; This is why even face is used when dif-num is odd.
|
|
|
1239 (intern (format (if (ediff-odd-p dif-num)
|
|
|
1240 "ediff-even-diff-face-%S"
|
|
|
1241 "ediff-odd-diff-face-%S")
|
|
|
1242 buf-type)))
|
|
|
1243
|
|
|
1244
|
|
|
1245 ;; arg is a record for a given diff in a difference vector
|
|
|
1246 ;; this record is itself a vector
|
|
|
1247 (defsubst ediff-clear-fine-diff-vector (diff-record)
|
|
|
1248 (if diff-record
|
|
|
1249 (mapcar 'ediff-delete-overlay
|
|
|
1250 (ediff-get-fine-diff-vector-from-diff-record diff-record))))
|
|
|
1251
|
|
|
1252 (defsubst ediff-clear-fine-differences-in-one-buffer (n buf-type)
|
|
|
1253 (ediff-clear-fine-diff-vector (ediff-get-difference n buf-type))
|
|
|
1254 (ediff-set-fine-diff-vector n buf-type nil))
|
|
|
1255
|
|
|
1256 (defsubst ediff-clear-fine-differences (n)
|
|
|
1257 (ediff-clear-fine-differences-in-one-buffer n 'A)
|
|
|
1258 (ediff-clear-fine-differences-in-one-buffer n 'B)
|
|
|
1259 (if ediff-3way-job
|
|
|
1260 (ediff-clear-fine-differences-in-one-buffer n 'C)))
|
|
|
1261
|
|
|
1262
|
|
|
1263 (defsubst ediff-convert-fine-diffs-to-overlays (diff-list region-num)
|
|
|
1264 (ediff-set-fine-overlays-in-one-buffer 'A diff-list region-num)
|
|
|
1265 (ediff-set-fine-overlays-in-one-buffer 'B diff-list region-num)
|
|
|
1266 (if ediff-3way-job
|
|
|
1267 (ediff-set-fine-overlays-in-one-buffer 'C diff-list region-num)
|
|
|
1268 ))
|
|
|
1269
|
|
|
1270 (defsubst ediff-mouse-event-p (event)
|
|
|
1271 (if ediff-xemacs-p
|
|
|
1272 (button-event-p event)
|
|
|
1273 (string-match "mouse" (format "%S" (event-basic-type event)))
|
|
|
1274 ))
|
|
|
1275
|
|
|
1276
|
|
|
1277 (defsubst ediff-key-press-event-p (event)
|
|
|
1278 (if ediff-xemacs-p
|
|
|
1279 (key-press-event-p event)
|
|
|
1280 (or (char-or-string-p event) (symbolp event))))
|
|
|
1281
|
|
|
1282 (defun ediff-event-point (event)
|
|
|
1283 (cond ((ediff-mouse-event-p event)
|
|
|
1284 (if ediff-xemacs-p
|
|
|
1285 (event-point event)
|
|
|
1286 (posn-point (event-start event))))
|
|
|
1287 ((ediff-key-press-event-p event)
|
|
|
1288 (point))
|
|
|
1289 (t (error))))
|
|
|
1290
|
|
|
1291 (defun ediff-event-buffer (event)
|
|
|
1292 (cond ((ediff-mouse-event-p event)
|
|
|
1293 (if ediff-xemacs-p
|
|
|
1294 (event-buffer event)
|
|
|
1295 (window-buffer (posn-window (event-start event)))))
|
|
|
1296 ((ediff-key-press-event-p event)
|
|
|
1297 (current-buffer))
|
|
|
1298 (t (error))))
|
|
|
1299
|
|
|
1300
|
|
|
1301 (defsubst ediff-frame-iconified-p (frame)
|
|
|
1302 (if (and (ediff-window-display-p) (frame-live-p frame))
|
|
|
1303 (if ediff-xemacs-p
|
|
|
1304 (frame-iconified-p frame)
|
|
|
1305 (eq (frame-visible-p frame) 'icon))))
|
|
|
1306
|
|
|
1307 (defsubst ediff-window-visible-p (wind)
|
|
|
1308 ;; under TTY, window-live-p also means window is visible
|
|
|
1309 (and (window-live-p wind)
|
|
|
1310 (or (not (ediff-window-display-p))
|
|
|
1311 (frame-visible-p (window-frame wind)))))
|
|
|
1312
|
|
|
1313
|
|
|
1314 (defsubst ediff-frame-char-width (frame)
|
|
|
1315 (if ediff-xemacs-p
|
|
|
1316 (/ (frame-pixel-width frame) (frame-width frame))
|
|
|
1317 (frame-char-width frame)))
|
|
|
1318
|
|
|
1319 (defun ediff-reset-mouse (&optional frame do-not-grab-mouse)
|
|
|
1320 (or frame (setq frame (selected-frame)))
|
|
|
1321 (if (ediff-window-display-p)
|
|
|
1322 (let ((frame-or-wind frame))
|
|
|
1323 (if ediff-xemacs-p
|
|
|
1324 (setq frame-or-wind (frame-selected-window frame)))
|
|
|
1325 (or do-not-grab-mouse
|
|
|
1326 ;; don't set mouse if the user said to never do this
|
|
|
1327 (not ediff-grab-mouse)
|
|
|
1328 ;; Don't grab on quit, if the user doesn't want to.
|
|
|
1329 ;; If ediff-grab-mouse = t, then mouse won't be grabbed for
|
|
|
1330 ;; sessions that are not part of a group (this is done in
|
|
|
1331 ;; ediff-recenter). The condition below affects only terminating
|
|
|
1332 ;; sessions in session groups (in which case mouse is warped into
|
|
|
1333 ;; a meta buffer).
|
|
|
1334 (and (eq ediff-grab-mouse 'maybe)
|
|
|
1335 (memq this-command '(ediff-quit ediff-update-diffs)))
|
|
|
1336 (set-mouse-position frame-or-wind 1 0))
|
|
|
1337 )))
|
|
|
1338
|
|
|
1339 (defsubst ediff-spy-after-mouse ()
|
|
|
1340 (setq ediff-mouse-pixel-position (mouse-pixel-position)))
|
|
|
1341
|
|
|
1342 ;; It is not easy to find out when the user grabs the mouse, since emacs and
|
|
|
1343 ;; xemacs behave differently when mouse is not in any frame. Also, this is
|
|
|
1344 ;; sensitive to when the user grabbed mouse. Not used for now.
|
|
|
1345 (defun ediff-user-grabbed-mouse ()
|
|
|
1346 (if ediff-mouse-pixel-position
|
|
|
1347 (cond ((not (eq (car ediff-mouse-pixel-position)
|
|
|
1348 (car (mouse-pixel-position)))))
|
|
|
1349 ((and (car (cdr ediff-mouse-pixel-position))
|
|
|
1350 (car (cdr (mouse-pixel-position)))
|
|
|
1351 (cdr (cdr ediff-mouse-pixel-position))
|
|
|
1352 (cdr (cdr (mouse-pixel-position))))
|
|
|
1353 (not (and (< (abs (- (car (cdr ediff-mouse-pixel-position))
|
|
|
1354 (car (cdr (mouse-pixel-position)))))
|
|
|
1355 ediff-mouse-pixel-threshold)
|
|
|
1356 (< (abs (- (cdr (cdr ediff-mouse-pixel-position))
|
|
|
1357 (cdr (cdr (mouse-pixel-position)))))
|
|
|
1358 ediff-mouse-pixel-threshold))))
|
|
|
1359 (t nil))))
|
|
|
1360
|
|
|
1361 (defsubst ediff-frame-char-height (frame)
|
|
|
1362 (if ediff-xemacs-p
|
|
|
1363 (glyph-height ediff-H-glyph (selected-window frame))
|
|
|
1364 (frame-char-height frame)))
|
|
|
1365
|
|
|
1366
|
|
|
1367 (defsubst ediff-empty-overlay-p (overl)
|
|
|
1368 (= (ediff-overlay-start overl) (ediff-overlay-end overl)))
|
|
|
1369
|
|
|
1370 ;; like overlay-buffer in Emacs. In XEmacs, returns nil if the extent is
|
|
|
1371 ;; dead. Otherwise, works like extent-buffer
|
|
|
1372 (defun ediff-overlay-buffer (overl)
|
|
|
1373 (if ediff-emacs-p
|
|
|
1374 (overlay-buffer overl)
|
|
|
1375 (and (extent-live-p overl) (extent-object overl))))
|
|
|
1376
|
|
|
1377 ;; like overlay-get in Emacs. In XEmacs, returns nil if the extent is
|
|
|
1378 ;; dead. Otherwise, like extent-property
|
|
|
1379 (defun ediff-overlay-get (overl property)
|
|
|
1380 (if ediff-emacs-p
|
|
|
1381 (overlay-get overl property)
|
|
|
1382 (and (extent-live-p overl) (extent-property overl property))))
|
|
|
1383
|
|
|
1384 ;; t if diff region is empty.
|
|
|
1385 ;; In case of buffer C, t also if it is not a 3way
|
|
|
1386 ;; comparison job (merging jobs return t as well).
|
|
|
1387 (defun ediff-empty-diff-region-p (n buf-type)
|
|
|
1388 (if (eq buf-type 'C)
|
|
|
1389 (or (not ediff-3way-comparison-job)
|
|
|
1390 (= (ediff-get-diff-posn 'C 'beg n)
|
|
|
1391 (ediff-get-diff-posn 'C 'end n)))
|
|
|
1392 (= (ediff-get-diff-posn buf-type 'beg n)
|
|
|
1393 (ediff-get-diff-posn buf-type 'end n))))
|
|
|
1394
|
|
|
1395 ;; Test if diff region is white space only.
|
|
|
1396 ;; If 2-way job and buf-type = C, then returns t.
|
|
|
1397 (defun ediff-whitespace-diff-region-p (n buf-type)
|
|
|
1398 (or (and (eq buf-type 'C) (not ediff-3way-job))
|
|
|
1399 (ediff-empty-diff-region-p n buf-type)
|
|
|
1400 (let ((beg (ediff-get-diff-posn buf-type 'beg n))
|
|
|
1401 (end (ediff-get-diff-posn buf-type 'end n)))
|
|
|
1402 (ediff-eval-in-buffer (ediff-get-buffer buf-type)
|
|
|
1403 (save-excursion
|
|
|
1404 (goto-char beg)
|
|
|
1405 (skip-chars-forward ediff-whitespace)
|
|
|
1406 (>= (point) end))))))
|
|
|
1407
|
|
|
1408 ;; temporarily uses DIR to abbreviate file name
|
|
|
1409 ;; if DIR is nil, use default-directory
|
|
|
1410 (defun ediff-abbreviate-file-name (file &optional dir)
|
|
|
1411 (cond ((stringp dir)
|
|
|
1412 (let ((directory-abbrev-alist (list (cons dir ""))))
|
|
|
1413 (abbreviate-file-name file)))
|
|
|
1414 (ediff-emacs-p (abbreviate-file-name file))
|
|
|
1415 (t ; XEmacs requires addl argument
|
|
|
1416 (abbreviate-file-name file t))))
|
|
|
1417
|
|
|
1418 ;; Takes a directory and returns the parent directory.
|
|
|
1419 ;; does nothing to `/'. If the ARG is a regular file,
|
|
|
1420 ;; strip the file AND the last dir.
|
|
|
1421 (defun ediff-strip-last-dir (dir)
|
|
|
1422 (if (not (stringp dir)) (setq dir default-directory))
|
|
|
1423 (setq dir (expand-file-name dir))
|
|
|
1424 (or (file-directory-p dir) (setq dir (file-name-directory dir)))
|
|
|
1425 (let* ((pos (1- (length dir)))
|
|
|
1426 (last-char (aref dir pos)))
|
|
|
1427 (if (and (> pos 0) (= last-char ?/))
|
|
|
1428 (setq dir (substring dir 0 pos)))
|
|
|
1429 (ediff-abbreviate-file-name (file-name-directory dir))))
|
|
|
1430
|
|
|
1431 (defun ediff-truncate-string-left (str newlen)
|
|
|
1432 ;; leave space for ... on the left
|
|
|
1433 (let ((len (length str))
|
|
|
1434 substr)
|
|
|
1435 (if (<= len newlen)
|
|
|
1436 str
|
|
|
1437 (setq newlen (max 0 (- newlen 3)))
|
|
|
1438 (setq substr (substring str (max 0 (- len 1 newlen))))
|
|
|
1439 (concat "..." substr))))
|
|
|
1440
|
|
|
1441 (defun ediff-abbrev-jobname (jobname)
|
|
|
1442 (cond ((eq jobname 'ediff-directories)
|
|
|
1443 "Compare two directories")
|
|
|
1444 ((eq jobname 'ediff-files)
|
|
|
1445 "Compare two files")
|
|
|
1446 ((eq jobname 'ediff-buffers)
|
|
|
1447 "Compare two buffers")
|
|
|
1448 ((eq jobname 'ediff-directories3)
|
|
|
1449 "Compare three directories")
|
|
|
1450 ((eq jobname 'ediff-files3)
|
|
|
1451 "Compare three files")
|
|
|
1452 ((eq jobname 'ediff-buffers3)
|
|
|
1453 "Compare three buffers")
|
|
|
1454 ((eq jobname 'ediff-revision)
|
|
|
1455 "Compare file with a version")
|
|
|
1456 ((eq jobname 'ediff-directory-revisions)
|
|
|
1457 "Compare dir files with versions")
|
|
|
1458 ((eq jobname 'ediff-merge-directory-revisions)
|
|
|
1459 "Merge dir files with versions")
|
|
|
1460 ((eq jobname 'ediff-merge-directory-revisions-with-ancestor)
|
|
|
1461 "Merge dir versions via ancestors")
|
|
|
1462 (t
|
|
|
1463 (let* ((str (substring (symbol-name jobname) 6))
|
|
|
1464 (len (length str))
|
|
|
1465 (pos 0))
|
|
|
1466 (while (< pos len)
|
|
|
1467 (if (= pos 0)
|
|
|
1468 (aset str pos (upcase (aref str pos))))
|
|
|
1469 (if (= (aref str pos) ?-)
|
|
|
1470 (aset str pos ?\ ))
|
|
|
1471 (setq pos (1+ pos)))
|
|
|
1472 str))))
|
|
|
1473
|
|
|
1474
|
|
|
1475
|
|
|
1476 (defsubst ediff-get-region-contents (n buf-type ctrl-buf &optional start end)
|
|
|
1477 (ediff-eval-in-buffer
|
|
|
1478 (ediff-eval-in-buffer ctrl-buf (ediff-get-buffer buf-type))
|
|
|
1479 (buffer-substring
|
|
|
1480 (or start (ediff-get-diff-posn buf-type 'beg n ctrl-buf))
|
|
|
1481 (or end (ediff-get-diff-posn buf-type 'end n ctrl-buf)))))
|
|
|
1482
|
|
|
1483 ;; If ediff modified mode line, strip the modification
|
|
|
1484 (defsubst ediff-strip-mode-line-format ()
|
|
|
1485 (if (member (car mode-line-format) '(" A: " " B: " " C: " " Ancestor: "))
|
|
|
1486 (setq mode-line-format (nth 2 mode-line-format))))
|
|
|
1487
|
|
|
1488 ;; Verify that we have a difference selected.
|
|
|
1489 (defsubst ediff-valid-difference-p (&optional n)
|
|
|
1490 (or n (setq n ediff-current-difference))
|
|
|
1491 (and (>= n 0) (< n ediff-number-of-differences)))
|
|
|
1492
|
|
|
1493 (defsubst ediff-show-all-diffs (n)
|
|
|
1494 "Don't skip difference regions."
|
|
|
1495 nil)
|
|
|
1496
|
|
|
1497 (defsubst Xor (a b)
|
|
|
1498 (or (and a (not b)) (and (not a) b)))
|
|
|
1499
|
|
|
1500 (defsubst ediff-message-if-verbose (string &rest args)
|
|
|
1501 (if ediff-verbose-p
|
|
|
1502 (apply 'message string args)))
|
|
|
1503
|
|
|
1504 (defun ediff-file-attributes (filename attr-number)
|
|
|
1505 (let ((handler (find-file-name-handler filename 'find-file-noselect)))
|
|
|
1506 (if (and handler (string-match "ange-ftp" (format "%S" handler)))
|
|
|
1507 -1
|
|
|
1508 (nth attr-number (file-attributes filename)))))
|
|
|
1509 (defsubst ediff-file-size (filename)
|
|
|
1510 (ediff-file-attributes filename 7))
|
|
|
1511 (defsubst ediff-file-modtime (filename)
|
|
|
1512 (ediff-file-attributes filename 5))
|
|
|
1513
|
|
|
1514
|
|
|
1515
|
|
|
1516
|
|
|
1517
|
|
|
1518 (provide 'ediff-init)
|
|
|
1519
|
|
|
1520
|
|
|
1521 ;;; ediff-init.el ends here
|
