(auto-image-file-mode): Drop unneeded positional args.
[emacs.git] / lisp / vc-hooks.el
blobd3ac65171871bb10530bc11546bae8cfdb0591fa
1 ;;; vc-hooks.el --- resident support for version-control
3 ;; Copyright (C) 1992,93,94,95,96,98,99,2000 Free Software Foundation, Inc.
5 ;; Author: FSF (see vc.el for full credits)
6 ;; Maintainer: Andre Spiegel <spiegel@gnu.org>
8 ;; $Id: vc-hooks.el,v 1.125 2000/10/27 12:11:55 spiegel Exp $
10 ;; This file is part of GNU Emacs.
12 ;; GNU Emacs is free software; you can redistribute it and/or modify
13 ;; it 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.
17 ;; GNU Emacs is distributed in the hope that it will be useful,
18 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
19 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 ;; GNU General Public License for more details.
22 ;; You should have received a copy of the GNU General Public License
23 ;; along with GNU Emacs; 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.
27 ;;; Commentary:
29 ;; This is the always-loaded portion of VC. It takes care of
30 ;; VC-related activities that are done when you visit a file, so that
31 ;; vc.el itself is loaded only when you use a VC command. See the
32 ;; commentary of vc.el.
34 ;;; Code:
36 ;(eval-when-compile
37 ; (require 'vc))
39 ;; Customization Variables (the rest is in vc.el)
41 (defvar vc-ignore-vc-files nil "Obsolete -- use `vc-handled-backends'.")
42 (defvar vc-master-templates () "Obsolete -- use vc-BACKEND-master-templates.")
43 (defvar vc-header-alist () "Obsolete -- use vc-BACKEND-header.")
45 (defcustom vc-handled-backends '(RCS CVS SCCS)
46 "*List of version control backends for which VC will be used.
47 Entries in this list will be tried in order to determine whether a
48 file is under that sort of version control.
49 Removing an entry from the list prevents VC from being activated
50 when visiting a file managed by that backend.
51 An empty list disables VC altogether."
52 :type '(repeat symbol)
53 :version "21.1"
54 :group 'vc)
56 (defcustom vc-path
57 (if (file-directory-p "/usr/sccs")
58 '("/usr/sccs")
59 nil)
60 "*List of extra directories to search for version control commands."
61 :type '(repeat directory)
62 :group 'vc)
64 (defcustom vc-make-backup-files nil
65 "*If non-nil, backups of registered files are made as with other files.
66 If nil (the default), files covered by version control don't get backups."
67 :type 'boolean
68 :group 'vc)
70 (defcustom vc-follow-symlinks 'ask
71 "*What to do if visiting a symbolic link to a file under version control.
72 Editing such a file through the link bypasses the version control system,
73 which is dangerous and probably not what you want.
75 If this variable is t, VC follows the link and visits the real file,
76 telling you about it in the echo area. If it is `ask', VC asks for
77 confirmation whether it should follow the link. If nil, the link is
78 visited and a warning displayed."
79 :type '(choice (const :tag "Ask for confirmation" ask)
80 (const :tag "Visit link and warn" nil)
81 (const :tag "Follow link" t))
82 :group 'vc)
84 (defcustom vc-display-status t
85 "*If non-nil, display revision number and lock status in modeline.
86 Otherwise, not displayed."
87 :type 'boolean
88 :group 'vc)
91 (defcustom vc-consult-headers t
92 "*If non-nil, identify work files by searching for version headers."
93 :type 'boolean
94 :group 'vc)
96 (defcustom vc-keep-workfiles t
97 "*If non-nil, don't delete working files after registering changes.
98 If the back-end is CVS, workfiles are always kept, regardless of the
99 value of this flag."
100 :type 'boolean
101 :group 'vc)
103 (defcustom vc-mistrust-permissions nil
104 "*If non-nil, don't assume permissions/ownership track version-control status.
105 If nil, do rely on the permissions.
106 See also variable `vc-consult-headers'."
107 :type 'boolean
108 :group 'vc)
110 (defun vc-mistrust-permissions (file)
111 "Internal access function to variable `vc-mistrust-permissions' for FILE."
112 (or (eq vc-mistrust-permissions 't)
113 (and vc-mistrust-permissions
114 (funcall vc-mistrust-permissions
115 (vc-backend-subdirectory-name file)))))
117 ;; Tell Emacs about this new kind of minor mode
118 (add-to-list 'minor-mode-alist '(vc-mode vc-mode))
120 (make-variable-buffer-local 'vc-mode)
121 (put 'vc-mode 'permanent-local t)
123 (defmacro vc-error-occurred (&rest body)
124 (list 'condition-case nil (cons 'progn (append body '(nil))) '(error t)))
126 ;; We need a notion of per-file properties because the version
127 ;; control state of a file is expensive to derive --- we compute
128 ;; them when the file is initially found, keep them up to date
129 ;; during any subsequent VC operations, and forget them when
130 ;; the buffer is killed.
132 (defvar vc-file-prop-obarray (make-vector 16 0)
133 "Obarray for per-file properties.")
135 (defvar vc-touched-properties nil)
137 (defun vc-file-setprop (file property value)
138 "Set per-file VC PROPERTY for FILE to VALUE."
139 (if (and vc-touched-properties
140 (not (memq property vc-touched-properties)))
141 (setq vc-touched-properties (append (list property)
142 vc-touched-properties)))
143 (put (intern file vc-file-prop-obarray) property value))
145 (defun vc-file-getprop (file property)
146 "Get per-file VC PROPERTY for FILE."
147 (get (intern file vc-file-prop-obarray) property))
149 (defun vc-file-clearprops (file)
150 "Clear all VC properties of FILE."
151 (setplist (intern file vc-file-prop-obarray) nil))
154 ;; We keep properties on each symbol naming a backend as follows:
155 ;; * `vc-functions': an alist mapping vc-FUNCTION to vc-BACKEND-FUNCTION.
157 (defun vc-make-backend-sym (backend sym)
158 "Return BACKEND-specific version of VC symbol SYM."
159 (intern (concat "vc-" (downcase (symbol-name backend))
160 "-" (symbol-name sym))))
162 (defun vc-find-backend-function (backend fun)
163 "Return BACKEND-specific implementation of FUN.
164 If there is no such implementation, return the default implementation;
165 if that doesn't exist either, return nil."
166 (let ((f (vc-make-backend-sym backend fun)))
167 (if (fboundp f) f
168 ;; Load vc-BACKEND.el if needed.
169 (require (intern (concat "vc-" (downcase (symbol-name backend)))))
170 (if (fboundp f) f
171 (let ((def (vc-make-backend-sym 'default fun)))
172 (if (fboundp def) (cons def backend) nil))))))
174 (defun vc-call-backend (backend function-name &rest args)
175 "Call for BACKEND the implementation of FUNCTION-NAME with the given ARGS.
176 Calls
178 (apply 'vc-BACKEND-FUN ARGS)
180 if vc-BACKEND-FUN exists (after trying to find it in vc-BACKEND.el)
181 and else calls
183 (apply 'vc-default-FUN BACKEND ARGS)
185 It is usually called via the `vc-call' macro."
186 (let ((f (cdr (assoc function-name (get backend 'vc-functions)))))
187 (unless f
188 (setq f (vc-find-backend-function backend function-name))
189 (put backend 'vc-functions (cons (cons function-name f)
190 (get backend 'vc-functions))))
191 (if (consp f)
192 (apply (car f) (cdr f) args)
193 (apply f args))))
195 (defmacro vc-call (fun file &rest args)
196 ;; BEWARE!! `file' is evaluated twice!!
197 `(vc-call-backend (vc-backend ,file) ',fun ,file ,@args))
200 (defsubst vc-parse-buffer (pattern i)
201 "Find PATTERN in the current buffer and return its Ith submatch."
202 (goto-char (point-min))
203 (if (re-search-forward pattern nil t)
204 (match-string i)))
206 (defun vc-insert-file (file &optional limit blocksize)
207 "Insert the contents of FILE into the current buffer.
209 Optional argument LIMIT is a regexp. If present, the file is inserted
210 in chunks of size BLOCKSIZE (default 8 kByte), until the first
211 occurrence of LIMIT is found. The function returns nil if FILE doesn't
212 exist."
213 (erase-buffer)
214 (cond ((file-exists-p file)
215 (cond (limit
216 (if (not blocksize) (setq blocksize 8192))
217 (let (found s)
218 (while (not found)
219 (setq s (buffer-size))
220 (goto-char (1+ s))
221 (setq found
222 (or (zerop (cadr (insert-file-contents
223 file nil s (+ s blocksize))))
224 (progn (beginning-of-line)
225 (re-search-forward limit nil t)))))))
226 (t (insert-file-contents file)))
227 (set-buffer-modified-p nil)
228 (auto-save-mode nil)
230 (t nil)))
232 ;;; Access functions to file properties
233 ;;; (Properties should be _set_ using vc-file-setprop, but
234 ;;; _retrieved_ only through these functions, which decide
235 ;;; if the property is already known or not. A property should
236 ;;; only be retrieved by vc-file-getprop if there is no
237 ;;; access function.)
239 ;;; properties indicating the backend being used for FILE
241 (defun vc-registered (file)
242 "Return non-nil if FILE is registered in a version control system.
244 This function performs the check each time it is called. To rely
245 on the result of a previous call, use `vc-backend' instead. If the
246 file was previously registered under a certain backend, then that
247 backend is tried first."
248 (let (handler)
249 (if (boundp 'file-name-handler-alist)
250 (setq handler (find-file-name-handler file 'vc-registered)))
251 (if handler
252 ;; handler should set vc-backend and return t if registered
253 (funcall handler 'vc-registered file)
254 ;; There is no file name handler.
255 ;; Try vc-BACKEND-registered for each handled BACKEND.
256 (catch 'found
257 (let ((backend (vc-file-getprop file 'vc-backend)))
258 (mapcar
259 (lambda (b)
260 (and (vc-call-backend b 'registered file)
261 (vc-file-setprop file 'vc-backend b)
262 (throw 'found t)))
263 (if (or (not backend) (eq backend 'none))
264 vc-handled-backends
265 (cons backend vc-handled-backends))))
266 ;; File is not registered.
267 (vc-file-setprop file 'vc-backend 'none)
268 nil))))
270 (defun vc-backend (file)
271 "Return the version control type of FILE, nil if it is not registered."
272 ;; `file' can be nil in several places (typically due to the use of
273 ;; code like (vc-backend (buffer-file-name))).
274 (when (stringp file)
275 (let ((property (vc-file-getprop file 'vc-backend)))
276 ;; Note that internally, Emacs remembers unregistered
277 ;; files by setting the property to `none'.
278 (cond ((eq property 'none) nil)
279 (property)
280 ;; vc-registered sets the vc-backend property
281 (t (if (vc-registered file)
282 (vc-file-getprop file 'vc-backend)
283 nil))))))
285 (defun vc-backend-subdirectory-name (file)
286 "Return where the master and lock FILEs for the current directory are kept."
287 (symbol-name (vc-backend file)))
289 (defun vc-name (file)
290 "Return the master name of FILE.
291 If the file is not registered, or the master name is not known, return nil."
292 ;; TODO: This should ultimately become obsolete, at least up here
293 ;; in vc-hooks.
294 (or (vc-file-getprop file 'vc-name)
295 ;; force computation of the property by calling
296 ;; vc-BACKEND-registered explicitly
297 (if (and (vc-backend file)
298 (vc-call-backend (vc-backend file) 'registered file))
299 (vc-file-getprop file 'vc-name))))
301 (defun vc-checkout-model (file)
302 "Indicate how FILE is checked out.
304 Possible values:
306 'implicit File is always writeable, and checked out `implicitly'
307 when the user saves the first changes to the file.
309 'locking File is read-only if up-to-date; user must type
310 \\[vc-toggle-read-only] before editing. Strict locking
311 is assumed.
313 'announce File is read-only if up-to-date; user must type
314 \\[vc-toggle-read-only] before editing. But other users
315 may be editing at the same time."
316 (or (vc-file-getprop file 'vc-checkout-model)
317 (vc-file-setprop file 'vc-checkout-model
318 (vc-call checkout-model file))))
320 (defun vc-user-login-name (&optional uid)
321 "Return the name under which the user is logged in, as a string.
322 \(With optional argument UID, return the name of that user.)
323 This function does the same as function `user-login-name', but unlike
324 that, it never returns nil. If a UID cannot be resolved, that
325 UID is returned as a string."
326 (or (user-login-name uid)
327 (number-to-string (or uid (user-uid)))))
329 (defun vc-state (file)
330 "Return the version control state of FILE.
332 The value returned is one of:
334 'up-to-date The working file is unmodified with respect to the
335 latest version on the current branch, and not locked.
337 'edited The working file has been edited by the user. If
338 locking is used for the file, this state means that
339 the current version is locked by the calling user.
341 USER The current version of the working file is locked by
342 some other USER (a string).
344 'needs-patch The file has not been edited by the user, but there is
345 a more recent version on the current branch stored
346 in the master file.
348 'needs-merge The file has been edited by the user, and there is also
349 a more recent version on the current branch stored in
350 the master file. This state can only occur if locking
351 is not used for the file.
353 'unlocked-changes The current version of the working file is not locked,
354 but the working file has been changed with respect
355 to that version. This state can only occur for files
356 with locking; it represents an erroneous condition that
357 should be resolved by the user (vc-next-action will
358 prompt the user to do it)."
359 (or (vc-file-getprop file 'vc-state)
360 (vc-file-setprop file 'vc-state
361 (vc-call state-heuristic file))))
363 (defsubst vc-up-to-date-p (file)
364 "Convenience function that checks whether `vc-state' of FILE is `up-to-date'."
365 (eq (vc-state file) 'up-to-date))
367 (defun vc-default-state-heuristic (backend file)
368 "Default implementation of vc-state-heuristic.
369 It simply calls the real state computation function `vc-BACKEND-state'
370 and does not employ any heuristic at all."
371 (vc-call-backend backend 'state file))
373 (defun vc-workfile-version (file)
374 "Return version level of the current workfile FILE."
375 (or (vc-file-getprop file 'vc-workfile-version)
376 (vc-file-setprop file 'vc-workfile-version
377 (vc-call workfile-version file))))
379 ;;; actual version-control code starts here
381 (defun vc-default-registered (backend file)
382 "Check if FILE is registered in BACKEND using vc-BACKEND-master-templates."
383 (let ((sym (vc-make-backend-sym backend 'master-templates)))
384 (unless (get backend 'vc-templates-grabbed)
385 (put backend 'vc-templates-grabbed t)
386 (set sym (append (delq nil
387 (mapcar
388 (lambda (template)
389 (and (consp template)
390 (eq (cdr template) backend)
391 (car template)))
392 vc-master-templates))
393 (symbol-value sym))))
394 (let ((result (vc-check-master-templates file (symbol-value sym))))
395 (if (stringp result)
396 (vc-file-setprop file 'vc-name result)
397 nil)))) ; Not registered
399 (defun vc-possible-master (s dirname basename)
400 (cond
401 ((stringp s) (format s dirname basename))
402 ((functionp s)
403 ;; The template is a function to invoke. If the
404 ;; function returns non-nil, that means it has found a
405 ;; master. For backward compatibility, we also handle
406 ;; the case that the function throws a 'found atom
407 ;; and a pair (cons MASTER-FILE BACKEND).
408 (let ((result (catch 'found (funcall s dirname basename))))
409 (if (consp result) (car result) result)))))
411 (defun vc-check-master-templates (file templates)
412 "Return non-nil if there is a master corresponding to FILE,
413 according to any of the elements in TEMPLATES.
415 TEMPLATES is a list of strings or functions. If an element is a
416 string, it must be a control string as required by `format', with two
417 string placeholders, such as \"%sRCS/%s,v\". The directory part of
418 FILE is substituted for the first placeholder, the basename of FILE
419 for the second. If a file with the resulting name exists, it is taken
420 as the master of FILE, and returned.
422 If an element of TEMPLATES is a function, it is called with the
423 directory part and the basename of FILE as arguments. It should
424 return non-nil if it finds a master; that value is then returned by
425 this function."
426 (let ((dirname (or (file-name-directory file) ""))
427 (basename (file-name-nondirectory file)))
428 (catch 'found
429 (mapcar
430 (lambda (s)
431 (let ((trial (vc-possible-master s dirname basename)))
432 (if (and trial (file-exists-p trial)
433 ;; Make sure the file we found with name
434 ;; TRIAL is not the source file itself.
435 ;; That can happen with RCS-style names if
436 ;; the file name is truncated (e.g. to 14
437 ;; chars). See if either directory or
438 ;; attributes differ.
439 (or (not (string= dirname
440 (file-name-directory trial)))
441 (not (equal (file-attributes file)
442 (file-attributes trial)))))
443 (throw 'found trial))))
444 templates))))
446 (defun vc-toggle-read-only (&optional verbose)
447 "Change read-only status of current buffer, perhaps via version control.
448 If the buffer is visiting a file registered with version control,
449 then check the file in or out. Otherwise, just change the read-only flag
450 of the buffer.
451 With prefix argument, ask for version number to check in or check out.
452 Check-out of a specified version number does not lock the file;
453 to do that, use this command a second time with no argument."
454 (interactive "P")
455 (if (or (and (boundp 'vc-dired-mode) vc-dired-mode)
456 ;; use boundp because vc.el might not be loaded
457 (vc-backend (buffer-file-name)))
458 (vc-next-action verbose)
459 (toggle-read-only)))
460 (define-key global-map "\C-x\C-q" 'vc-toggle-read-only)
462 (defun vc-default-make-version-backups-p (backend file)
463 "Return non-nil if unmodified repository versions should
464 be backed up locally. The default is to switch off this feature."
465 nil)
467 (defun vc-version-backup-file-name (file &optional rev manual regexp)
468 "Return a backup file name for REV or the current version of FILE.
469 If MANUAL is non-nil it means that a name for backups created by
470 the user should be returned; if REGEXP is non-nil that means to return
471 a regexp for matching all such backup files, regardless of the version."
472 (if regexp
473 (concat (regexp-quote (file-name-nondirectory file))
474 "\\.~[0-9.]+" (unless manual "\\.") "~")
475 (expand-file-name (concat (file-name-nondirectory file)
476 ".~" (or rev (vc-workfile-version file))
477 (unless manual ".") "~")
478 (file-name-directory file))))
480 (defun vc-delete-automatic-version-backups (file)
481 "Delete all existing automatic version backups for FILE."
482 (mapcar
483 (lambda (f)
484 (delete-file f))
485 (directory-files (file-name-directory file) t
486 (vc-version-backup-file-name file nil nil t))))
488 (defun vc-make-version-backup (file)
489 "Make a backup copy of FILE, which is assumed in sync with the repository.
490 Before doing that, check if there are any old backups and get rid of them."
491 (unless (and (fboundp 'msdos-long-file-names)
492 (not (msdos-long-file-names)))
493 (vc-delete-automatic-version-backups file)
494 (copy-file file (vc-version-backup-file-name file)
495 nil 'keep-date)))
497 (defun vc-before-save ()
498 "Function to be called by `basic-save-buffer' (in files.el)."
499 ;; If the file on disk is still in sync with the repository,
500 ;; and version backups should be made, copy the file to
501 ;; another name. This enables local diffs and local reverting.
502 (let ((file (buffer-file-name)))
503 (and (vc-backend file)
504 (vc-up-to-date-p file)
505 (eq (vc-checkout-model file) 'implicit)
506 (vc-call make-version-backups-p file)
507 (vc-make-version-backup file))))
509 (defun vc-after-save ()
510 "Function to be called by `basic-save-buffer' (in files.el)."
511 ;; If the file in the current buffer is under version control,
512 ;; up-to-date, and locking is not used for the file, set
513 ;; the state to 'edited and redisplay the mode line.
514 (let ((file (buffer-file-name)))
515 (and (vc-backend file)
516 (or (and (equal (vc-file-getprop file 'vc-checkout-time)
517 (nth 5 (file-attributes file)))
518 ;; File has been saved in the same second in which
519 ;; it was checked out. Clear the checkout-time
520 ;; to avoid confusion.
521 (vc-file-setprop file 'vc-checkout-time nil))
523 (vc-up-to-date-p file)
524 (eq (vc-checkout-model file) 'implicit)
525 (vc-file-setprop file 'vc-state 'edited)
526 (vc-mode-line file)
527 (if (featurep 'vc)
528 ;; If VC is not loaded, then there can't be
529 ;; any VC Dired buffer to synchronize.
530 (vc-dired-resynch-file file)))))
532 (defun vc-mode-line (file)
533 "Set `vc-mode' to display type of version control for FILE.
534 The value is set in the current buffer, which should be the buffer
535 visiting FILE."
536 (interactive (list buffer-file-name))
537 (unless (not (vc-backend file))
538 (setq vc-mode (concat " " (if vc-display-status
539 (vc-call mode-line-string file)
540 (symbol-name (vc-backend file)))))
541 ;; If the file is locked by some other user, make
542 ;; the buffer read-only. Like this, even root
543 ;; cannot modify a file that someone else has locked.
544 (and (equal file (buffer-file-name))
545 (stringp (vc-state file))
546 (setq buffer-read-only t))
547 ;; If the user is root, and the file is not owner-writable,
548 ;; then pretend that we can't write it
549 ;; even though we can (because root can write anything).
550 ;; This way, even root cannot modify a file that isn't locked.
551 (and (equal file (buffer-file-name))
552 (not buffer-read-only)
553 (zerop (user-real-uid))
554 (zerop (logand (file-modes (buffer-file-name)) 128))
555 (setq buffer-read-only t)))
556 (force-mode-line-update)
557 (vc-backend file))
559 (defun vc-default-mode-line-string (backend file)
560 "Return string for placement in modeline by `vc-mode-line' for FILE.
561 Format:
563 \"BACKEND-REV\" if the file is up-to-date
564 \"BACKEND:REV\" if the file is edited (or locked by the calling user)
565 \"BACKEND:LOCKER:REV\" if the file is locked by somebody else
567 This function assumes that the file is registered."
568 (setq backend (symbol-name backend))
569 (let ((state (vc-state file))
570 (rev (vc-workfile-version file)))
571 (cond ((or (eq state 'up-to-date)
572 (eq state 'needs-patch))
573 (concat backend "-" rev))
574 ((stringp state)
575 (concat backend ":" state ":" rev))
577 ;; Not just for the 'edited state, but also a fallback
578 ;; for all other states. Think about different symbols
579 ;; for 'needs-patch and 'needs-merge.
580 (concat backend ":" rev)))))
582 (defun vc-follow-link ()
583 "If current buffer visits a symbolic link, visit the real file.
584 If the real file is already visited in another buffer, make that buffer
585 current, and kill the buffer that visits the link."
586 (let* ((truename (abbreviate-file-name (file-chase-links buffer-file-name)))
587 (true-buffer (find-buffer-visiting truename))
588 (this-buffer (current-buffer)))
589 (if (eq true-buffer this-buffer)
590 (progn
591 (kill-buffer this-buffer)
592 ;; In principle, we could do something like set-visited-file-name.
593 ;; However, it can't be exactly the same as set-visited-file-name.
594 ;; I'm not going to work out the details right now. -- rms.
595 (set-buffer (find-file-noselect truename)))
596 (set-buffer true-buffer)
597 (kill-buffer this-buffer))))
599 (defun vc-find-file-hook ()
600 "Function for `find-file-hooks' activating VC mode if appropriate."
601 ;; Recompute whether file is version controlled,
602 ;; if user has killed the buffer and revisited.
603 (when buffer-file-name
604 (vc-file-clearprops buffer-file-name)
605 (cond
606 ((vc-backend buffer-file-name)
607 (vc-mode-line buffer-file-name)
608 (cond ((not vc-make-backup-files)
609 ;; Use this variable, not make-backup-files,
610 ;; because this is for things that depend on the file name.
611 (make-local-variable 'backup-inhibited)
612 (setq backup-inhibited t))))
613 ((let* ((link (file-symlink-p buffer-file-name))
614 (link-type (and link (vc-backend (file-chase-links link)))))
615 (if link-type
616 (cond ((eq vc-follow-symlinks nil)
617 (message
618 "Warning: symbolic link to %s-controlled source file" link-type))
619 ((or (not (eq vc-follow-symlinks 'ask))
620 ;; If we already visited this file by following
621 ;; the link, don't ask again if we try to visit
622 ;; it again. GUD does that, and repeated questions
623 ;; are painful.
624 (get-file-buffer
625 (abbreviate-file-name
626 (file-chase-links buffer-file-name))))
628 (vc-follow-link)
629 (message "Followed link to %s" buffer-file-name)
630 (vc-find-file-hook))
632 (if (yes-or-no-p (format
633 "Symbolic link to %s-controlled source file; follow link? " link-type))
634 (progn (vc-follow-link)
635 (message "Followed link to %s" buffer-file-name)
636 (vc-find-file-hook))
637 (message
638 "Warning: editing through the link bypasses version control")
639 )))))))))
641 (add-hook 'find-file-hooks 'vc-find-file-hook)
643 ;;; more hooks, this time for file-not-found
644 (defun vc-file-not-found-hook ()
645 "When file is not found, try to check it out from version control.
646 Returns t if checkout was successful, nil otherwise.
647 Used in `find-file-not-found-hooks'."
648 ;; When a file does not exist, ignore cached info about it
649 ;; from a previous visit.
650 (vc-file-clearprops buffer-file-name)
651 (if (and (vc-backend buffer-file-name)
652 (yes-or-no-p
653 (format "File %s was lost; check out from version control? "
654 (file-name-nondirectory buffer-file-name))))
655 (save-excursion
656 (require 'vc)
657 (setq default-directory (file-name-directory buffer-file-name))
658 (not (vc-error-occurred (vc-checkout buffer-file-name))))))
660 (add-hook 'find-file-not-found-hooks 'vc-file-not-found-hook)
662 (defun vc-kill-buffer-hook ()
663 "Discard VC info about a file when we kill its buffer."
664 (if (buffer-file-name)
665 (vc-file-clearprops (buffer-file-name))))
667 ;; ??? DL: why is this not done?
668 ;;;(add-hook 'kill-buffer-hook 'vc-kill-buffer-hook)
670 ;;; Now arrange for bindings and autoloading of the main package.
671 ;;; Bindings for this have to go in the global map, as we'll often
672 ;;; want to call them from random buffers.
674 (autoload 'vc-prefix-map "vc" nil nil 'keymap)
675 (define-key global-map "\C-xv" 'vc-prefix-map)
677 (if (not (boundp 'vc-menu-map))
678 ;; Don't do the menu bindings if menu-bar.el wasn't loaded to defvar
679 ;; vc-menu-map.
681 ;;(define-key vc-menu-map [show-files]
682 ;; '("Show Files under VC" . (vc-directory t)))
683 (define-key vc-menu-map [vc-retrieve-snapshot]
684 '("Retrieve Snapshot" . vc-retrieve-snapshot))
685 (define-key vc-menu-map [vc-create-snapshot]
686 '("Create Snapshot" . vc-create-snapshot))
687 (define-key vc-menu-map [vc-directory] '("VC Directory Listing" . vc-directory))
688 (define-key vc-menu-map [separator1] '("----"))
689 (define-key vc-menu-map [vc-annotate] '("Annotate" . vc-annotate))
690 (define-key vc-menu-map [vc-rename-file] '("Rename File" . vc-rename-file))
691 (define-key vc-menu-map [vc-version-other-window]
692 '("Show Other Version" . vc-version-other-window))
693 (define-key vc-menu-map [vc-diff] '("Compare with Last Version" . vc-diff))
694 (define-key vc-menu-map [vc-update-change-log]
695 '("Update ChangeLog" . vc-update-change-log))
696 (define-key vc-menu-map [vc-print-log] '("Show History" . vc-print-log))
697 (define-key vc-menu-map [separator2] '("----"))
698 (define-key vc-menu-map [undo] '("Undo Last Check-In" . vc-cancel-version))
699 (define-key vc-menu-map [vc-revert-buffer]
700 '("Revert to Last Version" . vc-revert-buffer))
701 (define-key vc-menu-map [vc-insert-header]
702 '("Insert Header" . vc-insert-headers))
703 (define-key vc-menu-map [vc-next-action] '("Check In/Out" . vc-next-action))
704 (define-key vc-menu-map [vc-register] '("Register" . vc-register)))
706 ;;; These are not correct and it's not currently clear how doing it
707 ;;; better (with more complicated expressions) might slow things down
708 ;;; on older systems.
710 ;;;(put 'vc-rename-file 'menu-enable 'vc-mode)
711 ;;;(put 'vc-annotate 'menu-enable '(eq (vc-buffer-backend) 'CVS))
712 ;;;(put 'vc-version-other-window 'menu-enable 'vc-mode)
713 ;;;(put 'vc-diff 'menu-enable 'vc-mode)
714 ;;;(put 'vc-update-change-log 'menu-enable
715 ;;; '(member (vc-buffer-backend) '(RCS CVS)))
716 ;;;(put 'vc-print-log 'menu-enable 'vc-mode)
717 ;;;(put 'vc-cancel-version 'menu-enable 'vc-mode)
718 ;;;(put 'vc-revert-buffer 'menu-enable 'vc-mode)
719 ;;;(put 'vc-insert-headers 'menu-enable 'vc-mode)
720 ;;;(put 'vc-next-action 'menu-enable 'vc-mode)
721 ;;;(put 'vc-register 'menu-enable '(and buffer-file-name (not vc-mode)))
723 (provide 'vc-hooks)
725 ;;; vc-hooks.el ends here