|
0
|
1 ;;; vc.el --- drive a version-control system from within Emacs
|
|
|
2
|
|
|
3 ;; Copyright (C) 1992, 1993, 1994 Free Software Foundation, Inc.
|
|
|
4 ;; Copyright (C) 1995 Tinker Systems and INS Engineering Corp.
|
|
|
5
|
|
|
6 ;; Author: Eric S. Raymond <esr@snark.thyrsus.com>
|
|
|
7 ;; Maintainer: ttn@netcom.com
|
|
|
8 ;; Version: 5.6
|
|
|
9
|
|
|
10 ;; This file is part of XEmacs.
|
|
|
11
|
|
|
12 ;; XEmacs is free software; you can redistribute it and/or modify it
|
|
|
13 ;; under the terms of the GNU General Public License as published by
|
|
|
14 ;; the Free Software Foundation; either version 2, or (at your option)
|
|
|
15 ;; any later version.
|
|
|
16
|
|
|
17 ;; XEmacs is distributed in the hope that it will be useful, but
|
|
|
18 ;; WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
19 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
|
20 ;; General Public License for more details.
|
|
|
21
|
|
|
22 ;; You should have received a copy of the GNU General Public License
|
|
16
|
23 ;; along with XEmacs; see the file COPYING. If not, write to the
|
|
|
24 ;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
|
|
25 ;; Boston, MA 02111-1307, USA.
|
|
0
|
26
|
|
|
27 ;;; Synched up with: It's not clear at this point.
|
|
|
28 ;;; mly synched this with FSF at version 5.4. Stig did a whole lot
|
|
|
29 ;;; of stuff to it since then, and so has the FSF.
|
|
|
30
|
|
|
31 ;;; Commentary:
|
|
|
32
|
|
|
33 ;; This mode is fully documented in the Emacs user's manual.
|
|
|
34 ;;
|
|
|
35 ;; This was designed and implemented by Eric Raymond <esr@snark.thyrsus.com>.
|
|
|
36 ;; Paul Eggert <eggert@twinsun.com>, Sebastian Kremer <sk@thp.uni-koeln.de>,
|
|
|
37 ;; and Richard Stallman contributed valuable criticism, support, and testing.
|
|
|
38 ;; CVS support was added by Per Cederqvist <ceder@lysator.liu.se>
|
|
|
39 ;; in Jan-Feb 1994.
|
|
|
40 ;;
|
|
|
41 ;; XEmacs fixes, CVS fixes, and general improvements
|
|
|
42 ;; by Jonathan Stigelman <Stig@hackvan.com>
|
|
|
43 ;;
|
|
|
44 ;; Supported version-control systems presently include SCCS, RCS, and CVS.
|
|
|
45 ;; The RCS lock-stealing code doesn't work right unless you use RCS 5.6.2
|
|
|
46 ;; or newer. Currently (January 1994) that is only a beta test release.
|
|
|
47 ;; Even initial checkins will fail if your RCS version is so old that ci
|
|
|
48 ;; doesn't understand -t-; this has been known to happen to people running
|
|
|
49 ;; NExTSTEP 3.0.
|
|
|
50 ;;
|
|
|
51 ;; The RCS code assumes strict locking. You can support the RCS -x option
|
|
|
52 ;; by adding pairs to the vc-master-templates list.
|
|
|
53 ;;
|
|
|
54 ;; Proper function of the SCCS diff commands requires the shellscript vcdiff
|
|
|
55 ;; to be installed somewhere on Emacs's path for executables.
|
|
|
56 ;;
|
|
|
57 ;; If your site uses the ChangeLog convention supported by Emacs, the
|
|
|
58 ;; function vc-comment-to-change-log should prove a useful checkin hook.
|
|
|
59 ;;
|
|
|
60 ;; This code depends on call-process passing back the subprocess exit
|
|
|
61 ;; status. Thus, you need Emacs 18.58 or later to run it. For the
|
|
|
62 ;; vc-directory command to work properly as documented, you need 19.
|
|
|
63 ;; You also need Emacs 19's ring.el.
|
|
|
64 ;;
|
|
|
65 ;; The vc code maintains some internal state in order to reduce expensive
|
|
|
66 ;; version-control operations to a minimum. Some names are only computed
|
|
|
67 ;; once. If you perform version control operations with RCS/SCCS/CVS while
|
|
|
68 ;; vc's back is turned, or move/rename master files while vc is running,
|
|
|
69 ;; vc may get seriously confused. Don't do these things!
|
|
|
70 ;;
|
|
|
71 ;; Developer's notes on some concurrency issues are included at the end of
|
|
|
72 ;; the file.
|
|
|
73
|
|
|
74 ;;; Code:
|
|
|
75
|
|
|
76 (require 'vc-hooks)
|
|
|
77 (require 'ring)
|
|
|
78 (eval-when-compile (require 'dired)) ; for dired-map-over-marks macro
|
|
|
79
|
|
|
80 (if (not (assoc 'vc-parent-buffer minor-mode-alist))
|
|
|
81 (setq minor-mode-alist
|
|
|
82 (cons '(vc-parent-buffer vc-parent-buffer-name)
|
|
|
83 minor-mode-alist)))
|
|
|
84
|
|
|
85 ;; General customization
|
|
|
86
|
|
|
87 (defvar vc-default-back-end nil
|
|
|
88 "*Back-end actually used by this interface; may be SCCS or RCS.
|
|
|
89 The value is only computed when needed to avoid an expensive search.")
|
|
|
90 (defvar vc-suppress-confirm nil
|
|
|
91 "*If non-nil, treat user as expert; suppress yes-no prompts on some things.")
|
|
|
92 (defvar vc-keep-workfiles t
|
|
|
93 "*If non-nil, don't delete working files after registering changes.
|
|
|
94 If the back-end is CVS, workfiles are always kept, regardless of the
|
|
|
95 value of this flag.")
|
|
|
96 (defvar vc-initial-comment nil
|
|
|
97 "*Prompt for initial comment when a file is registered.")
|
|
|
98 (defvar vc-command-messages nil
|
|
|
99 "*Display run messages from back-end commands.")
|
|
|
100 (defvar vc-mistrust-permissions 'file-symlink-p
|
|
|
101 "*Don't assume that permissions and ownership track version-control status.")
|
|
|
102 (defvar vc-checkin-switches nil
|
|
|
103 "*Extra switches passed to the checkin program by \\[vc-checkin].")
|
|
|
104 (defvar vc-checkout-switches nil
|
|
|
105 "*Extra switches passed to the checkout program by \\[vc-checkout].")
|
|
|
106 (defvar vc-path
|
|
|
107 (if (file-exists-p "/usr/sccs")
|
|
|
108 '("/usr/sccs") nil)
|
|
|
109 "*List of extra directories to search for version control commands.")
|
|
|
110 (defvar vc-directory-exclusion-list '("SCCS" "RCS")
|
|
|
111 "*Directory names ignored by functions that recursively walk file trees.")
|
|
|
112
|
|
|
113 (defconst vc-maximum-comment-ring-size 32
|
|
|
114 "Maximum number of saved comments in the comment ring.")
|
|
|
115
|
|
|
116 ;;; XEmacs - This is dumped into loaddefs.el already.
|
|
24
|
117 ;; Not any more! -sb
|
|
|
118 (defvar diff-switches "-c"
|
|
|
119 "*A string or list of strings specifying switches to be passed to diff.")
|
|
0
|
120
|
|
|
121 ;;;###autoload
|
|
|
122 (defvar vc-checkin-hook nil
|
|
|
123 "*List of functions called after a checkin is done. See `run-hooks'.")
|
|
|
124
|
|
30
|
125 ;;;###autoload
|
|
|
126 (defvar vc-before-checkin-hook nil
|
|
|
127 "*List of functions called before a checkin is done. See `run-hooks'.")
|
|
|
128
|
|
0
|
129 (defvar vc-make-buffer-writable-hook nil
|
|
|
130 "*List of functions called when a buffer is made writable. See `run-hooks.'
|
|
|
131 This hook is only used when the version control system is CVS. It
|
|
|
132 might be useful for sites who uses locking with CVS, or who uses link
|
|
|
133 farms to gold trees.")
|
|
|
134
|
|
|
135 ;; Header-insertion hair
|
|
|
136
|
|
|
137 (defvar vc-header-alist
|
|
|
138 '((SCCS "\%W\%") (RCS "\$Id\$") (CVS "\$Id\$"))
|
|
|
139 "*Header keywords to be inserted when `vc-insert-headers' is executed.")
|
|
|
140 (defvar vc-static-header-alist
|
|
|
141 '(("\\.c$" .
|
|
|
142 "\n#ifndef lint\nstatic char vcid[] = \"\%s\";\n#endif /* lint */\n"))
|
|
|
143 "*Associate static header string templates with file types. A \%s in the
|
|
|
144 template is replaced with the first string associated with the file's
|
|
|
145 version-control type in `vc-header-alist'.")
|
|
|
146
|
|
|
147 (defvar vc-comment-alist
|
|
|
148 '((nroff-mode ".\\\"" ""))
|
|
|
149 "*Special comment delimiters to be used in generating vc headers only.
|
|
|
150 Add an entry in this list if you need to override the normal comment-start
|
|
|
151 and comment-end variables. This will only be necessary if the mode language
|
|
|
152 is sensitive to blank lines.")
|
|
|
153
|
|
|
154 ;; Default is to be extra careful for super-user.
|
|
|
155 (defvar vc-checkout-carefully (= (user-uid) 0) ; #### - this prevents preloading!
|
|
|
156 "*Non-nil means be extra-careful in checkout.
|
|
|
157 Verify that the file really is not locked
|
|
|
158 and that its contents match what the master file says.")
|
|
|
159
|
|
|
160 ;; Variables the user doesn't need to know about.
|
|
|
161 (defvar vc-log-entry-mode nil)
|
|
|
162 (defvar vc-log-operation nil)
|
|
|
163 (defvar vc-log-after-operation-hook nil)
|
|
|
164 (defvar vc-checkout-writable-buffer-hook 'vc-checkout-writable-buffer)
|
|
|
165 ;; In a log entry buffer, this is a local variable
|
|
|
166 ;; that points to the buffer for which it was made
|
|
|
167 ;; (either a file, or a VC dired buffer).
|
|
|
168 (defvar vc-parent-buffer nil)
|
|
|
169 (defvar vc-parent-buffer-name nil)
|
|
|
170
|
|
|
171 (defvar vc-log-file)
|
|
|
172 (defvar vc-log-version)
|
|
|
173
|
|
|
174 (defconst vc-name-assoc-file "VC-names")
|
|
|
175
|
|
|
176 (defvar vc-dired-mode nil)
|
|
|
177 (make-variable-buffer-local 'vc-dired-mode)
|
|
|
178
|
|
|
179 (defvar vc-comment-ring nil)
|
|
|
180 (defvar vc-comment-ring-index nil)
|
|
|
181 (defvar vc-last-comment-match nil)
|
|
|
182
|
|
|
183 ;; File property caching
|
|
|
184
|
|
|
185 (defun vc-file-clearprops (file)
|
|
|
186 ;; clear all properties of a given file
|
|
|
187 (setplist (intern file vc-file-prop-obarray) nil))
|
|
|
188
|
|
|
189 (defun vc-clear-context ()
|
|
|
190 "Clear all cached file properties and the comment ring."
|
|
|
191 (interactive)
|
|
|
192 (fillarray vc-file-prop-obarray nil)
|
|
|
193 ;; Note: there is potential for minor lossage here if there is an open
|
|
|
194 ;; log buffer with a nonzero local value of vc-comment-ring-index.
|
|
|
195 (setq vc-comment-ring nil))
|
|
|
196
|
|
|
197 ;; Random helper functions
|
|
|
198
|
|
|
199 (defun vc-registration-error (file)
|
|
|
200 (if file
|
|
|
201 (error "File %s is not under version control" file)
|
|
|
202 (error "Buffer %s is not associated with a file" (buffer-name))))
|
|
|
203
|
|
|
204 (defvar vc-binary-assoc nil)
|
|
|
205
|
|
|
206 (defun vc-find-binary (name)
|
|
|
207 "Look for a command anywhere on the subprocess-command search path."
|
|
|
208 (or (cdr (assoc name vc-binary-assoc))
|
|
|
209 ;; XEmacs - use locate-file
|
|
|
210 (let ((full (locate-file name exec-path nil 1)))
|
|
|
211 (if full
|
|
|
212 (setq vc-binary-assoc (cons (cons name full) vc-binary-assoc)))
|
|
|
213 full)))
|
|
|
214
|
|
|
215 (defun vc-do-command (okstatus command file last &rest flags)
|
|
|
216 "Execute a version-control command, notifying user and checking for errors.
|
|
|
217 The command is successful if its exit status does not exceed OKSTATUS.
|
|
|
218 Output from COMMAND goes to buffer *vc*. The last argument of the command is
|
|
|
219 the master name of FILE if LAST is 'MASTER, or the workfile of FILE if LAST is
|
|
|
220 'WORKFILE; this is appended to an optional list of FLAGS."
|
|
|
221 (setq file (expand-file-name file))
|
|
|
222 (let ((camefrom (current-buffer))
|
|
|
223 (pwd (file-name-directory (expand-file-name file)))
|
|
|
224 (squeezed nil)
|
|
|
225 (vc-file (and file (vc-name file)))
|
|
|
226 status)
|
|
|
227 ;;; #### - don't know why this code was here...to beautify the echo message?
|
|
|
228 ;;; the version of code below doesn't break default-directory, but it
|
|
|
229 ;;; still might mess up CVS and RCS because they like to operate on
|
|
|
230 ;;; files in the current directory. --Stig
|
|
|
231 ;;;
|
|
|
232 ;;; (if (string-match (concat "^" (regexp-quote pwd)) file)
|
|
|
233 ;;; (setq file (substring file (match-end 0)))
|
|
|
234 ;;; (setq pwd (file-name-directory file)))
|
|
|
235 (if vc-command-messages
|
|
|
236 (message "Running %s on %s..." command file))
|
|
|
237 (set-buffer (get-buffer-create "*vc*"))
|
|
|
238 (setq default-directory pwd
|
|
|
239 file (file-name-nondirectory file))
|
|
|
240
|
|
|
241 (set (make-local-variable 'vc-parent-buffer) camefrom)
|
|
|
242 (set (make-local-variable 'vc-parent-buffer-name)
|
|
|
243 (concat " from " (buffer-name camefrom)))
|
|
|
244
|
|
|
245 (erase-buffer)
|
|
|
246
|
|
|
247 (mapcar
|
|
|
248 (function (lambda (s) (and s (setq squeezed (append squeezed (list s))))))
|
|
|
249 flags)
|
|
|
250 (if (and vc-file (eq last 'MASTER))
|
|
|
251 (setq squeezed (append squeezed (list vc-file))))
|
|
|
252 (if (eq last 'WORKFILE)
|
|
|
253 (setq squeezed (append squeezed (list file))))
|
|
|
254 (let ((exec-path (if vc-path (append vc-path exec-path) exec-path))
|
|
|
255 ;; Add vc-path to PATH for the execution of this command.
|
|
|
256 (process-environment (copy-sequence process-environment)))
|
|
|
257 (setenv "PATH" (mapconcat 'identity exec-path ":"))
|
|
|
258 (setq status (apply 'call-process command nil t nil squeezed)))
|
|
|
259 (goto-char (point-max))
|
|
|
260 (set-buffer-modified-p nil) ; XEmacs - fsf uses `not-modified'
|
|
|
261 (forward-line -1)
|
|
|
262 (if (or (not (integerp status)) (< okstatus status))
|
|
|
263 (progn
|
|
|
264 (pop-to-buffer "*vc*")
|
|
|
265 (goto-char (point-min))
|
|
|
266 (shrink-window-if-larger-than-buffer)
|
|
|
267 (error "Running %s...FAILED (%s)" command
|
|
|
268 (if (integerp status)
|
|
|
269 (format "status %d" status)
|
|
|
270 status))
|
|
|
271 )
|
|
|
272 (if vc-command-messages
|
|
|
273 (message "Running %s...OK" command))
|
|
|
274 )
|
|
|
275 (set-buffer camefrom)
|
|
|
276 status)
|
|
|
277 )
|
|
|
278
|
|
|
279 ;;; Save a bit of the text around POSN in the current buffer, to help
|
|
|
280 ;;; us find the corresponding position again later. This works even
|
|
|
281 ;;; if all markers are destroyed or corrupted.
|
|
|
282 (defun vc-position-context (posn)
|
|
|
283 (list posn
|
|
|
284 (buffer-size)
|
|
|
285 (buffer-substring posn
|
|
|
286 (min (point-max) (+ posn 100)))))
|
|
|
287
|
|
|
288 ;;; Return the position of CONTEXT in the current buffer, or nil if we
|
|
|
289 ;;; couldn't find it.
|
|
|
290 (defun vc-find-position-by-context (context)
|
|
|
291 (let ((context-string (nth 2 context)))
|
|
|
292 (if (equal "" context-string)
|
|
|
293 (point-max)
|
|
|
294 (save-excursion
|
|
|
295 (let ((diff (- (nth 1 context) (buffer-size))))
|
|
|
296 (if (< diff 0) (setq diff (- diff)))
|
|
|
297 (goto-char (nth 0 context))
|
|
|
298 (if (or (search-forward context-string nil t)
|
|
|
299 ;; Can't use search-backward since the match may continue
|
|
|
300 ;; after point.
|
|
|
301 (progn (goto-char (- (point) diff (length context-string)))
|
|
|
302 ;; goto-char doesn't signal an error at
|
|
|
303 ;; beginning of buffer like backward-char would
|
|
|
304 (search-forward context-string nil t)))
|
|
|
305 ;; to beginning of OSTRING
|
|
|
306 (- (point) (length context-string))))))))
|
|
|
307
|
|
|
308 (defun vc-revert-buffer1 (&optional arg no-confirm)
|
|
|
309 ;; Most of this was shamelessly lifted from Sebastian Kremer's rcs.el mode.
|
|
|
310 ;; Revert buffer, try to keep point and mark where user expects them in spite
|
|
|
311 ;; of changes because of expanded version-control key words.
|
|
|
312 ;; This is quite important since otherwise typeahead won't work as expected.
|
|
|
313 (interactive "P")
|
|
|
314 (widen)
|
|
|
315 (let ((point-context (vc-position-context (point)))
|
|
|
316 ;; Use mark-marker to avoid confusion in transient-mark-mode.
|
|
|
317 ;; XEmacs - mark-marker t
|
|
|
318 (mark-context (if (eq (marker-buffer (mark-marker t)) (current-buffer))
|
|
|
319 (vc-position-context (mark-marker t))))
|
|
|
320 ;; We may want to reparse the compilation buffer after revert
|
|
|
321 (reparse (and (boundp 'compilation-error-list) ;compile loaded
|
|
|
322 ;; Construct a list; each elt is nil or a buffer
|
|
|
323 ;; iff that buffer is a compilation output buffer
|
|
|
324 ;; that contains markers into the current buffer.
|
|
|
325 (save-excursion
|
|
|
326 (mapcar (function
|
|
|
327 (lambda (buffer)
|
|
|
328 (set-buffer buffer)
|
|
|
329 (let ((errors (or
|
|
|
330 compilation-old-error-list
|
|
|
331 compilation-error-list))
|
|
|
332 (buffer-error-marked-p nil))
|
|
|
333 (while (and (consp errors)
|
|
|
334 (not buffer-error-marked-p))
|
|
|
335 (and (markerp (cdr (car errors)))
|
|
|
336 (eq buffer
|
|
|
337 (marker-buffer
|
|
|
338 (cdr (car errors))))
|
|
|
339 (setq buffer-error-marked-p t))
|
|
|
340 (setq errors (cdr errors)))
|
|
|
341 (if buffer-error-marked-p buffer))))
|
|
|
342 (buffer-list))))))
|
|
|
343
|
|
|
344 ;; The FSF version intentionally runs font-lock here. That
|
|
|
345 ;; usually just leads to a correctly font-locked buffer being
|
|
|
346 ;; redone. #### We should detect the cases where the font-locking
|
|
|
347 ;; may be incorrect (such as on reverts). We know that it is fine
|
|
|
348 ;; during regular checkin and checkouts.
|
|
|
349
|
|
|
350 ;; the actual revisit
|
|
|
351 (revert-buffer arg no-confirm)
|
|
|
352
|
|
|
353 ;; Reparse affected compilation buffers.
|
|
|
354 (while reparse
|
|
|
355 (if (car reparse)
|
|
|
356 (save-excursion
|
|
|
357 (set-buffer (car reparse))
|
|
|
358 (let ((compilation-last-buffer (current-buffer)) ;select buffer
|
|
|
359 ;; Record the position in the compilation buffer of
|
|
|
360 ;; the last error next-error went to.
|
|
|
361 (error-pos (marker-position
|
|
|
362 (car (car-safe compilation-error-list)))))
|
|
|
363 ;; Reparse the error messages as far as they were parsed before.
|
|
|
364 (compile-reinitialize-errors '(4) compilation-parsing-end)
|
|
|
365 ;; Move the pointer up to find the error we were at before
|
|
|
366 ;; reparsing. Now next-error should properly go to the next one.
|
|
|
367 (while (and compilation-error-list
|
|
|
368 (/= error-pos (car (car compilation-error-list))))
|
|
|
369 (setq compilation-error-list (cdr compilation-error-list))))))
|
|
|
370 (setq reparse (cdr reparse)))
|
|
|
371
|
|
|
372 ;; Restore point and mark
|
|
|
373 (let ((new-point (vc-find-position-by-context point-context)))
|
|
|
374 (if new-point (goto-char new-point)))
|
|
|
375 (if mark-context
|
|
|
376 (let ((new-mark (vc-find-position-by-context mark-context)))
|
|
|
377 (if new-mark (set-mark new-mark))))))
|
|
|
378
|
|
|
379
|
|
|
380 (defun vc-buffer-sync (&optional not-urgent)
|
|
|
381 ;; Make sure the current buffer and its working file are in sync
|
|
|
382 ;; NOT-URGENT means it is ok to continue if the user says not to save.
|
|
|
383 (if (buffer-modified-p)
|
|
|
384 (if (or vc-suppress-confirm
|
|
|
385 (y-or-n-p (format "Buffer %s modified; save it? " (buffer-name))))
|
|
|
386 (save-buffer)
|
|
|
387 (if not-urgent
|
|
|
388 nil
|
|
|
389 (error "Aborted")))))
|
|
|
390
|
|
|
391 ;;;###autoload
|
|
|
392 (defun vc-file-status ()
|
|
|
393 "Display the current status of the file being visited.
|
|
|
394 Currently, this is only defined for CVS. The information provided in the
|
|
|
395 modeline is generally sufficient for RCS and SCCS."
|
|
|
396 ;; by Stig@hackvan.com
|
|
|
397 (interactive)
|
|
|
398 (vc-buffer-sync t)
|
|
|
399 (let ((type (vc-backend-deduce buffer-file-name))
|
|
|
400 (file buffer-file-name))
|
|
|
401 (cond ((null type)
|
|
|
402 (if buffer-file-name
|
|
|
403 (message "`%s' is not registered with a version control system."
|
|
|
404 buffer-file-name)
|
|
|
405 (ding)
|
|
|
406 (message "Buffer `%s' has no associated file."
|
|
|
407 (buffer-name (current-buffer)))))
|
|
|
408 ((eq 'CVS type)
|
|
|
409 (vc-do-command 0 "cvs" file 'WORKFILE "status" "-v")
|
|
|
410 (set-buffer "*vc*")
|
|
|
411 (set-buffer-modified-p nil)
|
|
|
412 ;; reparse the status information, since we have it handy...
|
|
|
413 (vc-parse-buffer '("Status: \\(.*\\)") file '(vc-cvs-status))
|
|
|
414 (goto-char (point-min))
|
|
|
415 (shrink-window-if-larger-than-buffer
|
|
|
416 (display-buffer (current-buffer))))
|
|
|
417 ((eq 'CC type)
|
|
|
418 (vc-do-command 0 "cleartool" file 'WORKFILE "describe")
|
|
|
419 (set-buffer "*vc*")
|
|
|
420 (set-buffer-modified-p nil)
|
|
|
421 (goto-char (point-min))
|
|
|
422 (shrink-window-if-larger-than-buffer
|
|
|
423 (display-buffer (current-buffer))))
|
|
|
424 (t
|
|
|
425 (ding)
|
|
|
426 (message "Operation not yet defined for RCS or SCCS.")))
|
|
|
427 ))
|
|
|
428
|
|
|
429 (defun vc-workfile-unchanged-p (file &optional want-differences-if-changed)
|
|
|
430 ;; Has the given workfile changed since last checkout?
|
|
|
431 (cond ((and (eq 'CVS (vc-backend-deduce file))
|
|
|
432 (not want-differences-if-changed))
|
|
|
433
|
|
|
434 (let ((status (vc-file-getprop file 'vc-cvs-status)))
|
|
|
435 ;; #### - should this have some kind of timeout? how often does
|
|
|
436 ;; this get called? possibly the cached information should be
|
|
|
437 ;; flushed out of hand. The only concern is the VC menu, which
|
|
|
438 ;; may indirectly call this function.
|
|
|
439 (or status ; #### - caching is error-prone
|
|
|
440 (setq status (car (vc-log-info "cvs" file 'WORKFILE '("status")
|
|
|
441 '("Status: \\(.*\\)")
|
|
|
442 '(vc-cvs-status)))))
|
|
|
443 (string= status "Up-to-date")))
|
|
|
444 (t
|
|
|
445 (let ((checkout-time (vc-file-getprop file 'vc-checkout-time))
|
|
|
446 (lastmod (nth 5 (file-attributes file)))
|
|
|
447 unchanged)
|
|
|
448 (or (equal checkout-time lastmod)
|
|
|
449 (and (or (not checkout-time) want-differences-if-changed)
|
|
|
450 (setq unchanged
|
|
|
451 (zerop (vc-backend-diff file nil nil
|
|
|
452 (not want-differences-if-changed))))
|
|
|
453 ;; 0 stands for an unknown time; it can't match any mod time.
|
|
|
454 (vc-file-setprop file 'vc-checkout-time (if unchanged lastmod 0))
|
|
|
455 unchanged))))))
|
|
|
456
|
|
|
457 (defun vc-next-action-on-file (file verbose &optional comment)
|
|
|
458 ;;; If comment is specified, it will be used as an admin or checkin comment.
|
|
|
459 (let ((vc-file (vc-name file))
|
|
|
460 (vc-type (vc-backend-deduce file))
|
|
|
461 owner version)
|
|
|
462 (cond
|
|
|
463
|
|
|
464 ;; if there is no master file corresponding, create one
|
|
|
465 ((not vc-file)
|
|
|
466 (vc-register verbose comment))
|
|
|
467
|
|
|
468 ;; if there is no lock on the file, assert one and get it
|
|
|
469 ((and (not (eq vc-type 'CVS)) ;There are no locks in CVS.
|
|
|
470 (not (setq owner (vc-locking-user file))))
|
|
|
471 (if (and vc-checkout-carefully
|
|
|
472 (not (vc-workfile-unchanged-p file t)))
|
|
|
473 (if (save-window-excursion
|
|
|
474 (pop-to-buffer "*vc*")
|
|
|
475 (goto-char (point-min))
|
|
|
476 (insert (format "Changes to %s since last lock:\n\n" file))
|
|
|
477 (not (beep))
|
|
|
478 (yes-or-no-p
|
|
|
479 "File has unlocked changes, claim lock retaining changes? "))
|
|
|
480 (progn (vc-backend-steal file)
|
|
|
481 (vc-mode-line file))
|
|
|
482 (if (not (yes-or-no-p "Revert to checked-in version, instead? "))
|
|
|
483 (error "Checkout aborted.")
|
|
|
484 (vc-revert-buffer1 t t)
|
|
|
485 (vc-checkout-writable-buffer file))
|
|
|
486 )
|
|
|
487 (vc-checkout-writable-buffer file)))
|
|
|
488
|
|
|
489 ;; a checked-out version exists, but the user may not own the lock
|
|
|
490 ((and (not (eq vc-type 'CVS)) ;There are no locks in CVS.
|
|
|
491 (not (string-equal owner (user-login-name))))
|
|
|
492 (if comment
|
|
|
493 (error "Sorry, you can't steal the lock on %s this way" file))
|
|
|
494 (vc-steal-lock
|
|
|
495 file
|
|
|
496 (and verbose (read-string "Version to steal: "))
|
|
|
497 owner))
|
|
|
498
|
|
|
499 ;; changes to the master file needs to be merged back into the
|
|
|
500 ;; working file
|
|
|
501 ((and (eq vc-type 'CVS)
|
|
|
502 ;; "0" means "added, but not yet committed"
|
|
|
503 (not (string= (vc-file-getprop file 'vc-your-latest-version) "0"))
|
|
|
504 (progn
|
|
|
505 (vc-fetch-properties file)
|
|
|
506 (not (string= (vc-file-getprop file 'vc-your-latest-version)
|
|
|
507 (vc-file-getprop file 'vc-latest-version)))))
|
|
|
508 (vc-buffer-sync)
|
|
|
509 (if (yes-or-no-p (format "%s is not up-to-date. Merge in changes now? "
|
|
|
510 (buffer-name)))
|
|
|
511 (progn
|
|
|
512 (if (and (buffer-modified-p)
|
|
|
513 (not (yes-or-no-p
|
|
|
514 (format
|
|
|
515 "Buffer %s modified; merge file on disc anyhow? "
|
|
|
516 (buffer-name)))))
|
|
|
517 (error "Merge aborted"))
|
|
|
518 (if (not (zerop (vc-backend-merge-news file)))
|
|
|
519 ;; Overlaps detected - what now? Should use some
|
|
|
520 ;; fancy RCS conflict resolving package, or maybe
|
|
|
521 ;; emerge, but for now, simply warn the user with a
|
|
|
522 ;; message.
|
|
|
523 (message "Conflicts detected!"))
|
|
|
524 (vc-resynch-window file t (not (buffer-modified-p))))
|
|
|
525
|
|
|
526 (error "%s needs update" (buffer-name))))
|
|
|
527
|
|
|
528 ((and buffer-read-only (eq vc-type 'CVS))
|
|
|
529 (toggle-read-only)
|
|
|
530 ;; Sites who make link farms to a read-only gold tree (or
|
|
|
531 ;; something similar) can use the hook below to break the
|
|
|
532 ;; sym-link.
|
|
|
533 (run-hooks 'vc-make-buffer-writable-hook))
|
|
|
534
|
|
|
535 ;; OK, user owns the lock on the file (or we are running CVS)
|
|
|
536 (t
|
|
|
537 (find-file file)
|
|
|
538
|
|
|
539 ;; give luser a chance to save before checking in.
|
|
|
540 (vc-buffer-sync)
|
|
|
541
|
|
|
542 ;; Revert if file is unchanged and buffer is too.
|
|
|
543 ;; If buffer is modified, that means the user just said no
|
|
|
544 ;; to saving it; in that case, don't revert,
|
|
|
545 ;; because the user might intend to save
|
|
|
546 ;; after finishing the log entry.
|
|
|
547 (if (and (vc-workfile-unchanged-p file)
|
|
|
548 (not (buffer-modified-p)))
|
|
|
549 (progn
|
|
|
550 (if (eq vc-type 'CVS)
|
|
|
551 (message "No changes to %s" file)
|
|
|
552
|
|
|
553 (vc-backend-revert file)
|
|
|
554 ;; DO NOT revert the file without asking the user!
|
|
|
555 (vc-resynch-window file t nil)))
|
|
|
556
|
|
|
557 ;; user may want to set nonstandard parameters
|
|
|
558 (if verbose
|
|
|
559 (setq version (read-string "New version level: ")))
|
|
|
560
|
|
|
561 ;; OK, let's do the checkin
|
|
|
562 (vc-checkin file version comment)
|
|
|
563 )))))
|
|
|
564
|
|
|
565 (defun vc-next-action-dired (file rev comment)
|
|
|
566 ;; We've accepted a log comment, now do a vc-next-action using it on all
|
|
|
567 ;; marked files.
|
|
|
568 (set-buffer vc-parent-buffer)
|
|
|
569 (dired-map-over-marks
|
|
|
570 (save-window-excursion
|
|
|
571 (let ((file (dired-get-filename)))
|
|
|
572 (message "Processing %s..." file)
|
|
|
573 (vc-next-action-on-file file nil comment)
|
|
|
574 (message "Processing %s...done" file)))
|
|
|
575 nil t)
|
|
|
576 )
|
|
|
577
|
|
|
578 ;; Here's the major entry point.
|
|
|
579
|
|
|
580 ;;;###autoload
|
|
|
581 (defun vc-next-action (verbose)
|
|
|
582 "Do the next logical checkin or checkout operation on the current file.
|
|
|
583
|
|
|
584 For RCS and SCCS files:
|
|
|
585 If the file is not already registered, this registers it for version
|
|
|
586 control and then retrieves a writable, locked copy for editing.
|
|
|
587 If the file is registered and not locked by anyone, this checks out
|
|
|
588 a writable and locked file ready for editing.
|
|
|
589 If the file is checked out and locked by the calling user, this
|
|
|
590 first checks to see if the file has changed since checkout. If not,
|
|
|
591 it performs a revert.
|
|
|
592 If the file has been changed, this pops up a buffer for entry
|
|
|
593 of a log message; when the message has been entered, it checks in the
|
|
|
594 resulting changes along with the log message as change commentary. If
|
|
|
595 the variable `vc-keep-workfiles' is non-nil (which is its default), a
|
|
|
596 read-only copy of the changed file is left in place afterwards.
|
|
|
597 If the file is registered and locked by someone else, you are given
|
|
|
598 the option to steal the lock.
|
|
|
599
|
|
|
600 For CVS files:
|
|
|
601 If the file is not already registered, this registers it for version
|
|
|
602 control. This does a \"cvs add\", but no \"cvs commit\".
|
|
|
603 If the file is added but not committed, it is committed.
|
|
|
604 If the file has not been changed, neither in your working area or
|
|
|
605 in the repository, a message is printed and nothing is done.
|
|
|
606 If your working file is changed, but the repository file is
|
|
|
607 unchanged, this pops up a buffer for entry of a log message; when the
|
|
|
608 message has been entered, it checks in the resulting changes along
|
|
|
609 with the logmessage as change commentary. A writable file is retained.
|
|
|
610 If the repository file is changed, you are asked if you want to
|
|
|
611 merge in the changes into your working copy.
|
|
|
612
|
|
|
613 The following is true regardless of which version control system you
|
|
|
614 are using:
|
|
|
615
|
|
|
616 If you call this from within a VC dired buffer with no files marked,
|
|
|
617 it will operate on the file in the current line.
|
|
|
618 If you call this from within a VC dired buffer, and one or more
|
|
|
619 files are marked, it will accept a log message and then operate on
|
|
|
620 each one. The log message will be used as a comment for any register
|
|
|
621 or checkin operations, but ignored when doing checkouts. Attempted
|
|
|
622 lock steals will raise an error.
|
|
|
623
|
|
|
624 For checkin, a prefix argument lets you specify the version number to use."
|
|
|
625 (interactive "P")
|
|
|
626 (catch 'nogo
|
|
|
627 (if vc-dired-mode
|
|
|
628 (let ((files (dired-get-marked-files)))
|
|
|
629 (if (= (length files) 1)
|
|
|
630 (find-file-other-window (car files))
|
|
|
631 (vc-start-entry nil nil nil
|
|
|
632 "Enter a change comment for the marked files."
|
|
|
633 'vc-next-action-dired)
|
|
|
634 (throw 'nogo nil))))
|
|
|
635 (while vc-parent-buffer
|
|
|
636 (pop-to-buffer vc-parent-buffer))
|
|
|
637 (if buffer-file-name
|
|
|
638 (vc-next-action-on-file buffer-file-name verbose)
|
|
|
639 (vc-registration-error nil))))
|
|
|
640
|
|
|
641 ;;; These functions help the vc-next-action entry point
|
|
|
642
|
|
|
643 (defun vc-checkout-writable-buffer (&optional file)
|
|
|
644 "Retrieve a writable copy of the latest version of the current buffer's file."
|
|
|
645 (vc-checkout (or file (buffer-file-name)) t)
|
|
|
646 )
|
|
|
647
|
|
|
648 ;;;###autoload
|
|
|
649 (defun vc-register (&optional override comment)
|
|
|
650 "Register the current file into your version-control system."
|
|
|
651 (interactive "P")
|
|
|
652 (let ((master (vc-name buffer-file-name)))
|
|
|
653 (and master (file-exists-p master)
|
|
|
654 (error "This file is already registered"))
|
|
|
655 (and master
|
|
|
656 (not (y-or-n-p "Previous master file has vanished. Make a new one? "))
|
|
|
657 (error "This file is already registered")))
|
|
|
658 ;; Watch out for new buffers of size 0: the corresponding file
|
|
|
659 ;; does not exist yet, even though buffer-modified-p is nil.
|
|
|
660 (if (and (not (buffer-modified-p))
|
|
|
661 (zerop (buffer-size))
|
|
|
662 (not (file-exists-p buffer-file-name)))
|
|
|
663 (set-buffer-modified-p t))
|
|
|
664 (vc-buffer-sync)
|
|
|
665 (vc-admin
|
|
|
666 buffer-file-name
|
|
|
667 (and override
|
|
|
668 (read-string
|
|
|
669 (format "Initial version level for %s: " buffer-file-name))))
|
|
|
670 )
|
|
|
671
|
|
|
672 (defun vc-resynch-window (file &optional keep noquery)
|
|
|
673 ;; If the given file is in the current buffer,
|
|
|
674 ;; either revert on it so we see expanded keyworks,
|
|
|
675 ;; or unvisit it (depending on vc-keep-workfiles)
|
|
|
676 ;; NOQUERY if non-nil inhibits confirmation for reverting.
|
|
|
677 ;; NOQUERY should be t *only* if it is known the only difference
|
|
|
678 ;; between the buffer and the file is due to RCS rather than user editing!
|
|
|
679 (and (string= buffer-file-name file)
|
|
|
680 (if keep
|
|
|
681 (progn
|
|
|
682 (vc-revert-buffer1 t noquery)
|
|
|
683 (vc-mode-line buffer-file-name))
|
|
|
684 (progn
|
|
|
685 (delete-window)
|
|
|
686 (kill-buffer (current-buffer))))))
|
|
|
687
|
|
30
|
688 (defun vc-start-entry (file rev comment msg action &optional after-hook before-hook)
|
|
0
|
689 ;; Accept a comment for an operation on FILE revision REV. If COMMENT
|
|
|
690 ;; is nil, pop up a VC-log buffer, emit MSG, and set the
|
|
|
691 ;; action on close to ACTION; otherwise, do action immediately.
|
|
|
692 ;; Remember the file's buffer in vc-parent-buffer (current one if no file).
|
|
|
693 ;; AFTER-HOOK specifies the local value for vc-log-operation-hook.
|
|
30
|
694 ;; BEFORE-HOOK specifies a hook to run before even asking for the
|
|
|
695 ;; checkin comments.
|
|
0
|
696 (let ((parent (if file (find-file-noselect file) (current-buffer))))
|
|
30
|
697 (when before-hook
|
|
|
698 (save-excursion
|
|
|
699 (set-buffer parent)
|
|
|
700 (run-hooks before-hook)))
|
|
0
|
701 (if comment
|
|
|
702 (set-buffer (get-buffer-create "*VC-log*"))
|
|
|
703 (pop-to-buffer (get-buffer-create "*VC-log*")))
|
|
|
704 (set (make-local-variable 'vc-parent-buffer) parent)
|
|
|
705 (set (make-local-variable 'vc-parent-buffer-name)
|
|
|
706 (concat " from " (buffer-name vc-parent-buffer)))
|
|
|
707 (vc-mode-line (or file " (no file)"))
|
|
|
708 (vc-log-mode)
|
|
|
709 (make-local-variable 'vc-log-after-operation-hook)
|
|
|
710 (if after-hook
|
|
|
711 (setq vc-log-after-operation-hook after-hook))
|
|
|
712 (setq vc-log-operation action)
|
|
|
713 (setq vc-log-file file)
|
|
|
714 (setq vc-log-version rev)
|
|
|
715 (if comment
|
|
|
716 (progn
|
|
|
717 (erase-buffer)
|
|
|
718 (if (eq comment t)
|
|
|
719 (vc-finish-logentry t)
|
|
|
720 (insert comment)
|
|
|
721 (vc-finish-logentry nil)))
|
|
|
722 (message "%s Type C-c C-c when done." msg))))
|
|
|
723
|
|
|
724 (defun vc-admin (file rev &optional comment)
|
|
|
725 "Check a file into your version-control system.
|
|
|
726 FILE is the unmodified name of the file. REV should be the base version
|
|
|
727 level to check it in under. COMMENT, if specified, is the checkin comment."
|
|
|
728 (vc-start-entry file rev
|
|
|
729 (or comment (not vc-initial-comment))
|
|
|
730 "Enter initial comment." 'vc-backend-admin
|
|
30
|
731 nil 'vc-before-checkin-hook))
|
|
0
|
732
|
|
|
733 (defun vc-checkout (file &optional writable)
|
|
|
734 "Retrieve a copy of the latest version of the given file."
|
|
|
735 ;; XEmacs - ftp is suppressed by the check for a filename handler in
|
|
|
736 ;; vc-registered, so this is needless surplussage
|
|
|
737 ;; If ftp is on this system and the name matches the ange-ftp format
|
|
|
738 ;; for a remote file, the user is trying something that won't work.
|
|
|
739 ;; (if (and (string-match "^/[^/:]+:" file) (vc-find-binary "ftp"))
|
|
|
740 ;; (error "Sorry, you can't check out files over FTP"))
|
|
|
741 (vc-backend-checkout file writable)
|
|
|
742 (if (string-equal file buffer-file-name)
|
|
|
743 (vc-resynch-window file t t))
|
|
|
744 )
|
|
|
745
|
|
|
746 (defun vc-steal-lock (file rev &optional owner)
|
|
|
747 "Steal the lock on the current workfile."
|
|
|
748 (let (file-description)
|
|
|
749 (if (not owner)
|
|
|
750 (setq owner (vc-locking-user file)))
|
|
|
751 (if rev
|
|
|
752 (setq file-description (format "%s:%s" file rev))
|
|
|
753 (setq file-description file))
|
|
|
754 (if (not (y-or-n-p (format "Take the lock on %s from %s? "
|
|
|
755 file-description owner)))
|
|
|
756 (error "Steal cancelled"))
|
|
|
757 (pop-to-buffer (get-buffer-create "*VC-mail*"))
|
|
|
758 (setq default-directory (expand-file-name "~/"))
|
|
|
759 (auto-save-mode auto-save-default)
|
|
|
760 (mail-mode)
|
|
|
761 (erase-buffer)
|
|
|
762 (mail-setup owner (format "Stolen lock on %s" file-description) nil nil nil
|
|
|
763 (list (list 'vc-finish-steal file rev)))
|
|
|
764 (goto-char (point-max))
|
|
|
765 (insert
|
|
|
766 (format "I stole the lock on %s, " file-description)
|
|
|
767 (current-time-string)
|
|
|
768 ".\n")
|
|
|
769 (message "Please explain why you stole the lock. Type C-c C-c when done.")))
|
|
|
770
|
|
|
771 ;; This is called when the notification has been sent.
|
|
|
772 (defun vc-finish-steal (file version)
|
|
|
773 (vc-backend-steal file version)
|
|
|
774 (if (get-file-buffer file)
|
|
|
775 (save-excursion
|
|
|
776 (set-buffer (get-file-buffer file))
|
|
|
777 (vc-resynch-window file t t))))
|
|
|
778
|
|
|
779 (defun vc-checkin (file &optional rev comment)
|
|
|
780 "Check in the file specified by FILE.
|
|
|
781 The optional argument REV may be a string specifying the new version level
|
|
|
782 \(if nil increment the current level). The file is either retained with write
|
|
|
783 permissions zeroed, or deleted (according to the value of `vc-keep-workfiles').
|
|
|
784 If the back-end is CVS, a writable workfile is always kept.
|
|
|
785 COMMENT is a comment string; if omitted, a buffer is
|
|
|
786 popped up to accept a comment."
|
|
|
787 (vc-start-entry file rev comment
|
|
|
788 "Enter a change comment." 'vc-backend-checkin
|
|
30
|
789 'vc-checkin-hook 'vc-before-checkin-hook))
|
|
0
|
790
|
|
|
791 ;;; Here is a checkin hook that may prove useful to sites using the
|
|
|
792 ;;; ChangeLog facility supported by Emacs.
|
|
|
793 (defun vc-comment-to-change-log (&optional whoami file-name)
|
|
|
794 "Enter last VC comment into change log file for current buffer's file.
|
|
|
795 Optional arg (interactive prefix) non-nil means prompt for user name and site.
|
|
|
796 Second arg is file name of change log. \
|
|
|
797 If nil, uses `change-log-default-name'."
|
|
|
798 (interactive (if current-prefix-arg
|
|
|
799 (list current-prefix-arg
|
|
|
800 (prompt-for-change-log-name))))
|
|
|
801 ;; Make sure the defvar for add-log-current-defun-function has been executed
|
|
|
802 ;; before binding it.
|
|
|
803 (require 'add-log)
|
|
|
804 (let ( ; Extract the comment first so we get any error before doing anything.
|
|
|
805 (comment (ring-ref vc-comment-ring 0))
|
|
|
806 ;; Don't let add-change-log-entry insert a defun name.
|
|
|
807 (add-log-current-defun-function 'ignore)
|
|
|
808 end)
|
|
|
809 ;; Call add-log to do half the work.
|
|
|
810 (add-change-log-entry whoami file-name t t)
|
|
|
811 ;; Insert the VC comment, leaving point before it.
|
|
|
812 (setq end (save-excursion (insert comment) (point-marker)))
|
|
|
813 (if (looking-at "\\s *\\s(")
|
|
|
814 ;; It starts with an open-paren, as in "(foo): Frobbed."
|
|
|
815 ;; So remove the ": " add-log inserted.
|
|
|
816 (delete-char -2))
|
|
|
817 ;; Canonicalize the white space between the file name and comment.
|
|
|
818 (just-one-space)
|
|
|
819 ;; Indent rest of the text the same way add-log indented the first line.
|
|
|
820 (let ((indentation (current-indentation)))
|
|
|
821 (save-excursion
|
|
|
822 (while (< (point) end)
|
|
|
823 (forward-line 1)
|
|
|
824 (indent-to indentation))
|
|
|
825 (setq end (point))))
|
|
|
826 ;; Fill the inserted text, preserving open-parens at bol.
|
|
|
827 (let ((paragraph-separate (concat paragraph-separate "\\|^\\s *\\s("))
|
|
|
828 (paragraph-start (concat paragraph-start "\\|^\\s *\\s(")))
|
|
|
829 (beginning-of-line)
|
|
|
830 (fill-region (point) end))
|
|
|
831 ;; Canonicalize the white space at the end of the entry so it is
|
|
|
832 ;; separated from the next entry by a single blank line.
|
|
|
833 (skip-syntax-forward " " end)
|
|
|
834 (delete-char (- (skip-syntax-backward " ")))
|
|
|
835 (or (eobp) (looking-at "\n\n")
|
|
|
836 (insert "\n"))))
|
|
|
837
|
|
|
838
|
|
|
839 (defun vc-finish-logentry (&optional nocomment)
|
|
|
840 "Complete the operation implied by the current log entry."
|
|
|
841 (interactive)
|
|
|
842 ;; Check and record the comment, if any.
|
|
|
843 (if (not nocomment)
|
|
|
844 (progn
|
|
|
845 (goto-char (point-max))
|
|
|
846 (if (not (bolp))
|
|
|
847 (newline))
|
|
|
848 ;; Comment too long?
|
|
|
849 (vc-backend-logentry-check vc-log-file)
|
|
|
850 ;; Record the comment in the comment ring
|
|
|
851 (if (null vc-comment-ring)
|
|
|
852 (setq vc-comment-ring (make-ring vc-maximum-comment-ring-size)))
|
|
|
853 (ring-insert vc-comment-ring (buffer-string))
|
|
|
854 ))
|
|
|
855 ;; Sync parent buffer in case the user modified it while editing the comment.
|
|
|
856 ;; But not if it is a vc-dired buffer.
|
|
|
857 (save-excursion
|
|
|
858 (set-buffer vc-parent-buffer)
|
|
|
859 (or vc-dired-mode
|
|
|
860 (vc-buffer-sync)))
|
|
|
861 ;; OK, do it to it
|
|
|
862 (if vc-log-operation
|
|
|
863 (save-excursion
|
|
|
864 (funcall vc-log-operation
|
|
|
865 vc-log-file
|
|
|
866 vc-log-version
|
|
|
867 (buffer-string)))
|
|
|
868 (error "No log operation is pending"))
|
|
|
869 ;; save the vc-log-after-operation-hook of log buffer
|
|
|
870 (let ((after-hook vc-log-after-operation-hook))
|
|
|
871 ;; Return to "parent" buffer of this checkin and remove checkin window
|
|
|
872 (pop-to-buffer vc-parent-buffer)
|
|
|
873 (let ((logbuf (get-buffer "*VC-log*")))
|
|
|
874 (delete-windows-on logbuf)
|
|
|
875 (kill-buffer logbuf))
|
|
|
876 ;; Now make sure we see the expanded headers
|
|
|
877 (if buffer-file-name
|
|
|
878 (vc-resynch-window buffer-file-name vc-keep-workfiles t))
|
|
|
879 (run-hooks after-hook)))
|
|
|
880
|
|
|
881 ;; Code for access to the comment ring
|
|
|
882
|
|
|
883 (defun vc-previous-comment (arg)
|
|
|
884 "Cycle backwards through comment history."
|
|
|
885 (interactive "*p")
|
|
|
886 (let ((len (ring-length vc-comment-ring)))
|
|
|
887 (cond ((or (not len) (<= len 0)) ; XEmacs change from Barry Warsaw
|
|
|
888 (message "Empty comment ring")
|
|
|
889 (ding))
|
|
|
890 (t
|
|
|
891 (erase-buffer)
|
|
|
892 ;; Initialize the index on the first use of this command
|
|
|
893 ;; so that the first M-p gets index 0, and the first M-n gets
|
|
|
894 ;; index -1.
|
|
|
895 (if (null vc-comment-ring-index)
|
|
|
896 (setq vc-comment-ring-index
|
|
|
897 (if (> arg 0) -1
|
|
|
898 (if (< arg 0) 1 0))))
|
|
|
899 (setq vc-comment-ring-index
|
|
|
900 (mod (+ vc-comment-ring-index arg) len))
|
|
|
901 (message "%d" (1+ vc-comment-ring-index))
|
|
|
902 (insert (ring-ref vc-comment-ring vc-comment-ring-index))))))
|
|
|
903
|
|
|
904 (defun vc-next-comment (arg)
|
|
|
905 "Cycle forwards through comment history."
|
|
|
906 (interactive "*p")
|
|
|
907 (vc-previous-comment (- arg)))
|
|
|
908
|
|
|
909 (defun vc-comment-search-reverse (str)
|
|
|
910 "Searches backwards through comment history for substring match."
|
|
|
911 (interactive "sComment substring: ")
|
|
|
912 (if (string= str "")
|
|
|
913 (setq str vc-last-comment-match)
|
|
|
914 (setq vc-last-comment-match str))
|
|
|
915 (if (null vc-comment-ring-index)
|
|
|
916 (setq vc-comment-ring-index -1))
|
|
|
917 (let ((str (regexp-quote str))
|
|
|
918 (len (ring-length vc-comment-ring))
|
|
|
919 (n (1+ vc-comment-ring-index)))
|
|
|
920 (while (and (< n len) (not (string-match str (ring-ref vc-comment-ring n))))
|
|
|
921 (setq n (+ n 1)))
|
|
|
922 (cond ((< n len)
|
|
|
923 (vc-previous-comment (- n vc-comment-ring-index)))
|
|
|
924 (t (error "Not found")))))
|
|
|
925
|
|
|
926 (defun vc-comment-search-forward (str)
|
|
|
927 "Searches forwards through comment history for substring match."
|
|
|
928 (interactive "sComment substring: ")
|
|
|
929 (if (string= str "")
|
|
|
930 (setq str vc-last-comment-match)
|
|
|
931 (setq vc-last-comment-match str))
|
|
|
932 (if (null vc-comment-ring-index)
|
|
|
933 (setq vc-comment-ring-index 0))
|
|
|
934 (let ((str (regexp-quote str))
|
|
|
935 (n vc-comment-ring-index))
|
|
|
936 (while (and (>= n 0) (not (string-match str (ring-ref vc-comment-ring n))))
|
|
|
937 (setq n (- n 1)))
|
|
|
938 (cond ((>= n 0)
|
|
|
939 (vc-next-comment (- n vc-comment-ring-index)))
|
|
|
940 (t (error "Not found")))))
|
|
|
941
|
|
|
942 ;; Additional entry points for examining version histories
|
|
|
943
|
|
|
944 ;;;###autoload
|
|
|
945 (defun vc-diff (historic &optional not-urgent)
|
|
|
946 "Display diffs between file versions.
|
|
|
947 Normally this compares the current file and buffer with the most recent
|
|
|
948 checked in version of that file. This uses no arguments.
|
|
|
949 With a prefix argument, it reads the file name to use
|
|
|
950 and two version designators specifying which versions to compare."
|
|
|
951 (interactive "P")
|
|
|
952 (if vc-dired-mode
|
|
|
953 (set-buffer (find-file-noselect (dired-get-filename))))
|
|
|
954 (while vc-parent-buffer
|
|
|
955 (pop-to-buffer vc-parent-buffer))
|
|
|
956 (if historic
|
|
|
957 (call-interactively 'vc-version-diff)
|
|
|
958 (if (or (null buffer-file-name) (null (vc-name buffer-file-name)))
|
|
|
959 (error
|
|
|
960 "There is no version-control master associated with this buffer"))
|
|
|
961 (let ((file buffer-file-name)
|
|
|
962 unchanged)
|
|
|
963 (or (and file (vc-name file))
|
|
|
964 (vc-registration-error file))
|
|
|
965 (vc-buffer-sync not-urgent)
|
|
|
966 (setq unchanged (vc-workfile-unchanged-p buffer-file-name))
|
|
|
967 (if unchanged
|
|
|
968 (message "No changes to %s since latest version." file)
|
|
|
969 (vc-backend-diff file)
|
|
|
970 ;; Ideally, we'd like at this point to parse the diff so that
|
|
|
971 ;; the buffer effectively goes into compilation mode and we
|
|
|
972 ;; can visit the old and new change locations via next-error.
|
|
|
973 ;; Unfortunately, this is just too painful to do. The basic
|
|
|
974 ;; problem is that the `old' file doesn't exist to be
|
|
|
975 ;; visited. This plays hell with numerous assumptions in
|
|
|
976 ;; the diff.el and compile.el machinery.
|
|
|
977 (pop-to-buffer "*vc*")
|
|
|
978 (setq default-directory (file-name-directory file))
|
|
|
979 (if (= 0 (buffer-size))
|
|
|
980 (progn
|
|
|
981 (setq unchanged t)
|
|
|
982 (message "No changes to %s since latest version." file))
|
|
|
983 (goto-char (point-min))
|
|
|
984 (shrink-window-if-larger-than-buffer)))
|
|
|
985 (not unchanged))))
|
|
|
986
|
|
|
987 ;;;###autoload
|
|
|
988 (defun vc-version-diff (file rel1 rel2)
|
|
|
989 "For FILE, report diffs between two stored versions REL1 and REL2 of it.
|
|
|
990 If FILE is a directory, generate diffs between versions for all registered
|
|
|
991 files in or below it."
|
|
|
992 ;; XEmacs - better prompt
|
|
|
993 (interactive "FFile or directory to diff: \nsOlder version (default is repository): \nsNewer version (default is workfile): ")
|
|
|
994 (if (string-equal rel1 "") (setq rel1 nil))
|
|
|
995 (if (string-equal rel2 "") (setq rel2 nil))
|
|
|
996 (if (file-directory-p file)
|
|
|
997 (let ((camefrom (current-buffer)))
|
|
|
998 (set-buffer (get-buffer-create "*vc-status*"))
|
|
|
999 (set (make-local-variable 'vc-parent-buffer) camefrom)
|
|
|
1000 (set (make-local-variable 'vc-parent-buffer-name)
|
|
|
1001 (concat " from " (buffer-name camefrom)))
|
|
|
1002 (erase-buffer)
|
|
|
1003 (insert "Diffs between "
|
|
|
1004 (or rel1 "last version checked in")
|
|
|
1005 " and "
|
|
|
1006 (or rel2 "current workfile(s)")
|
|
|
1007 ":\n\n")
|
|
|
1008 (set-buffer (get-buffer-create "*vc*"))
|
|
|
1009 (cd file)
|
|
|
1010 (vc-file-tree-walk
|
|
|
1011 (function (lambda (f)
|
|
|
1012 (message "Looking at %s" f)
|
|
|
1013 (and
|
|
|
1014 (not (file-directory-p f))
|
|
|
1015 (vc-registered f)
|
|
|
1016 (vc-backend-diff f rel1 rel2)
|
|
|
1017 (append-to-buffer "*vc-status*" (point-min) (point-max)))
|
|
|
1018 )))
|
|
|
1019 (pop-to-buffer "*vc-status*")
|
|
|
1020 (insert "\nEnd of diffs.\n")
|
|
|
1021 (goto-char (point-min))
|
|
|
1022 (set-buffer-modified-p nil)
|
|
|
1023 )
|
|
|
1024 (if (zerop (vc-backend-diff file rel1 rel2))
|
|
|
1025 (message "No changes to %s between %s and %s." file rel1 rel2)
|
|
|
1026 (pop-to-buffer "*vc*"))))
|
|
|
1027
|
|
|
1028 ;;;###autoload
|
|
|
1029 (defun vc-version-other-window (rev)
|
|
|
1030 "Visit version REV of the current buffer in another window.
|
|
|
1031 If the current buffer is named `F', the version is named `F.~REV~'.
|
|
|
1032 If `F.~REV~' already exists, it is used instead of being re-created."
|
|
|
1033 (interactive "sVersion to visit (default is latest version): ")
|
|
|
1034 (if vc-dired-mode
|
|
|
1035 (set-buffer (find-file-noselect (dired-get-filename))))
|
|
|
1036 (while vc-parent-buffer
|
|
|
1037 (pop-to-buffer vc-parent-buffer))
|
|
|
1038 (if (and buffer-file-name (vc-name buffer-file-name))
|
|
|
1039 (let* ((version (if (string-equal rev "")
|
|
|
1040 (vc-latest-version buffer-file-name)
|
|
|
1041 rev))
|
|
|
1042 (filename (concat buffer-file-name ".~" version "~")))
|
|
|
1043 (or (file-exists-p filename)
|
|
|
1044 (vc-backend-checkout buffer-file-name nil version filename))
|
|
|
1045 (find-file-other-window filename))
|
|
|
1046 (vc-registration-error buffer-file-name)))
|
|
|
1047
|
|
|
1048 ;; Header-insertion code
|
|
|
1049
|
|
|
1050 ;;;###autoload
|
|
|
1051 (defun vc-insert-headers ()
|
|
|
1052 "Insert headers in a file for use with your version-control system.
|
|
|
1053 Headers desired are inserted at the start of the buffer, and are pulled from
|
|
|
1054 the variable `vc-header-alist'."
|
|
|
1055 (interactive)
|
|
|
1056 (if vc-dired-mode
|
|
|
1057 (find-file-other-window (dired-get-filename)))
|
|
|
1058 (while vc-parent-buffer
|
|
|
1059 (pop-to-buffer vc-parent-buffer))
|
|
|
1060 (save-excursion
|
|
|
1061 (save-restriction
|
|
|
1062 (widen)
|
|
|
1063 (if (or (not (vc-check-headers))
|
|
|
1064 (y-or-n-p "Version headers already exist. Insert another set? "))
|
|
|
1065 (progn
|
|
|
1066 (let* ((delims (cdr (assq major-mode vc-comment-alist)))
|
|
|
1067 (comment-start-vc (or (car delims) comment-start "#"))
|
|
|
1068 (comment-end-vc (or (car (cdr delims)) comment-end ""))
|
|
|
1069 (hdstrings (cdr (assoc (vc-backend-deduce buffer-file-name)
|
|
|
1070 vc-header-alist))))
|
|
|
1071 (mapcar #'(lambda (s)
|
|
|
1072 (insert comment-start-vc "\t" s "\t"
|
|
|
1073 comment-end-vc "\n"))
|
|
|
1074 hdstrings)
|
|
|
1075 (if vc-static-header-alist
|
|
|
1076 (mapcar #'(lambda (f)
|
|
|
1077 (if (and buffer-file-name
|
|
|
1078 (string-match (car f) buffer-file-name))
|
|
|
1079 (insert (format (cdr f) (car hdstrings)))))
|
|
|
1080 vc-static-header-alist))
|
|
|
1081 )
|
|
|
1082 )))))
|
|
|
1083
|
|
|
1084 ;; The VC directory submode. Coopt Dired for this.
|
|
|
1085 ;; All VC commands get mapped into logical equivalents.
|
|
|
1086
|
|
|
1087 ;; XEmacs
|
|
|
1088 (defvar vc-dired-prefix-map (let ((map (make-sparse-keymap)))
|
|
|
1089 (set-keymap-name map 'vc-dired-prefix-map)
|
|
|
1090 (define-key map "\C-xv" vc-prefix-map)
|
|
|
1091 map))
|
|
|
1092
|
|
|
1093 (or (not (boundp 'minor-mode-map-alist))
|
|
|
1094 (assq 'vc-dired-mode minor-mode-map-alist)
|
|
|
1095 (setq minor-mode-map-alist
|
|
|
1096 (cons (cons 'vc-dired-mode vc-dired-prefix-map)
|
|
|
1097 minor-mode-map-alist)))
|
|
|
1098
|
|
|
1099 (defun vc-dired-mode ()
|
|
|
1100 "The augmented Dired minor mode used in VC directory buffers.
|
|
|
1101 All Dired commands operate normally. Users currently locking listed files
|
|
|
1102 are listed in place of the file's owner and group.
|
|
|
1103 Keystrokes bound to VC commands will execute as though they had been called
|
|
|
1104 on a buffer attached to the file named in the current Dired buffer line."
|
|
|
1105 (setq vc-dired-mode t)
|
|
|
1106 (setq vc-mode " under VC"))
|
|
|
1107
|
|
|
1108 (defun vc-dired-reformat-line (x)
|
|
|
1109 ;; Hack a directory-listing line, plugging in locking-user info in
|
|
|
1110 ;; place of the user and group info. Should have the beneficial
|
|
|
1111 ;; side-effect of shortening the listing line. Each call starts with
|
|
|
1112 ;; point immediately following the dired mark area on the line to be
|
|
|
1113 ;; hacked.
|
|
|
1114 ;;
|
|
|
1115 ;; Simplest possible one:
|
|
|
1116 ;; (insert (concat x "\t")))
|
|
|
1117 ;;
|
|
|
1118 ;; This code, like dired, assumes UNIX -l format.
|
|
|
1119 (forward-word 1) ; skip over any extra field due to -ibs options
|
|
|
1120 (cond ((numberp x) ; This hack is used by the CVS code. See vc-locking-user.
|
|
|
1121 (cond
|
|
|
1122 ((re-search-forward "\\([0-9]+ \\)\\([^ ]+\\)\\( .*\\)" nil 0)
|
|
|
1123 (save-excursion
|
|
|
1124 (goto-char (match-beginning 2))
|
|
|
1125 (insert "(")
|
|
|
1126 (goto-char (1+ (match-end 2)))
|
|
|
1127 (insert ")")
|
|
|
1128 (delete-char (- 17 (- (match-end 2) (match-beginning 2))))
|
|
|
1129 (insert (substring " " 0
|
|
|
1130 (- 7 (- (match-end 2) (match-beginning 2)))))))))
|
|
|
1131 (t
|
|
|
1132 (if x (setq x (concat "(" x ")")))
|
|
|
1133 (if (re-search-forward "\\([0-9]+ \\).................\\( .*\\)" nil 0)
|
|
|
1134 (let ((rep (substring (concat x " ") 0 9)))
|
|
|
1135 (replace-match (concat "\\1" rep "\\2") t)))
|
|
|
1136 )))
|
|
|
1137
|
|
|
1138 ;;;###autoload
|
|
|
1139 (defun vc-directory (dir verbose &optional nested)
|
|
|
1140 "Show version-control status of all files in the directory DIR.
|
|
|
1141 If the second argument VERBOSE is non-nil, show all files;
|
|
|
1142 otherwise show only files that current locked in the version control system.
|
|
|
1143 Interactively, supply a prefix arg to make VERBOSE non-nil.
|
|
|
1144
|
|
|
1145 If the optional third argument NESTED is non-nil,
|
|
|
1146 scan the entire tree of subdirectories of the current directory."
|
|
|
1147 (interactive "DVC status of directory: \nP")
|
|
|
1148 (let* (nonempty
|
|
|
1149 (dl (length dir))
|
|
|
1150 (filelist nil) (userlist nil)
|
|
|
1151 dired-buf
|
|
|
1152 (subfunction
|
|
|
1153 (function (lambda (f)
|
|
|
1154 (if (vc-registered f)
|
|
|
1155 (let ((user (vc-locking-user f)))
|
|
|
1156 (and (or verbose user)
|
|
|
1157 (setq filelist (cons (substring f dl) filelist))
|
|
|
1158 (setq userlist (cons user userlist)))))))))
|
|
|
1159 (let ((default-directory dir))
|
|
|
1160 (if nested
|
|
|
1161 (vc-file-tree-walk subfunction)
|
|
|
1162 (vc-dir-all-files subfunction)))
|
|
|
1163 (save-excursion
|
|
|
1164 (dired (make-string-stringlist (cons dir (nreverse filelist)))
|
|
|
1165 dired-listing-switches)
|
|
|
1166 (rename-buffer (generate-new-buffer-name "VC-DIRED"))
|
|
|
1167 (setq dired-buf (current-buffer))
|
|
|
1168 (setq nonempty (not (zerop (buffer-size)))))
|
|
|
1169 (if nonempty
|
|
|
1170 (progn
|
|
|
1171 (pop-to-buffer dired-buf)
|
|
|
1172 (vc-dired-mode)
|
|
|
1173 (goto-char (point-min))
|
|
|
1174 (setq buffer-read-only nil)
|
|
|
1175 (forward-line 1) ; Skip header line
|
|
|
1176 (mapcar
|
|
|
1177 (function
|
|
|
1178 (lambda (x)
|
|
|
1179 (forward-char 2) ; skip dired's mark area
|
|
|
1180 (vc-dired-reformat-line x)
|
|
|
1181 (forward-line 1))) ; go to next line
|
|
|
1182 (nreverse userlist))
|
|
|
1183 (setq buffer-read-only t)
|
|
|
1184 (goto-char (point-min))
|
|
|
1185 )
|
|
|
1186 (message "No files are currently %s under %s"
|
|
|
1187 (if verbose "registered" "locked") default-directory))
|
|
|
1188 ))
|
|
|
1189
|
|
|
1190 (defun make-string-stringlist (stringlist)
|
|
|
1191 "Turn a list of strings into a string of space-delimited elements."
|
|
|
1192 (save-excursion
|
|
|
1193 (let ((tlist stringlist)
|
|
|
1194 (buf (generate-new-buffer "*stringlist*")))
|
|
|
1195 (set-buffer buf)
|
|
|
1196 (insert (car tlist))
|
|
|
1197 (setq tlist (cdr tlist))
|
|
|
1198 (while (not (null tlist))
|
|
|
1199 (setq s (car tlist))
|
|
|
1200 (insert s " ")
|
|
|
1201 (setq tlist (cdr tlist)))
|
|
|
1202 (setq string (buffer-string))
|
|
|
1203 (kill-this-buffer)
|
|
|
1204 string
|
|
|
1205 )))
|
|
|
1206
|
|
|
1207 ;; Named-configuration support for SCCS
|
|
|
1208
|
|
|
1209 (defun vc-add-triple (name file rev)
|
|
|
1210 (save-excursion
|
|
|
1211 (find-file (concat (vc-backend-subdirectory-name file) "/" vc-name-assoc-file))
|
|
|
1212 (goto-char (point-max))
|
|
|
1213 (insert name "\t:\t" file "\t" rev "\n")
|
|
|
1214 (basic-save-buffer)
|
|
|
1215 (kill-buffer (current-buffer))
|
|
|
1216 ))
|
|
|
1217
|
|
|
1218 (defun vc-record-rename (file newname)
|
|
|
1219 (save-excursion
|
|
|
1220 (find-file (concat (vc-backend-subdirectory-name file) "/" vc-name-assoc-file))
|
|
|
1221 (goto-char (point-min))
|
|
|
1222 ;; (replace-regexp (concat ":" (regexp-quote file) "$") (concat ":" newname))
|
|
|
1223 (while (re-search-forward (concat ":" (regexp-quote file) "$") nil t)
|
|
|
1224 (replace-match (concat ":" newname) nil nil))
|
|
|
1225 (basic-save-buffer)
|
|
|
1226 (kill-buffer (current-buffer))
|
|
|
1227 ))
|
|
|
1228
|
|
|
1229 (defun vc-lookup-triple (file name)
|
|
|
1230 ;; Return the numeric version corresponding to a named snapshot of file
|
|
|
1231 ;; If name is nil or a version number string it's just passed through
|
|
|
1232 (cond ((null name) name)
|
|
|
1233 ((let ((firstchar (aref name 0)))
|
|
|
1234 (and (>= firstchar ?0) (<= firstchar ?9)))
|
|
|
1235 name)
|
|
|
1236 (t
|
|
|
1237 (car (vc-master-info
|
|
|
1238 (concat (vc-backend-subdirectory-name file) "/" vc-name-assoc-file)
|
|
|
1239 (list (concat name "\t:\t" file "\t\\(.+\\)"))))
|
|
|
1240 )))
|
|
|
1241
|
|
|
1242 ;; Named-configuration entry points
|
|
|
1243
|
|
|
1244 (defun vc-locked-example ()
|
|
|
1245 ;; Return an example of why the current directory is not ready to be snapshot
|
|
|
1246 ;; or nil if no such example exists.
|
|
|
1247 (catch 'vc-locked-example
|
|
|
1248 (vc-file-tree-walk
|
|
|
1249 (function (lambda (f)
|
|
|
1250 (if (and (vc-registered f) (vc-locking-user f))
|
|
|
1251 (throw 'vc-locked-example f)))))
|
|
|
1252 nil))
|
|
|
1253
|
|
|
1254 ;;;###autoload
|
|
|
1255 (defun vc-create-snapshot (name)
|
|
|
1256 "Make a snapshot called NAME.
|
|
|
1257 The snapshot is made from all registered files at or below the current
|
|
|
1258 directory. For each file, the version level of its latest
|
|
|
1259 version becomes part of the named configuration."
|
|
|
1260 (interactive "sNew snapshot name: ")
|
|
|
1261 (let ((locked (vc-locked-example)))
|
|
|
1262 (if locked
|
|
|
1263 (error "File %s is locked" locked)
|
|
|
1264 (vc-file-tree-walk
|
|
|
1265 (function (lambda (f) (and
|
|
|
1266 (vc-name f)
|
|
|
1267 (vc-backend-assign-name f name)))))
|
|
|
1268 )))
|
|
|
1269
|
|
|
1270 ;;;###autoload
|
|
|
1271 (defun vc-retrieve-snapshot (name)
|
|
|
1272 "Retrieve the snapshot called NAME.
|
|
|
1273 This function fails if any files are locked at or below the current directory
|
|
|
1274 Otherwise, all registered files are checked out (unlocked) at their version
|
|
|
1275 levels in the snapshot."
|
|
|
1276 (interactive "sSnapshot name to retrieve: ")
|
|
|
1277 (let ((locked (vc-locked-example)))
|
|
|
1278 (if locked
|
|
|
1279 (error "File %s is locked" locked)
|
|
|
1280 (vc-file-tree-walk
|
|
|
1281 (function (lambda (f) (and
|
|
|
1282 (vc-name f)
|
|
|
1283 (vc-error-occurred
|
|
|
1284 (vc-backend-checkout f nil name))))))
|
|
|
1285 )))
|
|
|
1286
|
|
|
1287 ;; Miscellaneous other entry points
|
|
|
1288
|
|
|
1289 ;;;###autoload
|
|
|
1290 (defun vc-print-log ()
|
|
|
1291 "List the change log of the current buffer in a window."
|
|
|
1292 (interactive)
|
|
|
1293 (if vc-dired-mode
|
|
|
1294 (set-buffer (find-file-noselect (dired-get-filename))))
|
|
|
1295 (while vc-parent-buffer
|
|
|
1296 (pop-to-buffer vc-parent-buffer))
|
|
|
1297 (if (and buffer-file-name (vc-name buffer-file-name))
|
|
|
1298 (let ((file buffer-file-name))
|
|
|
1299 (vc-backend-print-log file)
|
|
|
1300 (pop-to-buffer (get-buffer-create "*vc*"))
|
|
|
1301 (setq default-directory (file-name-directory file))
|
|
|
1302 (while (looking-at "=*\n")
|
|
|
1303 (delete-char (- (match-end 0) (match-beginning 0)))
|
|
|
1304 (forward-line -1))
|
|
|
1305 (goto-char (point-min))
|
|
|
1306 (if (looking-at "[\b\t\n\v\f\r ]+")
|
|
|
1307 (delete-char (- (match-end 0) (match-beginning 0))))
|
|
|
1308 (shrink-window-if-larger-than-buffer)
|
|
|
1309 )
|
|
|
1310 (vc-registration-error buffer-file-name)))
|
|
|
1311
|
|
|
1312 ;;;###autoload
|
|
|
1313 (defun vc-revert-buffer ()
|
|
|
1314 "Revert the current buffer's file back to the latest checked-in version.
|
|
|
1315 This asks for confirmation if the buffer contents are not identical
|
|
|
1316 to that version.
|
|
|
1317 If the back-end is CVS, this will give you the most recent revision of
|
|
|
1318 the file on the branch you are editing."
|
|
|
1319 (interactive)
|
|
|
1320 (if vc-dired-mode
|
|
|
1321 (find-file-other-window (dired-get-filename)))
|
|
|
1322 (while vc-parent-buffer
|
|
|
1323 (pop-to-buffer vc-parent-buffer))
|
|
|
1324 (let ((file buffer-file-name)
|
|
|
1325 (obuf (current-buffer)) (changed (vc-diff nil t)))
|
|
|
1326 (if (and changed (or vc-suppress-confirm
|
|
|
1327 (not (yes-or-no-p "Discard changes? "))))
|
|
|
1328 (progn
|
|
|
1329 (delete-window)
|
|
|
1330 (error "Revert cancelled"))
|
|
|
1331 (set-buffer obuf))
|
|
|
1332 (if changed
|
|
|
1333 (delete-window))
|
|
|
1334 (vc-backend-revert file)
|
|
|
1335 (vc-resynch-window file t t)
|
|
|
1336 ))
|
|
|
1337
|
|
|
1338 ;;;###autoload
|
|
|
1339 (defun vc-cancel-version (norevert)
|
|
|
1340 "Get rid of most recently checked in version of this file.
|
|
|
1341 A prefix argument means do not revert the buffer afterwards."
|
|
|
1342 (interactive "P")
|
|
|
1343 (if vc-dired-mode
|
|
|
1344 (find-file-other-window (dired-get-filename)))
|
|
|
1345 (while vc-parent-buffer
|
|
|
1346 (pop-to-buffer vc-parent-buffer))
|
|
|
1347 (let* ((target (concat (vc-latest-version (buffer-file-name))))
|
|
|
1348 (yours (concat (vc-your-latest-version (buffer-file-name))))
|
|
|
1349 (prompt (if (string-equal yours target)
|
|
|
1350 "Remove your version %s from master? "
|
|
|
1351 "Version %s was not your change. Remove it anyway? ")))
|
|
|
1352 (if (null (yes-or-no-p (format prompt target)))
|
|
|
1353 nil
|
|
|
1354 (vc-backend-uncheck (buffer-file-name) target)
|
|
|
1355 (if (or norevert
|
|
|
1356 (not (yes-or-no-p "Revert buffer to most recent remaining version? ")))
|
|
|
1357 (vc-mode-line (buffer-file-name))
|
|
|
1358 (vc-checkout (buffer-file-name) nil)))
|
|
|
1359 ))
|
|
|
1360
|
|
|
1361 ;;;###autoload
|
|
|
1362 (defun vc-rename-file (old new)
|
|
|
1363 "Rename file OLD to NEW, and rename its master file likewise."
|
|
|
1364 (interactive "fVC rename file: \nFRename to: ")
|
|
|
1365 ;; There are several ways of renaming files under CVS 1.3, but they all
|
|
|
1366 ;; have serious disadvantages. See the FAQ (available from think.com in
|
|
|
1367 ;; pub/cvs/). I'd rather send the user an error, than do something he might
|
|
|
1368 ;; consider to be wrong. When the famous, long-awaited rename database is
|
|
|
1369 ;; implemented things might change for the better. This is unlikely to occur
|
|
|
1370 ;; until CVS 2.0 is released. --ceder 1994-01-23 21:27:51
|
|
|
1371 (if (eq (vc-backend-deduce old) 'CVS)
|
|
|
1372 (error "Renaming files under CVS is dangerous and not supported in VC."))
|
|
|
1373 (if (eq (vc-backend-deduce old) 'CC)
|
|
|
1374 (error "VC's ClearCase support cannot rename files."))
|
|
|
1375 (let ((oldbuf (get-file-buffer old)))
|
|
|
1376 (if (and oldbuf (buffer-modified-p oldbuf))
|
|
|
1377 (error "Please save files before moving them"))
|
|
|
1378 (if (get-file-buffer new)
|
|
|
1379 (error "Already editing new file name"))
|
|
|
1380 (if (file-exists-p new)
|
|
|
1381 (error "New file already exists"))
|
|
|
1382 (let ((oldmaster (vc-name old)))
|
|
|
1383 (if oldmaster
|
|
|
1384 (progn
|
|
|
1385 (if (vc-locking-user old)
|
|
|
1386 (error "Please check in files before moving them"))
|
|
|
1387 (if (or (file-symlink-p oldmaster)
|
|
|
1388 ;; This had FILE, I changed it to OLD. -- rms.
|
|
|
1389 (file-symlink-p (vc-backend-subdirectory-name old)))
|
|
|
1390 (error "This is not a safe thing to do in the presence of symbolic links"))
|
|
|
1391 (rename-file
|
|
|
1392 oldmaster
|
|
|
1393 (let ((backend (vc-backend-deduce old))
|
|
|
1394 (newdir (or (file-name-directory new) ""))
|
|
|
1395 (newbase (file-name-nondirectory new)))
|
|
|
1396 (catch 'found
|
|
|
1397 (mapcar
|
|
|
1398 (function
|
|
|
1399 (lambda (s)
|
|
|
1400 (if (eq backend (cdr s))
|
|
|
1401 (let* ((newmaster (format (car s) newdir newbase))
|
|
|
1402 (newmasterdir (file-name-directory newmaster)))
|
|
|
1403 (if (or (not newmasterdir)
|
|
|
1404 (file-directory-p newmasterdir))
|
|
|
1405 (throw 'found newmaster))))))
|
|
|
1406 vc-master-templates)
|
|
|
1407 (error "New file lacks a version control directory"))))))
|
|
|
1408 (if (or (not oldmaster) (file-exists-p old))
|
|
|
1409 (rename-file old new)))
|
|
|
1410 ;; ?? Renaming a file might change its contents due to keyword expansion.
|
|
|
1411 ;; We should really check out a new copy if the old copy was precisely equal
|
|
|
1412 ;; to some checked in version. However, testing for this is tricky....
|
|
|
1413 (if oldbuf
|
|
|
1414 (save-excursion
|
|
|
1415 (set-buffer oldbuf)
|
|
|
1416 (set-visited-file-name new)
|
|
|
1417 (set-buffer-modified-p nil))))
|
|
|
1418 ;; This had FILE, I changed it to OLD. -- rms.
|
|
|
1419 (vc-backend-dispatch old
|
|
|
1420 (vc-record-rename old new) ;SCCS
|
|
|
1421 ;; #### - This CAN kinda be done for both rcs and
|
|
|
1422 ;; cvs. It needs to be implemented. -- Stig
|
|
|
1423 nil ;RCS
|
|
|
1424 nil ;CVS
|
|
|
1425 nil ;CC
|
|
|
1426 )
|
|
|
1427 )
|
|
|
1428
|
|
|
1429 ;;;###autoload
|
|
6
|
1430 (defun vc-rename-this-file (new)
|
|
|
1431 (interactive "FVC rename file to: ")
|
|
|
1432 (vc-rename-file buffer-file-name new))
|
|
|
1433
|
|
|
1434 ;;;###autoload
|
|
0
|
1435 (defun vc-update-change-log (&rest args)
|
|
|
1436 "Find change log file and add entries from recent RCS logs.
|
|
|
1437 The mark is left at the end of the text prepended to the change log.
|
|
|
1438 With prefix arg of C-u, only find log entries for the current buffer's file.
|
|
|
1439 With any numeric prefix arg, find log entries for all files currently visited.
|
|
|
1440 Otherwise, find log entries for all registered files in the default directory.
|
|
|
1441 From a program, any arguments are passed to the `rcs2log' script."
|
|
|
1442 (interactive
|
|
|
1443 (cond ((consp current-prefix-arg) ;C-u
|
|
|
1444 (list buffer-file-name))
|
|
|
1445 (current-prefix-arg ;Numeric argument.
|
|
|
1446 (let ((files nil)
|
|
|
1447 (buffers (buffer-list))
|
|
|
1448 file)
|
|
|
1449 (while buffers
|
|
|
1450 (setq file (buffer-file-name (car buffers)))
|
|
|
1451 (and file (vc-backend-deduce file)
|
|
|
1452 (setq files (cons file files)))
|
|
|
1453 (setq buffers (cdr buffers)))
|
|
|
1454 files))
|
|
|
1455 (t
|
|
|
1456 (let ((RCS (concat default-directory "RCS")))
|
|
|
1457 (and (file-directory-p RCS)
|
|
|
1458 (mapcar (function
|
|
|
1459 (lambda (f)
|
|
|
1460 (if (string-match "\\(.*\\),v$" f)
|
|
|
1461 (substring f 0 (match-end 1))
|
|
|
1462 f)))
|
|
|
1463 (directory-files RCS nil "...\\|^[^.]\\|^.[^.]")))))))
|
|
|
1464 (let ((odefault default-directory))
|
|
|
1465 (find-file-other-window (find-change-log))
|
|
|
1466 (barf-if-buffer-read-only)
|
|
|
1467 (vc-buffer-sync)
|
|
|
1468 (undo-boundary)
|
|
|
1469 (goto-char (point-min))
|
|
|
1470 (push-mark)
|
|
|
1471 (message "Computing change log entries...")
|
|
|
1472 (message "Computing change log entries... %s"
|
|
|
1473 (if (or (null args)
|
|
|
1474 (eq 0 (apply 'call-process "rcs2log" nil t nil
|
|
|
1475 "-n"
|
|
|
1476 (user-login-name)
|
|
|
1477 (user-full-name)
|
|
|
1478 user-mail-address
|
|
|
1479 (mapcar (function
|
|
|
1480 (lambda (f)
|
|
|
1481 (file-relative-name
|
|
|
1482 (if (file-name-absolute-p f)
|
|
|
1483 f
|
|
|
1484 (concat odefault f)))))
|
|
|
1485 args))))
|
|
|
1486 "done" "failed"))))
|
|
|
1487
|
|
|
1488 ;; Functions for querying the master and lock files.
|
|
|
1489
|
|
|
1490 ;; XEmacs - use match-string instead...
|
|
|
1491 ;; (defun vc-match-substring (bn)
|
|
|
1492 ;; (buffer-substring (match-beginning bn) (match-end bn)))
|
|
|
1493
|
|
|
1494 (defun vc-parse-buffer (patterns &optional file properties)
|
|
|
1495 ;; Each pattern is of the form:
|
|
|
1496 ;; regex ; subex is 1, and date-subex is 2 (or nil)
|
|
|
1497 ;; (regex subex date-subex)
|
|
|
1498 ;;
|
|
|
1499 ;; Use PATTERNS to parse information out of the current buffer by matching
|
|
|
1500 ;; each REGEX in the list and the returning the string matched by SUBEX.
|
|
|
1501 ;; If a DATE-SUBEX is present, then the SUBEX from the match with the
|
|
|
1502 ;; highest value for DATE-SUBEX (string comparison is used) will be
|
|
|
1503 ;; returned.
|
|
|
1504 ;;
|
|
|
1505 ;; If FILE and PROPERTIES are given, the latter must be a list of
|
|
|
1506 ;; properties of the same length as PATTERNS; each property is assigned
|
|
|
1507 ;; the corresponding value.
|
|
|
1508 ;;
|
|
|
1509 (let (pattern regex subex date-subex latest-date val values date)
|
|
|
1510 (while (setq pattern (car patterns))
|
|
|
1511 (if (stringp pattern)
|
|
|
1512 (setq regex pattern
|
|
|
1513 subex 1
|
|
|
1514 date-subex (and (string-match "\\\\(.*\\\\(" regex) 2))
|
|
|
1515 (setq regex (car pattern)
|
|
|
1516 subex (nth 1 pattern)
|
|
|
1517 date-subex (nth 2 pattern)))
|
|
|
1518 (goto-char (point-min))
|
|
|
1519 (if date-subex
|
|
|
1520 (progn
|
|
|
1521 (setq latest-date "" val nil)
|
|
|
1522 (while (re-search-forward regex nil t)
|
|
|
1523 (setq date (match-string date-subex))
|
|
|
1524 (if (string< latest-date date)
|
|
|
1525 (setq latest-date date
|
|
|
1526 val (match-string subex))))
|
|
|
1527 val)
|
|
|
1528 ;; no date subex, so just take the first match...
|
|
|
1529 (setq val (and (re-search-forward regex nil t) (match-string subex))))
|
|
|
1530 (if file (vc-file-setprop file (car properties) val))
|
|
|
1531 (setq values (cons val values)
|
|
|
1532 patterns (cdr patterns)
|
|
|
1533 properties (cdr properties)))
|
|
|
1534 values
|
|
|
1535 ))
|
|
|
1536
|
|
|
1537 (defun vc-master-info (file fields &optional rfile properties)
|
|
|
1538 ;; Search for information in a master file.
|
|
|
1539 (if (and file (file-exists-p file))
|
|
|
1540 (save-excursion
|
|
|
1541 (let ((buf))
|
|
|
1542 (setq buf (create-file-buffer file))
|
|
|
1543 (set-buffer buf))
|
|
|
1544 (erase-buffer)
|
|
|
1545 (insert-file-contents file)
|
|
|
1546 (set-buffer-modified-p nil)
|
|
|
1547 (auto-save-mode nil)
|
|
|
1548 (prog1
|
|
|
1549 (vc-parse-buffer fields rfile properties)
|
|
|
1550 (kill-buffer (current-buffer)))
|
|
|
1551 )
|
|
|
1552 (if rfile
|
|
|
1553 (mapcar
|
|
|
1554 (function (lambda (p) (vc-file-setprop rfile p nil)))
|
|
|
1555 properties))
|
|
|
1556 )
|
|
|
1557 )
|
|
|
1558
|
|
|
1559 (defun vc-log-info (command file last flags patterns &optional properties)
|
|
|
1560 ;; Search for information in log program output
|
|
|
1561 (if (and file (file-exists-p file))
|
|
|
1562 (save-excursion
|
|
|
1563 (set-buffer (get-buffer-create "*vc*"))
|
|
|
1564 (apply 'vc-do-command 0 command file last flags)
|
|
|
1565 (set-buffer-modified-p nil)
|
|
|
1566 (prog1
|
|
|
1567 (vc-parse-buffer patterns file properties)
|
|
|
1568 (kill-buffer (current-buffer))
|
|
|
1569 )
|
|
|
1570 )
|
|
|
1571 (if file
|
|
|
1572 (mapcar
|
|
|
1573 (function (lambda (p) (vc-file-setprop file p nil)))
|
|
|
1574 properties))
|
|
|
1575 )
|
|
|
1576 )
|
|
|
1577
|
|
|
1578 (defun vc-locking-user (file)
|
|
|
1579 "Return the name of the person currently holding a lock on FILE.
|
|
|
1580 Return nil if there is no such person.
|
|
|
1581 Under CVS, a file is considered locked if it has been modified since it
|
|
|
1582 was checked out...even though it may well be writable by you."
|
|
|
1583 (setq file (expand-file-name file)) ; use full pathname
|
|
|
1584 (cond ((eq (vc-backend-deduce file) 'CVS)
|
|
|
1585 (if (vc-workfile-unchanged-p file t)
|
|
|
1586 nil
|
|
|
1587 ;; XEmacs - ahead of the pack...
|
|
|
1588 (user-login-name (nth 2 (file-attributes file)))))
|
|
|
1589 (t
|
|
|
1590 ;; #### - this can probably be cleaned up as a result of the changes to
|
|
|
1591 ;; user-login-name...
|
|
|
1592 (if (or (not vc-keep-workfiles)
|
|
|
1593 (eq vc-mistrust-permissions 't)
|
|
|
1594 (and vc-mistrust-permissions
|
|
|
1595 (funcall vc-mistrust-permissions (vc-backend-subdirectory-name
|
|
|
1596 file))))
|
|
|
1597 (vc-true-locking-user file)
|
|
|
1598 ;; This implementation assumes that any file which is under version
|
|
|
1599 ;; control and has -rw-r--r-- is locked by its owner. This is true
|
|
|
1600 ;; for both RCS and SCCS, which keep unlocked files at -r--r--r--.
|
|
|
1601 ;; We have to be careful not to exclude files with execute bits on;
|
|
|
1602 ;; scripts can be under version control too. Also, we must ignore
|
|
|
1603 ;; the group-read and other-read bits, since paranoid users turn them off.
|
|
|
1604 ;; This hack wins because calls to the very expensive vc-fetch-properties
|
|
|
1605 ;; function only have to be made if (a) the file is locked by someone
|
|
|
1606 ;; other than the current user, or (b) some untoward manipulation
|
|
|
1607 ;; behind vc's back has changed the owner or the `group' or `other'
|
|
|
1608 ;; write bits.
|
|
|
1609 (let ((attributes (file-attributes file)))
|
|
|
1610 (cond ((string-match ".r-..-..-." (nth 8 attributes))
|
|
|
1611 nil)
|
|
|
1612 ((and (= (nth 2 attributes) (user-uid))
|
|
|
1613 (string-match ".rw..-..-." (nth 8 attributes)))
|
|
|
1614 (user-login-name))
|
|
|
1615 (t
|
|
|
1616 (vc-true-locking-user file)))) ; #### - this looks recursive!!!
|
|
|
1617 ))))
|
|
|
1618
|
|
|
1619 (defun vc-true-locking-user (file)
|
|
|
1620 ;; The slow but reliable version
|
|
|
1621 (vc-fetch-properties file)
|
|
|
1622 (vc-file-getprop file 'vc-locking-user))
|
|
|
1623
|
|
|
1624 (defun vc-latest-version (file)
|
|
|
1625 ;; Return version level of the latest version of FILE
|
|
|
1626 (vc-fetch-properties file)
|
|
|
1627 (vc-file-getprop file 'vc-latest-version))
|
|
|
1628
|
|
|
1629 (defun vc-your-latest-version (file)
|
|
|
1630 ;; Return version level of the latest version of FILE checked in by you
|
|
|
1631 (vc-fetch-properties file)
|
|
|
1632 (vc-file-getprop file 'vc-your-latest-version))
|
|
|
1633
|
|
|
1634 ;; Collect back-end-dependent stuff here
|
|
|
1635 ;;
|
|
|
1636 ;; Everything eventually funnels through these functions. To implement
|
|
|
1637 ;; support for a new version-control system, add another branch to the
|
|
|
1638 ;; vc-backend-dispatch macro and fill it in in each call. The variable
|
|
|
1639 ;; vc-master-templates in vc-hooks.el will also have to change.
|
|
|
1640
|
|
|
1641 (put 'vc-backend-dispatch 'lisp-indent-function 'defun)
|
|
|
1642
|
|
|
1643 (defmacro vc-backend-dispatch (f s r c a)
|
|
|
1644 "Execute FORM1, FORM2 or FORM3 depending whether we're using SCCS, RCS, CVS
|
|
|
1645 or ClearCase.
|
|
|
1646 If FORM3 is RCS, use FORM2 even if we are using CVS. (CVS shares some code
|
|
|
1647 with RCS)."
|
|
|
1648 (list 'let (list (list 'type (list 'vc-backend-deduce f)))
|
|
|
1649 (list 'cond
|
|
|
1650 (list (list 'eq 'type (quote 'SCCS)) s) ; SCCS
|
|
|
1651 (list (list 'eq 'type (quote 'RCS)) r) ; RCS
|
|
|
1652 (list (list 'eq 'type (quote 'CVS)) ; CVS
|
|
|
1653 (if (eq c 'RCS) r c))
|
|
|
1654 (list (list 'eq 'type (quote 'CC)) a) ; CC
|
|
|
1655 )))
|
|
|
1656
|
|
|
1657 (defun vc-lock-file (file)
|
|
|
1658 ;; Generate lock file name corresponding to FILE
|
|
|
1659 (let ((master (vc-name file)))
|
|
|
1660 (and
|
|
|
1661 master
|
|
|
1662 (string-match "\\(.*/\\)s\\.\\(.*\\)" master)
|
|
|
1663 (concat
|
|
|
1664 (substring master (match-beginning 1) (match-end 1))
|
|
|
1665 "p."
|
|
|
1666 (substring master (match-beginning 2) (match-end 2))))))
|
|
|
1667
|
|
|
1668
|
|
|
1669 (defun vc-fetch-properties (file)
|
|
|
1670 ;; Re-fetch all properties associated with the given file.
|
|
|
1671 ;; Currently these properties are:
|
|
|
1672 ;; vc-locking-user
|
|
|
1673 ;; vc-locked-version
|
|
|
1674 ;; vc-latest-version
|
|
|
1675 ;; vc-your-latest-version
|
|
|
1676 ;; vc-cvs-status (cvs only)
|
|
|
1677 ;; vc-cc-predecessor (ClearCase only)
|
|
|
1678 (vc-backend-dispatch
|
|
|
1679 file
|
|
|
1680 ;; SCCS
|
|
|
1681 (progn
|
|
|
1682 (vc-master-info (vc-lock-file file)
|
|
|
1683 (list
|
|
|
1684 "^[^ ]+ [^ ]+ \\([^ ]+\\)"
|
|
|
1685 "^\\([^ ]+\\)")
|
|
|
1686 file
|
|
|
1687 '(vc-locking-user vc-locked-version))
|
|
|
1688 (vc-master-info (vc-name file)
|
|
|
1689 (list
|
|
|
1690 "^\001d D \\([^ ]+\\)"
|
|
|
1691 (concat "^\001d D \\([^ ]+\\) .* "
|
|
|
1692 (regexp-quote (user-login-name)) " ")
|
|
|
1693 )
|
|
|
1694 file
|
|
|
1695 '(vc-latest-version vc-your-latest-version))
|
|
|
1696 )
|
|
|
1697 ;; RCS
|
|
|
1698 (vc-log-info "rlog" file 'MASTER nil
|
|
|
1699 (list
|
|
|
1700 "^locks: strict\n\t\\([^:]+\\)"
|
|
|
1701 "^locks: strict\n\t[^:]+: \\(.+\\)"
|
|
|
1702 "^revision[\t ]+\\([0-9.]+\\).*\ndate: \\([ /0-9:]+\\);"
|
|
|
1703 (concat
|
|
|
1704 "^revision[\t ]+\\([0-9.]+\\)\n.*author: "
|
|
|
1705 (regexp-quote (user-login-name))
|
|
|
1706 ";"))
|
|
|
1707 '(vc-locking-user vc-locked-version
|
|
|
1708 vc-latest-version vc-your-latest-version))
|
|
|
1709 ;; CVS
|
|
|
1710 ;; Don't fetch vc-locking-user and vc-locked-version here, since they
|
|
|
1711 ;; should always be nil anyhow. Don't fetch vc-your-latest-version, since
|
|
|
1712 ;; that is done in vc-find-cvs-master.
|
|
|
1713 (vc-log-info
|
|
|
1714 "cvs" file 'WORKFILE '("status")
|
|
|
1715 ;; CVS 1.3 says "RCS Version:", other releases "RCS Revision:",
|
|
|
1716 ;; and CVS 1.4a1 says "Repository revision:". The regexp below
|
|
|
1717 ;; matches much more, but because of the way vc-log-info is
|
|
|
1718 ;; implemented it is impossible to use additional groups.
|
|
|
1719 '(("\\(RCS Version\\|RCS Revision\\|Repository revision\\):[\t ]+\\([0-9.]+\\)" 2)
|
|
|
1720 "Status: \\(.*\\)")
|
|
|
1721 '(vc-latest-version
|
|
|
1722 vc-cvs-status))
|
|
|
1723 ;; CC
|
|
|
1724 (vc-log-info "cleartool" file 'WORKFILE '("describe")
|
|
|
1725 (list
|
|
|
1726 "checked out .* by .* (\\([^ .]+\\)..*@.*)"
|
|
|
1727 "from \\([^ ]+\\) (reserved)"
|
|
|
1728 "version [^\"]*\".*@@\\([^ ]+\\)\""
|
|
|
1729 "version [^\"]*\".*@@\\([^ ]+\\)\""
|
|
|
1730 "predecessor version: \\([^ ]+\\)\n")
|
|
|
1731 '(vc-locking-user vc-locked-version
|
|
|
1732 vc-latest-version vc-your-latest-version
|
|
|
1733 vc-cc-predecessor))
|
|
|
1734 ))
|
|
|
1735
|
|
|
1736 (defun vc-backend-subdirectory-name (&optional file)
|
|
|
1737 ;; Where the master and lock files for the current directory are kept
|
|
|
1738 (let ((backend
|
|
|
1739 (or
|
|
|
1740 (and file (vc-backend-deduce file))
|
|
|
1741 vc-default-back-end
|
|
|
1742 (setq vc-default-back-end (if (vc-find-binary "rcs") 'RCS 'SCCS)))))
|
|
|
1743 (cond
|
|
|
1744 ((eq backend 'SCCS) "SCCS")
|
|
|
1745 ((eq backend 'RCS) "RCS")
|
|
|
1746 ((eq backend 'CVS) "CVS")
|
|
|
1747 ((eq backend 'CC) "@@"))
|
|
|
1748 ))
|
|
|
1749
|
|
|
1750 (defun vc-backend-admin (file &optional rev comment)
|
|
|
1751 ;; Register a file into the version-control system
|
|
|
1752 ;; Automatically retrieves a read-only version of the file with
|
|
|
1753 ;; keywords expanded if vc-keep-workfiles is non-nil, otherwise
|
|
|
1754 ;; it deletes the workfile.
|
|
|
1755 (vc-file-clearprops file)
|
|
|
1756 (or vc-default-back-end
|
|
|
1757 (setq vc-default-back-end (if (vc-find-binary "rcs") 'RCS 'SCCS)))
|
|
|
1758 (message "Registering %s..." file)
|
|
|
1759 (let ((backend
|
|
|
1760 (cond
|
|
|
1761 ((file-exists-p (vc-backend-subdirectory-name)) vc-default-back-end)
|
|
|
1762 ((file-exists-p "RCS") 'RCS)
|
|
|
1763 ((file-exists-p "SCCS") 'SCCS)
|
|
|
1764 ((file-exists-p "CVS") 'CVS)
|
|
|
1765 ((file-exists-p "@@") 'CC)
|
|
|
1766 (t vc-default-back-end))))
|
|
|
1767 (cond ((eq backend 'SCCS)
|
|
|
1768 (vc-do-command 0 "admin" file 'MASTER ; SCCS
|
|
|
1769 (and rev (concat "-r" rev))
|
|
|
1770 "-fb"
|
|
|
1771 (concat "-i" file)
|
|
|
1772 (and comment (concat "-y" comment))
|
|
|
1773 (format
|
|
|
1774 (car (rassq 'SCCS vc-master-templates))
|
|
|
1775 (or (file-name-directory file) "")
|
|
|
1776 (file-name-nondirectory file)))
|
|
|
1777 (delete-file file)
|
|
|
1778 (if vc-keep-workfiles
|
|
|
1779 (vc-do-command 0 "get" file 'MASTER)))
|
|
|
1780 ((eq backend 'RCS)
|
|
|
1781 (vc-do-command 0 "ci" file 'MASTER ; RCS
|
|
|
1782 (concat (if vc-keep-workfiles "-u" "-r") rev)
|
|
|
1783 (and comment (concat "-t-" comment))
|
|
|
1784 file))
|
|
|
1785 ((eq backend 'CVS)
|
|
|
1786 ;; #### - should maybe check to see if the master file is
|
|
|
1787 ;; already in the repository...in which case we need to add the
|
|
|
1788 ;; appropriate branch tag and do an update.
|
|
|
1789 ;; #### - note that adding a file is a 2 step process in CVS...
|
|
|
1790 (vc-do-command 0 "cvs" file 'WORKFILE "add")
|
|
|
1791 (vc-do-command 0 "cvs" file 'WORKFILE "commit"
|
|
|
1792 (and comment (not (string= comment ""))
|
|
|
1793 (concat "-m" comment)))
|
|
|
1794 )
|
|
|
1795 ((eq backend 'CC)
|
|
|
1796 (vc-do-command 0 "cleartool" file 'WORKFILE ; CC
|
|
|
1797 "mkelem"
|
|
|
1798 (if (string-equal "" comment)
|
|
|
1799 "-nc")
|
|
|
1800 (if (not (string-equal "" comment))
|
|
|
1801 "-c")
|
|
|
1802 (if (not (string-equal "" comment))
|
|
|
1803 comment)
|
|
|
1804 )
|
|
|
1805 (vc-do-command 0 "cleartool" file 'WORKFILE
|
|
|
1806 "checkin" "-identical" "-nc"
|
|
|
1807 )
|
|
|
1808 )))
|
|
|
1809 (message "Registering %s...done" file)
|
|
|
1810 )
|
|
|
1811
|
|
|
1812 (defun vc-backend-checkout (file &optional writable rev workfile)
|
|
|
1813 ;; Retrieve a copy of a saved version into a workfile
|
|
|
1814 (let ((filename (or workfile file)))
|
|
|
1815 (message "Checking out %s..." filename)
|
|
|
1816 (save-excursion
|
|
|
1817 ;; Change buffers to get local value of vc-checkin-switches.
|
|
|
1818 (set-buffer (or (get-file-buffer file) (current-buffer)))
|
|
|
1819 (vc-backend-dispatch
|
|
|
1820 file
|
|
|
1821 ;; SCCS
|
|
|
1822 (if workfile
|
|
|
1823 ;; Some SCCS implementations allow checking out directly to a
|
|
|
1824 ;; file using the -G option, but then some don't so use the
|
|
|
1825 ;; least common denominator approach and use the -p option
|
|
|
1826 ;; ala RCS.
|
|
|
1827 (let ((vc-modes (logior (file-modes (vc-name file))
|
|
|
1828 (if writable 128 0)))
|
|
|
1829 (failed t))
|
|
|
1830 (unwind-protect
|
|
|
1831 (progn
|
|
|
1832 (apply 'vc-do-command
|
|
|
1833 0 "/bin/sh" file 'MASTER "-c"
|
|
|
1834 ;; Some shells make the "" dummy argument into $0
|
|
|
1835 ;; while others use the shell's name as $0 and
|
|
|
1836 ;; use the "" as $1. The if-statement
|
|
|
1837 ;; converts the latter case to the former.
|
|
|
1838 (format "if [ x\"$1\" = x ]; then shift; fi; \
|
|
|
1839 umask %o; exec >\"$1\" || exit; \
|
|
|
1840 shift; umask %o; exec get \"$@\""
|
|
|
1841 (logand 511 (lognot vc-modes))
|
|
|
1842 (logand 511 (lognot (default-file-modes))))
|
|
|
1843 "" ; dummy argument for shell's $0
|
|
|
1844 filename
|
|
|
1845 (if writable "-e")
|
|
|
1846 "-p" (and rev
|
|
|
1847 (concat "-r" (vc-lookup-triple file rev)))
|
|
|
1848 vc-checkout-switches)
|
|
|
1849 (setq failed nil))
|
|
|
1850 (and failed (file-exists-p filename) (delete-file filename))))
|
|
|
1851 (apply 'vc-do-command 0 "get" file 'MASTER ; SCCS
|
|
|
1852 (if writable "-e")
|
|
|
1853 (and rev (concat "-r" (vc-lookup-triple file rev)))
|
|
|
1854 vc-checkout-switches))
|
|
|
1855 ;; RCS
|
|
|
1856 (if workfile
|
|
|
1857 ;; RCS doesn't let us check out into arbitrary file names directly.
|
|
|
1858 ;; Use `co -p' and make stdout point to the correct file.
|
|
|
1859 (let ((vc-modes (logior (file-modes (vc-name file))
|
|
|
1860 (if writable 128 0)))
|
|
|
1861 (failed t))
|
|
|
1862 (unwind-protect
|
|
|
1863 (progn
|
|
|
1864 (apply 'vc-do-command
|
|
|
1865 0 "/bin/sh" file 'MASTER "-c"
|
|
|
1866 ;; See the SCCS case, above, regarding the
|
|
|
1867 ;; if-statement.
|
|
|
1868 (format "if [ x\"$1\" = x ]; then shift; fi; \
|
|
|
1869 umask %o; exec >\"$1\" || exit; \
|
|
|
1870 shift; umask %o; exec co \"$@\""
|
|
|
1871 (logand 511 (lognot vc-modes))
|
|
|
1872 (logand 511 (lognot (default-file-modes))))
|
|
|
1873 "" ; dummy argument for shell's $0
|
|
|
1874 filename
|
|
|
1875 (if writable "-l")
|
|
|
1876 (concat "-p" rev)
|
|
|
1877 vc-checkout-switches)
|
|
|
1878 (setq failed nil))
|
|
|
1879 (and failed (file-exists-p filename) (delete-file filename))))
|
|
|
1880 (apply 'vc-do-command 0 "co" file 'MASTER
|
|
|
1881 (if writable "-l")
|
|
|
1882 (and rev (concat "-r" rev))
|
|
|
1883 vc-checkout-switches))
|
|
|
1884 ;; CVS
|
|
|
1885 (if workfile
|
|
|
1886 ;; CVS is much like RCS
|
|
|
1887 (let ((failed t))
|
|
|
1888 (unwind-protect
|
|
|
1889 (progn
|
|
|
1890 (apply 'vc-do-command
|
|
|
1891 0 "/bin/sh" file 'WORKFILE "-c"
|
|
|
1892 "exec >\"$1\" || exit; shift; exec cvs update \"$@\""
|
|
|
1893 "" ; dummy argument for shell's $0
|
|
|
1894 workfile
|
|
|
1895 (concat "-r" rev)
|
|
|
1896 "-p"
|
|
|
1897 vc-checkout-switches)
|
|
|
1898 (setq failed nil))
|
|
|
1899 (and failed (file-exists-p filename) (delete-file filename))))
|
|
|
1900 (apply 'vc-do-command 0 "cvs" file 'WORKFILE
|
|
|
1901 "update"
|
|
|
1902 (and rev (concat "-r" rev))
|
|
|
1903 file
|
|
|
1904 vc-checkout-switches))
|
|
|
1905 ;; CC
|
|
|
1906 (if (or rev workfile)
|
|
|
1907 (error "VC's ClearCase support currently checks out /main/LATEST.")
|
|
|
1908 (apply 'vc-do-command 0 "cleartool" file 'WORKFILE
|
|
|
1909 "checkout" "-nc"
|
|
|
1910 vc-checkout-switches))
|
|
|
1911 ))
|
|
|
1912 (or workfile
|
|
|
1913 (vc-file-setprop file
|
|
|
1914 'vc-checkout-time (nth 5 (file-attributes file))))
|
|
|
1915 (message "Checking out %s...done" filename))
|
|
|
1916 )
|
|
|
1917
|
|
|
1918 (defun vc-backend-logentry-check (file)
|
|
|
1919 (vc-backend-dispatch file
|
|
|
1920 (if (>= (buffer-size) 512) ; SCCS
|
|
|
1921 (progn
|
|
|
1922 (goto-char 512)
|
|
|
1923 (error
|
|
|
1924 "Log must be less than 512 characters; point is now at pos 512")))
|
|
|
1925 nil ; RCS
|
|
|
1926 nil ; CVS
|
|
|
1927 nil) ; CC
|
|
|
1928 )
|
|
|
1929
|
|
|
1930 (defun vc-backend-checkin (file rev comment)
|
|
|
1931 ;; Register changes to FILE as level REV with explanatory COMMENT.
|
|
|
1932 ;; Automatically retrieves a read-only version of the file with
|
|
|
1933 ;; keywords expanded if vc-keep-workfiles is non-nil, otherwise
|
|
|
1934 ;; it deletes the workfile.
|
|
|
1935 (message "Checking in %s..." file)
|
|
|
1936 (save-excursion
|
|
|
1937 ;; Change buffers to get local value of vc-checkin-switches.
|
|
|
1938 (set-buffer (or (get-file-buffer file) (current-buffer)))
|
|
|
1939 (vc-backend-dispatch file
|
|
|
1940 (progn
|
|
|
1941 (apply 'vc-do-command 0 "delta" file 'MASTER
|
|
|
1942 (if rev (concat "-r" rev))
|
|
|
1943 (concat "-y" comment)
|
|
|
1944 vc-checkin-switches)
|
|
|
1945 (if vc-keep-workfiles
|
|
|
1946 (vc-do-command 0 "get" file 'MASTER))
|
|
|
1947 )
|
|
|
1948 (apply 'vc-do-command 0 "ci" file 'MASTER
|
|
|
1949 (concat (if vc-keep-workfiles "-u" "-r") rev)
|
|
|
1950 (if (not (string-equal "" comment))
|
|
|
1951 (concat "-m" comment))
|
|
|
1952 vc-checkin-switches)
|
|
|
1953 (progn
|
|
|
1954 (apply 'vc-do-command 0 "cvs" file 'WORKFILE
|
|
|
1955 "ci"
|
|
|
1956 (if (not (string-equal "" comment))
|
|
|
1957 (concat "-m" comment))
|
|
|
1958 vc-checkin-switches)
|
|
|
1959 (vc-file-setprop file 'vc-checkout-time
|
|
|
1960 (nth 5 (file-attributes file))))
|
|
|
1961 (progn
|
|
|
1962 (apply 'vc-do-command 0 "cleartool" file 'WORKFILE
|
|
|
1963 "checkin" "-identical"
|
|
|
1964 (if (string-equal "" comment)
|
|
|
1965 "-nc")
|
|
|
1966 (if (not (string-equal "" comment))
|
|
|
1967 "-c")
|
|
|
1968 (if (not (string-equal "" comment))
|
|
|
1969 comment)
|
|
|
1970 vc-checkin-switches)
|
|
|
1971 (vc-file-setprop file 'vc-checkout-time
|
|
|
1972 (nth 5 (file-attributes file))))
|
|
|
1973 ))
|
|
|
1974 (vc-file-setprop file 'vc-locking-user nil)
|
|
|
1975 (message "Checking in %s...done" file)
|
|
|
1976 )
|
|
|
1977
|
|
|
1978 (defun vc-backend-revert (file)
|
|
|
1979 ;; Revert file to latest checked-in version.
|
|
|
1980 (message "Reverting %s..." file)
|
|
|
1981 (vc-backend-dispatch
|
|
|
1982 file
|
|
|
1983 (progn ; SCCS
|
|
|
1984 (vc-do-command 0 "unget" file 'MASTER nil)
|
|
|
1985 (vc-do-command 0 "get" file 'MASTER nil))
|
|
|
1986 (vc-do-command 0 "co" file 'MASTER ; RCS. This deletes the work file.
|
|
|
1987 "-f" "-u")
|
|
|
1988 (progn ; CVS
|
|
|
1989 (delete-file file)
|
|
|
1990 (vc-do-command 0 "cvs" file 'WORKFILE "update"))
|
|
|
1991 (vc-do-command 0 "cleartool" file 'WORKFILE ; CC
|
|
|
1992 "unco" "-rm")
|
|
|
1993 )
|
|
|
1994 (vc-file-setprop file 'vc-locking-user nil)
|
|
|
1995 (message "Reverting %s...done" file)
|
|
|
1996 )
|
|
|
1997
|
|
|
1998 (defun vc-backend-steal (file &optional rev)
|
|
|
1999 ;; Steal the lock on the current workfile. Needs RCS 5.6.2 or later for -M.
|
|
|
2000 (message "Stealing lock on %s..." file)
|
|
|
2001 (vc-backend-dispatch file
|
|
|
2002 (progn ; SCCS
|
|
|
2003 (vc-do-command 0 "unget" file 'MASTER "-n" (if rev (concat "-r" rev)))
|
|
|
2004 (vc-do-command 0 "get" file 'MASTER "-g" (if rev (concat "-r" rev)))
|
|
|
2005 )
|
|
|
2006 (vc-do-command 0 "rcs" file 'MASTER ; RCS
|
|
|
2007 "-M" (concat "-u" rev) (concat "-l" rev))
|
|
|
2008 (error "You cannot steal a CVS lock; there are no CVS locks to steal.") ; CVS
|
|
|
2009 (error "VC's ClearCase support cannot steal locks.") ; CC
|
|
|
2010 )
|
|
|
2011 (vc-file-setprop file 'vc-locking-user (user-login-name))
|
|
|
2012 (message "Stealing lock on %s...done" file)
|
|
|
2013 )
|
|
|
2014
|
|
|
2015 (defun vc-backend-uncheck (file target)
|
|
|
2016 ;; Undo the latest checkin. Note: this code will have to get a lot
|
|
|
2017 ;; smarter when we support multiple branches.
|
|
|
2018 (message "Removing last change from %s..." file)
|
|
|
2019 (vc-backend-dispatch file
|
|
|
2020 (vc-do-command 0 "rmdel" file 'MASTER (concat "-r" target))
|
|
|
2021 (vc-do-command 0 "rcs" file 'MASTER (concat "-o" target))
|
|
|
2022 (error "Unchecking files under CVS is dangerous and not supported in VC.")
|
|
|
2023 (error "VC's ClearCase support cannot cancel checkins.")
|
|
|
2024 )
|
|
|
2025 (message "Removing last change from %s...done" file)
|
|
|
2026 )
|
|
|
2027
|
|
|
2028 (defun vc-backend-print-log (file)
|
|
|
2029 ;; Print change log associated with FILE to buffer *vc*.
|
|
|
2030 (vc-backend-dispatch
|
|
|
2031 file
|
|
|
2032 (vc-do-command 0 "prs" file 'MASTER)
|
|
|
2033 (vc-do-command 0 "rlog" file 'MASTER)
|
|
24
|
2034 (vc-do-command 0 "cvs" file 'WORKFILE "log")
|
|
0
|
2035 (vc-do-command 0 "cleartool" file 'WORKFILE "lshistory")))
|
|
|
2036
|
|
|
2037 (defun vc-backend-assign-name (file name)
|
|
|
2038 ;; Assign to a FILE's latest version a given NAME.
|
|
|
2039 (vc-backend-dispatch file
|
|
|
2040 (vc-add-triple name file (vc-latest-version file)) ; SCCS
|
|
|
2041 (vc-do-command 0 "rcs" file 'MASTER (concat "-n" name ":")) ; RCS
|
|
|
2042 (vc-do-command 0 "cvs" file 'WORKFILE "tag" name) ; CVS
|
|
|
2043 (vc-do-command 0 "cleartool" file 'WORKFILE ; CC
|
|
|
2044 "mklabel" "-replace" "-nc" name)
|
|
|
2045 )
|
|
|
2046 )
|
|
|
2047
|
|
|
2048 (defun vc-backend-diff (file &optional oldvers newvers cmp)
|
|
|
2049 ;; Get a difference report between two versions of FILE.
|
|
|
2050 ;; Get only a brief comparison report if CMP, a difference report otherwise.
|
|
|
2051 (let ((backend (vc-backend-deduce file)))
|
|
|
2052 (cond
|
|
|
2053 ((eq backend 'SCCS)
|
|
|
2054 (setq oldvers (vc-lookup-triple file oldvers))
|
|
|
2055 (setq newvers (vc-lookup-triple file newvers))))
|
|
|
2056 (cond
|
|
|
2057 ;; SCCS and RCS shares a lot of code.
|
|
|
2058 ((or (eq backend 'SCCS) (eq backend 'RCS))
|
|
|
2059 (let* ((command (if (eq backend 'SCCS)
|
|
|
2060 "vcdiff"
|
|
|
2061 "rcsdiff"))
|
|
|
2062 (mode (if (eq backend 'RCS) 'WORKFILE 'MASTER))
|
|
|
2063 (options (append (list (and cmp "--brief")
|
|
|
2064 "-q"
|
|
|
2065 (and oldvers (concat "-r" oldvers))
|
|
|
2066 (and newvers (concat "-r" newvers)))
|
|
|
2067 (and (not cmp)
|
|
|
2068 (if (listp diff-switches)
|
|
|
2069 diff-switches
|
|
|
2070 (list diff-switches)))))
|
|
|
2071 (status (apply 'vc-do-command 2 command file mode options)))
|
|
|
2072 ;; Some RCS versions don't understand "--brief"; work around this.
|
|
|
2073 (if (eq status 2)
|
|
|
2074 (apply 'vc-do-command 1 command file 'WORKFILE
|
|
|
2075 (if cmp (cdr options) options))
|
|
|
2076 status)))
|
|
|
2077 ;; CVS is different.
|
|
|
2078 ;; cmp is not yet implemented -- we always do a full diff.
|
|
|
2079 ((eq backend 'CVS)
|
|
|
2080 (if (string= (vc-file-getprop file 'vc-your-latest-version) "0") ; CVS
|
|
|
2081 ;; This file is added but not yet committed; there is no master file.
|
|
|
2082 ;; diff it against /dev/null.
|
|
|
2083 (if (or oldvers newvers)
|
|
|
2084 (error "No revisions of %s exists" file)
|
|
|
2085 (apply 'vc-do-command
|
|
|
2086 1 "diff" file 'WORKFILE "/dev/null"
|
|
|
2087 (if (listp diff-switches)
|
|
|
2088 diff-switches
|
|
|
2089 (list diff-switches))))
|
|
|
2090 (apply 'vc-do-command
|
|
|
2091 1 "cvs" file 'WORKFILE "diff"
|
|
|
2092 (and oldvers (concat "-r" oldvers))
|
|
|
2093 (and newvers (concat "-r" newvers))
|
|
|
2094 (if (listp diff-switches)
|
|
|
2095 diff-switches
|
|
|
2096 (list diff-switches)))))
|
|
|
2097 ;; ClearCase is completely different.
|
|
|
2098 ((eq backend 'CC)
|
|
|
2099 (apply 'vc-do-command 2 "cleardiff" file nil
|
|
|
2100 (if cmp "-status_only")
|
|
|
2101 (concat file "@@"
|
|
|
2102 (or oldvers
|
|
|
2103 (vc-file-getprop file 'vc-cc-predecessor)))
|
|
|
2104 (if newvers
|
|
|
2105 (concat file "@@" newvers)
|
|
|
2106 file)
|
|
|
2107 nil))
|
|
|
2108 (t
|
|
|
2109 (vc-registration-error file)))))
|
|
|
2110
|
|
|
2111 (defun vc-backend-merge-news (file)
|
|
|
2112 ;; Merge in any new changes made to FILE.
|
|
|
2113 (vc-backend-dispatch
|
|
|
2114 file
|
|
|
2115 (error "vc-backend-merge-news not meaningful for SCCS files") ; SCCS
|
|
|
2116 (error "vc-backend-merge-news not meaningful for RCS files") ; RCS
|
|
|
2117 (vc-do-command 1 "cvs" file 'WORKFILE "update") ; CVS
|
|
|
2118 (error "vc-backend-merge-news not meaningful for ClearCase files") ; CC
|
|
|
2119 ))
|
|
|
2120
|
|
|
2121 (defun vc-check-headers ()
|
|
|
2122 "Check if the current file has any headers in it."
|
|
|
2123 (interactive)
|
|
|
2124 (save-excursion
|
|
|
2125 (goto-char (point-min))
|
|
|
2126 (vc-backend-dispatch buffer-file-name
|
|
|
2127 (re-search-forward "%[MIRLBSDHTEGUYFPQCZWA]%" nil t) ; SCCS
|
|
|
2128 (re-search-forward "\\$[A-Za-z\300-\326\330-\366\370-\377]+\\(: [\t -#%-\176\240-\377]*\\)?\\$" nil t) ; RCS
|
|
|
2129 'RCS ; CVS works like RCS in this regard.
|
|
|
2130 nil ; ClearCase does not recognise headers.
|
|
|
2131 )
|
|
|
2132 ))
|
|
|
2133
|
|
|
2134 ;; Back-end-dependent stuff ends here.
|
|
|
2135
|
|
|
2136 ;; Set up key bindings for use while editing log messages
|
|
|
2137
|
|
|
2138 (defun vc-log-mode ()
|
|
|
2139 "Minor mode for driving version-control tools.
|
|
|
2140 These bindings are added to the global keymap when you enter this mode:
|
|
|
2141 \\[vc-next-action] perform next logical version-control operation on current file
|
|
|
2142 \\[vc-register] register current file
|
|
|
2143 \\[vc-toggle-read-only] like next-action, but won't register files
|
|
|
2144 \\[vc-insert-headers] insert version-control headers in current file
|
|
|
2145 \\[vc-print-log] display change history of current file
|
|
|
2146 \\[vc-revert-buffer] revert buffer to latest version
|
|
|
2147 \\[vc-cancel-version] undo latest checkin
|
|
|
2148 \\[vc-diff] show diffs between file versions
|
|
|
2149 \\[vc-version-other-window] visit old version in another window
|
|
|
2150 \\[vc-directory] show all files locked by any user in or below .
|
|
|
2151 \\[vc-update-change-log] add change log entry from recent checkins
|
|
|
2152
|
|
|
2153 While you are entering a change log message for a version, the following
|
|
|
2154 additional bindings will be in effect.
|
|
|
2155
|
|
|
2156 \\[vc-finish-logentry] proceed with check in, ending log message entry
|
|
|
2157
|
|
|
2158 Whenever you do a checkin, your log comment is added to a ring of
|
|
|
2159 saved comments. These can be recalled as follows:
|
|
|
2160
|
|
|
2161 \\[vc-next-comment] replace region with next message in comment ring
|
|
|
2162 \\[vc-previous-comment] replace region with previous message in comment ring
|
|
|
2163 \\[vc-comment-search-reverse] search backward for regexp in the comment ring
|
|
|
2164 \\[vc-comment-search-forward] search backward for regexp in the comment ring
|
|
|
2165
|
|
|
2166 Entry to the change-log submode calls the value of text-mode-hook, then
|
|
|
2167 the value of vc-log-mode-hook.
|
|
|
2168
|
|
|
2169 Global user options:
|
|
|
2170 vc-initial-comment If non-nil, require user to enter a change
|
|
|
2171 comment upon first checkin of the file.
|
|
|
2172
|
|
|
2173 vc-keep-workfiles Non-nil value prevents workfiles from being
|
|
|
2174 deleted when changes are checked in
|
|
|
2175
|
|
|
2176 vc-suppress-confirm Suppresses some confirmation prompts,
|
|
|
2177 notably for reversions.
|
|
|
2178
|
|
|
2179 vc-header-alist Which keywords to insert when adding headers
|
|
|
2180 with \\[vc-insert-headers]. Defaults to
|
|
|
2181 '(\"\%\W\%\") under SCCS, '(\"\$Id\$\") under
|
|
|
2182 RCS and CVS.
|
|
|
2183
|
|
|
2184 vc-static-header-alist By default, version headers inserted in C files
|
|
|
2185 get stuffed in a static string area so that
|
|
|
2186 ident(RCS/CVS) or what(SCCS) can see them in
|
|
|
2187 the compiled object code. You can override
|
|
|
2188 this by setting this variable to nil, or change
|
|
|
2189 the header template by changing it.
|
|
|
2190
|
|
|
2191 vc-command-messages if non-nil, display run messages from the
|
|
|
2192 actual version-control utilities (this is
|
|
|
2193 intended primarily for people hacking vc
|
|
|
2194 itself).
|
|
|
2195 "
|
|
|
2196 (interactive)
|
|
|
2197 (set-syntax-table text-mode-syntax-table)
|
|
|
2198 (use-local-map vc-log-entry-mode)
|
|
|
2199 (setq local-abbrev-table text-mode-abbrev-table)
|
|
|
2200 (setq major-mode 'vc-log-mode)
|
|
|
2201 (setq mode-name "VC-Log")
|
|
|
2202 (make-local-variable 'vc-log-file)
|
|
|
2203 (make-local-variable 'vc-log-version)
|
|
|
2204 (make-local-variable 'vc-comment-ring-index)
|
|
|
2205 (set-buffer-modified-p nil)
|
|
|
2206 (setq buffer-file-name nil)
|
|
|
2207 (run-hooks 'text-mode-hook 'vc-log-mode-hook)
|
|
|
2208 )
|
|
|
2209
|
|
|
2210 ;; Initialization code, to be done just once at load-time
|
|
|
2211 (if vc-log-entry-mode
|
|
|
2212 nil
|
|
|
2213 (setq vc-log-entry-mode (make-sparse-keymap))
|
|
|
2214 (set-keymap-name vc-log-entry-mode 'vc-log-entry-mode) ; XEmacs
|
|
|
2215 (define-key vc-log-entry-mode "\M-n" 'vc-next-comment)
|
|
|
2216 (define-key vc-log-entry-mode "\M-p" 'vc-previous-comment)
|
|
|
2217 (define-key vc-log-entry-mode "\M-r" 'vc-comment-search-reverse)
|
|
|
2218 (define-key vc-log-entry-mode "\M-s" 'vc-comment-search-forward)
|
|
|
2219 (define-key vc-log-entry-mode "\C-c\C-c" 'vc-finish-logentry)
|
|
|
2220 )
|
|
|
2221
|
|
|
2222 ;;; These things should probably be generally available
|
|
|
2223
|
|
|
2224 (defun vc-file-tree-walk (func &rest args)
|
|
|
2225 "Walk recursively through default directory.
|
|
|
2226 Invoke FUNC f ARGS on each non-directory file f underneath it."
|
|
|
2227 (vc-file-tree-walk-internal default-directory func args)
|
|
|
2228 (message "Traversing directory %s...done" default-directory))
|
|
|
2229
|
|
|
2230 (defun vc-file-tree-walk-internal (file func args)
|
|
|
2231 (if (not (file-directory-p file))
|
|
|
2232 (apply func file args)
|
|
|
2233 (message "Traversing directory %s..." file)
|
|
|
2234 (let ((dir (file-name-as-directory file)))
|
|
|
2235 (mapcar
|
|
|
2236 (function
|
|
|
2237 (lambda (f) (or
|
|
|
2238 (string-equal f ".")
|
|
|
2239 (string-equal f "..")
|
|
|
2240 (member f vc-directory-exclusion-list)
|
|
|
2241 (let ((dirf (concat dir f)))
|
|
|
2242 (or
|
|
|
2243 (file-symlink-p dirf) ; Avoid possible loops
|
|
|
2244 (vc-file-tree-walk-internal dirf func args))))))
|
|
|
2245 (directory-files dir)))))
|
|
|
2246
|
|
|
2247 (defun vc-dir-all-files (func &rest args)
|
|
|
2248 "Invoke FUNC f ARGS on each regular file f in default directory."
|
|
|
2249 (let ((dir default-directory))
|
|
|
2250 (message "Scanning directory %s..." dir)
|
|
|
2251 (mapcar (function (lambda (f)
|
|
|
2252 (let ((dirf (expand-file-name f dir)))
|
|
|
2253 (if (not (file-directory-p dirf))
|
|
|
2254 (apply func dirf args)))))
|
|
|
2255 (directory-files dir))
|
|
|
2256 (message "Scanning directory %s...done" dir)))
|
|
|
2257
|
|
|
2258 (provide 'vc)
|
|
|
2259
|
|
|
2260 ;;; DEVELOPER'S NOTES ON CONCURRENCY PROBLEMS IN THIS CODE
|
|
|
2261 ;;;
|
|
|
2262 ;;; These may be useful to anyone who has to debug or extend the package.
|
|
|
2263 ;;;
|
|
|
2264 ;;; A fundamental problem in VC is that there are time windows between
|
|
|
2265 ;;; vc-next-action's computations of the file's version-control state and
|
|
|
2266 ;;; the actions that change it. This is a window open to lossage in a
|
|
|
2267 ;;; multi-user environment; someone else could nip in and change the state
|
|
|
2268 ;;; of the master during it.
|
|
|
2269 ;;;
|
|
|
2270 ;;; The performance problem is that rlog/prs calls are very expensive; we want
|
|
|
2271 ;;; to avoid them as much as possible.
|
|
|
2272 ;;;
|
|
|
2273 ;;; ANALYSIS:
|
|
|
2274 ;;;
|
|
|
2275 ;;; The performance problem, it turns out, simplifies in practice to the
|
|
|
2276 ;;; problem of making vc-locking-user fast. The two other functions that call
|
|
|
2277 ;;; prs/rlog will not be so commonly used that the slowdown is a problem; one
|
|
|
2278 ;;; makes snapshots, the other deletes the calling user's last change in the
|
|
|
2279 ;;; master.
|
|
|
2280 ;;;
|
|
|
2281 ;;; The race condition implies that we have to either (a) lock the master
|
|
|
2282 ;;; during the entire execution of vc-next-action, or (b) detect and
|
|
|
2283 ;;; recover from errors resulting from dispatch on an out-of-date state.
|
|
|
2284 ;;;
|
|
|
2285 ;;; Alternative (a) appears to be unfeasible. The problem is that we can't
|
|
|
2286 ;;; guarantee that the lock will ever be removed. Suppose a user starts a
|
|
|
2287 ;;; checkin, the change message buffer pops up, and the user, having wandered
|
|
|
2288 ;;; off to do something else, simply forgets about it?
|
|
|
2289 ;;;
|
|
|
2290 ;;; Alternative (b), on the other hand, works well with a cheap way to speed up
|
|
|
2291 ;;; vc-locking-user. Usually, if a file is registered, we can read its locked/
|
|
|
2292 ;;; unlocked state and its current owner from its permissions.
|
|
|
2293 ;;;
|
|
|
2294 ;;; This shortcut will fail if someone has manually changed the workfile's
|
|
|
2295 ;;; permissions; also if developers are munging the workfile in several
|
|
|
2296 ;;; directories, with symlinks to a master (in this latter case, the
|
|
|
2297 ;;; permissions shortcut will fail to detect a lock asserted from another
|
|
|
2298 ;;; directory).
|
|
|
2299 ;;;
|
|
|
2300 ;;; Note that these cases correspond exactly to the errors which could happen
|
|
|
2301 ;;; because of a competing checkin/checkout race in between two instances of
|
|
|
2302 ;;; vc-next-action.
|
|
|
2303 ;;;
|
|
|
2304 ;;; For VC's purposes, a workfile/master pair may have the following states:
|
|
|
2305 ;;;
|
|
|
2306 ;;; A. Unregistered. There is a workfile, there is no master.
|
|
|
2307 ;;;
|
|
|
2308 ;;; B. Registered and not locked by anyone.
|
|
|
2309 ;;;
|
|
|
2310 ;;; C. Locked by calling user and unchanged.
|
|
|
2311 ;;;
|
|
|
2312 ;;; D. Locked by the calling user and changed.
|
|
|
2313 ;;;
|
|
|
2314 ;;; E. Locked by someone other than the calling user.
|
|
|
2315 ;;;
|
|
|
2316 ;;; This makes for 25 states and 20 error conditions. Here's the matrix:
|
|
|
2317 ;;;
|
|
|
2318 ;;; VC's idea of state
|
|
|
2319 ;;; |
|
|
|
2320 ;;; V Actual state RCS action SCCS action Effect
|
|
|
2321 ;;; A B C D E
|
|
|
2322 ;;; A . 1 2 3 4 ci -u -t- admin -fb -i<file> initial admin
|
|
|
2323 ;;; B 5 . 6 7 8 co -l get -e checkout
|
|
|
2324 ;;; C 9 10 . 11 12 co -u unget; get revert
|
|
|
2325 ;;; D 13 14 15 . 16 ci -u -m<comment> delta -y<comment>; get checkin
|
|
|
2326 ;;; E 17 18 19 20 . rcs -u -M ; rcs -l unget -n ; get -g steal lock
|
|
|
2327 ;;;
|
|
|
2328 ;;; All commands take the master file name as a last argument (not shown).
|
|
|
2329 ;;;
|
|
|
2330 ;;; In the discussion below, a "self-race" is a pathological situation in
|
|
|
2331 ;;; which VC operations are being attempted simultaneously by two or more
|
|
|
2332 ;;; Emacsen running under the same username.
|
|
|
2333 ;;;
|
|
|
2334 ;;; The vc-next-action code has the following windows:
|
|
|
2335 ;;;
|
|
|
2336 ;;; Window P:
|
|
|
2337 ;;; Between the check for existence of a master file and the call to
|
|
|
2338 ;;; admin/checkin in vc-buffer-admin (apparent state A). This window may
|
|
|
2339 ;;; never close if the initial-comment feature is on.
|
|
|
2340 ;;;
|
|
|
2341 ;;; Window Q:
|
|
|
2342 ;;; Between the call to vc-workfile-unchanged-p in and the immediately
|
|
|
2343 ;;; following revert (apparent state C).
|
|
|
2344 ;;;
|
|
|
2345 ;;; Window R:
|
|
|
2346 ;;; Between the call to vc-workfile-unchanged-p in and the following
|
|
|
2347 ;;; checkin (apparent state D). This window may never close.
|
|
|
2348 ;;;
|
|
|
2349 ;;; Window S:
|
|
|
2350 ;;; Between the unlock and the immediately following checkout during a
|
|
|
2351 ;;; revert operation (apparent state C). Included in window Q.
|
|
|
2352 ;;;
|
|
|
2353 ;;; Window T:
|
|
|
2354 ;;; Between vc-locking-user and the following checkout (apparent state B).
|
|
|
2355 ;;;
|
|
|
2356 ;;; Window U:
|
|
|
2357 ;;; Between vc-locking-user and the following revert (apparent state C).
|
|
|
2358 ;;; Includes windows Q and S.
|
|
|
2359 ;;;
|
|
|
2360 ;;; Window V:
|
|
|
2361 ;;; Between vc-locking-user and the following checkin (apparent state
|
|
|
2362 ;;; D). This window may never be closed if the user fails to complete the
|
|
|
2363 ;;; checkin message. Includes window R.
|
|
|
2364 ;;;
|
|
|
2365 ;;; Window W:
|
|
|
2366 ;;; Between vc-locking-user and the following steal-lock (apparent
|
|
|
2367 ;;; state E). This window may never close if the user fails to complete
|
|
|
2368 ;;; the steal-lock message. Includes window X.
|
|
|
2369 ;;;
|
|
|
2370 ;;; Window X:
|
|
|
2371 ;;; Between the unlock and the immediately following re-lock during a
|
|
|
2372 ;;; steal-lock operation (apparent state E). This window may never cloce
|
|
|
2373 ;;; if the user fails to complete the steal-lock message.
|
|
|
2374 ;;;
|
|
|
2375 ;;; Errors:
|
|
|
2376 ;;;
|
|
|
2377 ;;; Apparent state A ---
|
|
|
2378 ;;;
|
|
|
2379 ;;; 1. File looked unregistered but is actually registered and not locked.
|
|
|
2380 ;;;
|
|
|
2381 ;;; Potential cause: someone else's admin during window P, with
|
|
|
2382 ;;; caller's admin happening before their checkout.
|
|
|
2383 ;;;
|
|
|
2384 ;;; RCS: ci will fail with a "no lock set by <user>" message.
|
|
|
2385 ;;; SCCS: admin will fail with error (ad19).
|
|
|
2386 ;;;
|
|
|
2387 ;;; We can let these errors be passed up to the user.
|
|
|
2388 ;;;
|
|
|
2389 ;;; 2. File looked unregistered but is actually locked by caller, unchanged.
|
|
|
2390 ;;;
|
|
|
2391 ;;; Potential cause: self-race during window P.
|
|
|
2392 ;;;
|
|
|
2393 ;;; RCS: will revert the file to the last saved version and unlock it.
|
|
|
2394 ;;; SCCS: will fail with error (ad19).
|
|
|
2395 ;;;
|
|
|
2396 ;;; Either of these consequences is acceptable.
|
|
|
2397 ;;;
|
|
|
2398 ;;; 3. File looked unregistered but is actually locked by caller, changed.
|
|
|
2399 ;;;
|
|
|
2400 ;;; Potential cause: self-race during window P.
|
|
|
2401 ;;;
|
|
|
2402 ;;; RCS: will register the caller's workfile as a delta with a
|
|
|
2403 ;;; null change comment (the -t- switch will be ignored).
|
|
|
2404 ;;; SCCS: will fail with error (ad19).
|
|
|
2405 ;;;
|
|
|
2406 ;;; 4. File looked unregistered but is locked by someone else.
|
|
|
2407 ;;;
|
|
|
2408 ;;; Potential cause: someone else's admin during window P, with
|
|
|
2409 ;;; caller's admin happening *after* their checkout.
|
|
|
2410 ;;;
|
|
|
2411 ;;; RCS: will fail with a "no lock set by <user>" message.
|
|
|
2412 ;;; SCCS: will fail with error (ad19).
|
|
|
2413 ;;;
|
|
|
2414 ;;; We can let these errors be passed up to the user.
|
|
|
2415 ;;;
|
|
|
2416 ;;; Apparent state B ---
|
|
|
2417 ;;;
|
|
|
2418 ;;; 5. File looked registered and not locked, but is actually unregistered.
|
|
|
2419 ;;;
|
|
|
2420 ;;; Potential cause: master file got nuked during window P.
|
|
|
2421 ;;;
|
|
|
2422 ;;; RCS: will fail with "RCS/<file>: No such file or directory"
|
|
|
2423 ;;; SCCS: will fail with error ut4.
|
|
|
2424 ;;;
|
|
|
2425 ;;; We can let these errors be passed up to the user.
|
|
|
2426 ;;;
|
|
|
2427 ;;; 6. File looked registered and not locked, but is actually locked by the
|
|
|
2428 ;;; calling user and unchanged.
|
|
|
2429 ;;;
|
|
|
2430 ;;; Potential cause: self-race during window T.
|
|
|
2431 ;;;
|
|
|
2432 ;;; RCS: in the same directory as the previous workfile, co -l will fail
|
|
|
2433 ;;; with "co error: writable foo exists; checkout aborted". In any other
|
|
|
2434 ;;; directory, checkout will succeed.
|
|
|
2435 ;;; SCCS: will fail with ge17.
|
|
|
2436 ;;;
|
|
|
2437 ;;; Either of these consequences is acceptable.
|
|
|
2438 ;;;
|
|
|
2439 ;;; 7. File looked registered and not locked, but is actually locked by the
|
|
|
2440 ;;; calling user and changed.
|
|
|
2441 ;;;
|
|
|
2442 ;;; As case 6.
|
|
|
2443 ;;;
|
|
|
2444 ;;; 8. File looked registered and not locked, but is actually locked by another
|
|
|
2445 ;;; user.
|
|
|
2446 ;;;
|
|
|
2447 ;;; Potential cause: someone else checks it out during window T.
|
|
|
2448 ;;;
|
|
|
2449 ;;; RCS: co error: revision 1.3 already locked by <user>
|
|
|
2450 ;;; SCCS: fails with ge4 (in directory) or ut7 (outside it).
|
|
|
2451 ;;;
|
|
|
2452 ;;; We can let these errors be passed up to the user.
|
|
|
2453 ;;;
|
|
|
2454 ;;; Apparent state C ---
|
|
|
2455 ;;;
|
|
|
2456 ;;; 9. File looks locked by calling user and unchanged, but is unregistered.
|
|
|
2457 ;;;
|
|
|
2458 ;;; As case 5.
|
|
|
2459 ;;;
|
|
|
2460 ;;; 10. File looks locked by calling user and unchanged, but is actually not
|
|
|
2461 ;;; locked.
|
|
|
2462 ;;;
|
|
|
2463 ;;; Potential cause: a self-race in window U, or by the revert's
|
|
|
2464 ;;; landing during window X of some other user's steal-lock or window S
|
|
|
2465 ;;; of another user's revert.
|
|
|
2466 ;;;
|
|
|
2467 ;;; RCS: succeeds, refreshing the file from the identical version in
|
|
|
2468 ;;; the master.
|
|
|
2469 ;;; SCCS: fails with error ut4 (p file nonexistent).
|
|
|
2470 ;;;
|
|
|
2471 ;;; Either of these consequences is acceptable.
|
|
|
2472 ;;;
|
|
|
2473 ;;; 11. File is locked by calling user. It looks unchanged, but is actually
|
|
|
2474 ;;; changed.
|
|
|
2475 ;;;
|
|
|
2476 ;;; Potential cause: the file would have to be touched by a self-race
|
|
|
2477 ;;; during window Q.
|
|
|
2478 ;;;
|
|
|
2479 ;;; The revert will succeed, removing whatever changes came with
|
|
|
2480 ;;; the touch. It is theoretically possible that work could be lost.
|
|
|
2481 ;;;
|
|
|
2482 ;;; 12. File looks like it's locked by the calling user and unchanged, but
|
|
|
2483 ;;; it's actually locked by someone else.
|
|
|
2484 ;;;
|
|
|
2485 ;;; Potential cause: a steal-lock in window V.
|
|
|
2486 ;;;
|
|
|
2487 ;;; RCS: co error: revision <rev> locked by <user>; use co -r or rcs -u
|
|
|
2488 ;;; SCCS: fails with error un2
|
|
|
2489 ;;;
|
|
|
2490 ;;; We can pass these errors up to the user.
|
|
|
2491 ;;;
|
|
|
2492 ;;; Apparent state D ---
|
|
|
2493 ;;;
|
|
|
2494 ;;; 13. File looks like it's locked by the calling user and changed, but it's
|
|
|
2495 ;;; actually unregistered.
|
|
|
2496 ;;;
|
|
|
2497 ;;; Potential cause: master file got nuked during window P.
|
|
|
2498 ;;;
|
|
|
2499 ;;; RCS: Checks in the user's version as an initial delta.
|
|
|
2500 ;;; SCCS: will fail with error ut4.
|
|
|
2501 ;;;
|
|
|
2502 ;;; This case is kind of nasty. It means VC may fail to detect the
|
|
|
2503 ;;; loss of previous version information.
|
|
|
2504 ;;;
|
|
|
2505 ;;; 14. File looks like it's locked by the calling user and changed, but it's
|
|
|
2506 ;;; actually unlocked.
|
|
|
2507 ;;;
|
|
|
2508 ;;; Potential cause: self-race in window V, or the checkin happening
|
|
|
2509 ;;; during the window X of someone else's steal-lock or window S of
|
|
|
2510 ;;; someone else's revert.
|
|
|
2511 ;;;
|
|
|
2512 ;;; RCS: ci will fail with "no lock set by <user>".
|
|
|
2513 ;;; SCCS: delta will fail with error ut4.
|
|
|
2514 ;;;
|
|
|
2515 ;;; 15. File looks like it's locked by the calling user and changed, but it's
|
|
|
2516 ;;; actually locked by the calling user and unchanged.
|
|
|
2517 ;;;
|
|
|
2518 ;;; Potential cause: another self-race --- a whole checkin/checkout
|
|
|
2519 ;;; sequence by the calling user would have to land in window R.
|
|
|
2520 ;;;
|
|
|
2521 ;;; SCCS: checks in a redundant delta and leaves the file unlocked as usual.
|
|
|
2522 ;;; RCS: reverts to the file state as of the second user's checkin, leaving
|
|
|
2523 ;;; the file unlocked.
|
|
|
2524 ;;;
|
|
|
2525 ;;; It is theoretically possible that work could be lost under RCS.
|
|
|
2526 ;;;
|
|
|
2527 ;;; 16. File looks like it's locked by the calling user and changed, but it's
|
|
|
2528 ;;; actually locked by a different user.
|
|
|
2529 ;;;
|
|
|
2530 ;;; RCS: ci error: no lock set by <user>
|
|
|
2531 ;;; SCCS: unget will fail with error un2
|
|
|
2532 ;;;
|
|
|
2533 ;;; We can pass these errors up to the user.
|
|
|
2534 ;;;
|
|
|
2535 ;;; Apparent state E ---
|
|
|
2536 ;;;
|
|
|
2537 ;;; 17. File looks like it's locked by some other user, but it's actually
|
|
|
2538 ;;; unregistered.
|
|
|
2539 ;;;
|
|
|
2540 ;;; As case 13.
|
|
|
2541 ;;;
|
|
|
2542 ;;; 18. File looks like it's locked by some other user, but it's actually
|
|
|
2543 ;;; unlocked.
|
|
|
2544 ;;;
|
|
|
2545 ;;; Potential cause: someone released a lock during window W.
|
|
|
2546 ;;;
|
|
|
2547 ;;; RCS: The calling user will get the lock on the file.
|
|
|
2548 ;;; SCCS: unget -n will fail with cm4.
|
|
|
2549 ;;;
|
|
|
2550 ;;; Either of these consequences will be OK.
|
|
|
2551 ;;;
|
|
|
2552 ;;; 19. File looks like it's locked by some other user, but it's actually
|
|
|
2553 ;;; locked by the calling user and unchanged.
|
|
|
2554 ;;;
|
|
|
2555 ;;; Potential cause: the other user relinquishing a lock followed by
|
|
|
2556 ;;; a self-race, both in window W.
|
|
|
2557 ;;;
|
|
|
2558 ;;; Under both RCS and SCCS, both unlock and lock will succeed, making
|
|
|
2559 ;;; the sequence a no-op.
|
|
|
2560 ;;;
|
|
|
2561 ;;; 20. File looks like it's locked by some other user, but it's actually
|
|
|
2562 ;;; locked by the calling user and changed.
|
|
|
2563 ;;;
|
|
|
2564 ;;; As case 19.
|
|
|
2565 ;;;
|
|
|
2566 ;;; PROBLEM CASES:
|
|
|
2567 ;;;
|
|
|
2568 ;;; In order of decreasing severity:
|
|
|
2569 ;;;
|
|
|
2570 ;;; Cases 11 and 15 under RCS are the only one that potentially lose work.
|
|
|
2571 ;;; They would require a self-race for this to happen.
|
|
|
2572 ;;;
|
|
|
2573 ;;; Case 13 in RCS loses information about previous deltas, retaining
|
|
|
2574 ;;; only the information in the current workfile. This can only happen
|
|
|
2575 ;;; if the master file gets nuked in window P.
|
|
|
2576 ;;;
|
|
|
2577 ;;; Case 3 in RCS and case 15 under SCCS insert a redundant delta with
|
|
|
2578 ;;; no change comment in the master. This would require a self-race in
|
|
|
2579 ;;; window P or R respectively.
|
|
|
2580 ;;;
|
|
|
2581 ;;; Cases 2, 10, 19 and 20 do extra work, but make no changes.
|
|
|
2582 ;;;
|
|
|
2583 ;;; Unfortunately, it appears to me that no recovery is possible in these
|
|
|
2584 ;;; cases. They don't yield error messages, so there's no way to tell that
|
|
|
2585 ;;; a race condition has occurred.
|
|
|
2586 ;;;
|
|
|
2587 ;;; All other cases don't change either the workfile or the master, and
|
|
|
2588 ;;; trigger command errors which the user will see.
|
|
|
2589 ;;;
|
|
|
2590 ;;; Thus, there is no explicit recovery code.
|
|
|
2591
|
|
|
2592 ;;; vc.el ends here
|
