Commit | Line | Data |
---|---|---|
aae56ea7 | 1 | ;;; vc-hooks.el --- resident support for version-control |
594722a8 | 2 | |
0d30b337 | 3 | ;; Copyright (C) 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2002, |
aaef169d | 4 | ;; 2003, 2004, 2005, 2006 Free Software Foundation, Inc. |
594722a8 | 5 | |
0e0d9831 GM |
6 | ;; Author: FSF (see vc.el for full credits) |
7 | ;; Maintainer: Andre Spiegel <spiegel@gnu.org> | |
594722a8 | 8 | |
ce9f8ffb | 9 | ;; $Id$ |
f4c72097 | 10 | |
594722a8 ER |
11 | ;; This file is part of GNU Emacs. |
12 | ||
13 | ;; GNU Emacs is free software; you can redistribute it and/or modify | |
14 | ;; it under the terms of the GNU General Public License as published by | |
15 | ;; the Free Software Foundation; either version 2, or (at your option) | |
16 | ;; any later version. | |
17 | ||
18 | ;; GNU Emacs is distributed in the hope that it will be useful, | |
19 | ;; but WITHOUT ANY WARRANTY; without even the implied warranty of | |
20 | ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
21 | ;; GNU General Public License for more details. | |
22 | ||
23 | ;; You should have received a copy of the GNU General Public License | |
b578f267 | 24 | ;; along with GNU Emacs; see the file COPYING. If not, write to the |
086add15 LK |
25 | ;; Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, |
26 | ;; Boston, MA 02110-1301, USA. | |
594722a8 ER |
27 | |
28 | ;;; Commentary: | |
29 | ||
0e0d9831 GM |
30 | ;; This is the always-loaded portion of VC. It takes care of |
31 | ;; VC-related activities that are done when you visit a file, so that | |
32 | ;; vc.el itself is loaded only when you use a VC command. See the | |
33 | ;; commentary of vc.el. | |
594722a8 ER |
34 | |
35 | ;;; Code: | |
36 | ||
c3ce5e29 AS |
37 | (eval-when-compile |
38 | (require 'cl)) | |
099bd78a | 39 | |
e1c0c2d1 KH |
40 | ;; Customization Variables (the rest is in vc.el) |
41 | ||
e18cf2ee | 42 | (defvar vc-ignore-vc-files nil) |
5499f9dc | 43 | (make-obsolete-variable 'vc-ignore-vc-files |
3dab70bf | 44 | "set `vc-handled-backends' to nil to disable VC.") |
5499f9dc | 45 | |
e18cf2ee | 46 | (defvar vc-master-templates ()) |
0d2ce4ef JB |
47 | (make-obsolete-variable 'vc-master-templates |
48 | "to define master templates for a given BACKEND, use | |
5499f9dc | 49 | vc-BACKEND-master-templates. To enable or disable VC for a given |
3dab70bf | 50 | BACKEND, use `vc-handled-backends'.") |
5499f9dc | 51 | |
e18cf2ee JB |
52 | (defvar vc-header-alist ()) |
53 | (make-obsolete-variable 'vc-header-alist 'vc-BACKEND-header) | |
0e0d9831 | 54 | |
ce9f8ffb SM |
55 | (defvar vc-ignore-dir-regexp "\\`\\([\\/][\\/]\\|/net/\\|/afs/\\)\\'" |
56 | "Regexp matching directory names that are not under VC's control. | |
57 | The default regexp prevents fruitless and time-consuming attempts | |
58 | to determine the VC status in directories in which filenames are | |
59 | interpreted as hostnames.") | |
60 | ||
b8d1db77 SM |
61 | (defcustom vc-handled-backends '(RCS CVS SVN SCCS Arch MCVS) |
62 | ;; Arch and MCVS come last because they are per-tree rather than per-dir. | |
0e0d9831 GM |
63 | "*List of version control backends for which VC will be used. |
64 | Entries in this list will be tried in order to determine whether a | |
65 | file is under that sort of version control. | |
66 | Removing an entry from the list prevents VC from being activated | |
67 | when visiting a file managed by that backend. | |
68 | An empty list disables VC altogether." | |
69 | :type '(repeat symbol) | |
099bd78a | 70 | :version "21.1" |
50bec091 | 71 | :group 'vc) |
31888047 | 72 | |
50bec091 | 73 | (defcustom vc-path |
e1c0c2d1 KH |
74 | (if (file-directory-p "/usr/sccs") |
75 | '("/usr/sccs") | |
76 | nil) | |
50bec091 KH |
77 | "*List of extra directories to search for version control commands." |
78 | :type '(repeat directory) | |
79 | :group 'vc) | |
e1c0c2d1 | 80 | |
50bec091 | 81 | (defcustom vc-make-backup-files nil |
5032bd23 | 82 | "*If non-nil, backups of registered files are made as with other files. |
50bec091 KH |
83 | If nil (the default), files covered by version control don't get backups." |
84 | :type 'boolean | |
8f383484 DL |
85 | :group 'vc |
86 | :group 'backup) | |
594722a8 | 87 | |
50bec091 | 88 | (defcustom vc-follow-symlinks 'ask |
0e0d9831 GM |
89 | "*What to do if visiting a symbolic link to a file under version control. |
90 | Editing such a file through the link bypasses the version control system, | |
91 | which is dangerous and probably not what you want. | |
92 | ||
93 | If this variable is t, VC follows the link and visits the real file, | |
b8063212 AS |
94 | telling you about it in the echo area. If it is `ask', VC asks for |
95 | confirmation whether it should follow the link. If nil, the link is | |
50bec091 | 96 | visited and a warning displayed." |
0e0d9831 GM |
97 | :type '(choice (const :tag "Ask for confirmation" ask) |
98 | (const :tag "Visit link and warn" nil) | |
99 | (const :tag "Follow link" t)) | |
50bec091 | 100 | :group 'vc) |
b8063212 | 101 | |
50bec091 | 102 | (defcustom vc-display-status t |
624c0e9d | 103 | "*If non-nil, display revision number and lock status in modeline. |
50bec091 KH |
104 | Otherwise, not displayed." |
105 | :type 'boolean | |
106 | :group 'vc) | |
107 | ||
198d5c00 | 108 | |
50bec091 KH |
109 | (defcustom vc-consult-headers t |
110 | "*If non-nil, identify work files by searching for version headers." | |
111 | :type 'boolean | |
112 | :group 'vc) | |
e1c0c2d1 | 113 | |
50bec091 | 114 | (defcustom vc-keep-workfiles t |
e1c0c2d1 KH |
115 | "*If non-nil, don't delete working files after registering changes. |
116 | If the back-end is CVS, workfiles are always kept, regardless of the | |
50bec091 KH |
117 | value of this flag." |
118 | :type 'boolean | |
119 | :group 'vc) | |
e1c0c2d1 | 120 | |
50bec091 | 121 | (defcustom vc-mistrust-permissions nil |
0e0d9831 GM |
122 | "*If non-nil, don't assume permissions/ownership track version-control status. |
123 | If nil, do rely on the permissions. | |
50bec091 KH |
124 | See also variable `vc-consult-headers'." |
125 | :type 'boolean | |
126 | :group 'vc) | |
e66eac08 AS |
127 | |
128 | (defun vc-mistrust-permissions (file) | |
0e0d9831 | 129 | "Internal access function to variable `vc-mistrust-permissions' for FILE." |
e66eac08 AS |
130 | (or (eq vc-mistrust-permissions 't) |
131 | (and vc-mistrust-permissions | |
0e0d9831 | 132 | (funcall vc-mistrust-permissions |
e66eac08 AS |
133 | (vc-backend-subdirectory-name file))))) |
134 | ||
113414a9 SM |
135 | (defcustom vc-stay-local t |
136 | "*Non-nil means use local operations when possible for remote repositories. | |
137 | This avoids slow queries over the network and instead uses heuristics | |
138 | and past information to determine the current status of a file. | |
139 | ||
140 | The value can also be a regular expression or list of regular | |
141 | expressions to match against the host name of a repository; then VC | |
142 | only stays local for hosts that match it. Alternatively, the value | |
143 | can be a list of regular expressions where the first element is the | |
144 | symbol `except'; then VC always stays local except for hosts matched | |
145 | by these regular expressions." | |
146 | :type '(choice (const :tag "Always stay local" t) | |
147 | (const :tag "Don't stay local" nil) | |
148 | (list :format "\nExamine hostname and %v" :tag "Examine hostname ..." | |
149 | (set :format "%v" :inline t (const :format "%t" :tag "don't" except)) | |
150 | (regexp :format " stay local,\n%t: %v" :tag "if it matches") | |
151 | (repeat :format "%v%i\n" :inline t (regexp :tag "or")))) | |
bf247b6e | 152 | :version "22.1" |
113414a9 SM |
153 | :group 'vc) |
154 | ||
155 | (defun vc-stay-local-p (file) | |
156 | "Return non-nil if VC should stay local when handling FILE. | |
157 | This uses the `repository-hostname' backend operation." | |
158 | (let* ((backend (vc-backend file)) | |
159 | (sym (vc-make-backend-sym backend 'stay-local)) | |
160 | (stay-local (if (boundp sym) (symbol-value sym) t))) | |
161 | (if (eq stay-local t) (setq stay-local vc-stay-local)) | |
162 | (if (symbolp stay-local) stay-local | |
163 | (let ((dirname (if (file-directory-p file) | |
164 | (directory-file-name file) | |
165 | (file-name-directory file)))) | |
166 | (eq 'yes | |
167 | (or (vc-file-getprop dirname 'vc-stay-local-p) | |
168 | (vc-file-setprop | |
169 | dirname 'vc-stay-local-p | |
170 | (let ((hostname (vc-call-backend | |
171 | backend 'repository-hostname dirname))) | |
172 | (if (not hostname) | |
173 | 'no | |
174 | (let ((default t)) | |
175 | (if (eq (car-safe stay-local) 'except) | |
176 | (setq default nil stay-local (cdr stay-local))) | |
177 | (when (consp stay-local) | |
178 | (setq stay-local | |
179 | (mapconcat 'identity stay-local "\\|"))) | |
180 | (if (if (string-match stay-local hostname) | |
181 | default (not default)) | |
182 | 'yes 'no))))))))))) | |
183 | ||
9bd06e95 | 184 | ;;; This is handled specially now. |
594722a8 | 185 | ;; Tell Emacs about this new kind of minor mode |
9bd06e95 | 186 | ;; (add-to-list 'minor-mode-alist '(vc-mode vc-mode)) |
594722a8 | 187 | |
7bc2b98b | 188 | (make-variable-buffer-local 'vc-mode) |
c43e436c | 189 | (put 'vc-mode 'permanent-local t) |
594722a8 | 190 | |
14fef9de SM |
191 | (defun vc-mode (&optional arg) |
192 | ;; Dummy function for C-h m | |
193 | "Version Control minor mode. | |
194 | This minor mode is automatically activated whenever you visit a file under | |
195 | control of one of the revision control systems in `vc-handled-backends'. | |
196 | VC commands are globally reachable under the prefix `\\[vc-prefix-map]': | |
197 | \\{vc-prefix-map}") | |
198 | ||
099bd78a | 199 | (defmacro vc-error-occurred (&rest body) |
becd6193 | 200 | `(condition-case nil (progn ,@body nil) (error t))) |
099bd78a | 201 | |
594722a8 | 202 | ;; We need a notion of per-file properties because the version |
f2ee4191 | 203 | ;; control state of a file is expensive to derive --- we compute |
0e0d9831 | 204 | ;; them when the file is initially found, keep them up to date |
f2ee4191 RS |
205 | ;; during any subsequent VC operations, and forget them when |
206 | ;; the buffer is killed. | |
594722a8 | 207 | |
becd6193 | 208 | (defvar vc-file-prop-obarray (make-vector 17 0) |
594722a8 ER |
209 | "Obarray for per-file properties.") |
210 | ||
099bd78a SM |
211 | (defvar vc-touched-properties nil) |
212 | ||
594722a8 | 213 | (defun vc-file-setprop (file property value) |
0e0d9831 | 214 | "Set per-file VC PROPERTY for FILE to VALUE." |
099bd78a SM |
215 | (if (and vc-touched-properties |
216 | (not (memq property vc-touched-properties))) | |
217 | (setq vc-touched-properties (append (list property) | |
218 | vc-touched-properties))) | |
594722a8 ER |
219 | (put (intern file vc-file-prop-obarray) property value)) |
220 | ||
221 | (defun vc-file-getprop (file property) | |
099bd78a | 222 | "Get per-file VC PROPERTY for FILE." |
594722a8 ER |
223 | (get (intern file vc-file-prop-obarray) property)) |
224 | ||
e1c0c2d1 | 225 | (defun vc-file-clearprops (file) |
0e0d9831 | 226 | "Clear all VC properties of FILE." |
e1c0c2d1 | 227 | (setplist (intern file vc-file-prop-obarray) nil)) |
f2ee4191 | 228 | |
0e0d9831 GM |
229 | \f |
230 | ;; We keep properties on each symbol naming a backend as follows: | |
231 | ;; * `vc-functions': an alist mapping vc-FUNCTION to vc-BACKEND-FUNCTION. | |
232 | ||
233 | (defun vc-make-backend-sym (backend sym) | |
234 | "Return BACKEND-specific version of VC symbol SYM." | |
235 | (intern (concat "vc-" (downcase (symbol-name backend)) | |
236 | "-" (symbol-name sym)))) | |
237 | ||
238 | (defun vc-find-backend-function (backend fun) | |
239 | "Return BACKEND-specific implementation of FUN. | |
f8b72742 | 240 | If there is no such implementation, return the default implementation; |
0e0d9831 GM |
241 | if that doesn't exist either, return nil." |
242 | (let ((f (vc-make-backend-sym backend fun))) | |
243 | (if (fboundp f) f | |
244 | ;; Load vc-BACKEND.el if needed. | |
245 | (require (intern (concat "vc-" (downcase (symbol-name backend))))) | |
246 | (if (fboundp f) f | |
247 | (let ((def (vc-make-backend-sym 'default fun))) | |
248 | (if (fboundp def) (cons def backend) nil)))))) | |
249 | ||
250 | (defun vc-call-backend (backend function-name &rest args) | |
251 | "Call for BACKEND the implementation of FUNCTION-NAME with the given ARGS. | |
252 | Calls | |
253 | ||
254 | (apply 'vc-BACKEND-FUN ARGS) | |
255 | ||
256 | if vc-BACKEND-FUN exists (after trying to find it in vc-BACKEND.el) | |
257 | and else calls | |
258 | ||
259 | (apply 'vc-default-FUN BACKEND ARGS) | |
260 | ||
261 | It is usually called via the `vc-call' macro." | |
0bfb74a9 SM |
262 | (let ((f (assoc function-name (get backend 'vc-functions)))) |
263 | (if f (setq f (cdr f)) | |
0e0d9831 | 264 | (setq f (vc-find-backend-function backend function-name)) |
0bfb74a9 SM |
265 | (push (cons function-name f) (get backend 'vc-functions))) |
266 | (cond | |
267 | ((null f) | |
268 | (error "Sorry, %s is not implemented for %s" function-name backend)) | |
269 | ((consp f) (apply (car f) (cdr f) args)) | |
270 | (t (apply f args))))) | |
0e0d9831 GM |
271 | |
272 | (defmacro vc-call (fun file &rest args) | |
273 | ;; BEWARE!! `file' is evaluated twice!! | |
274 | `(vc-call-backend (vc-backend ,file) ',fun ,file ,@args)) | |
0e0d9831 GM |
275 | \f |
276 | (defsubst vc-parse-buffer (pattern i) | |
277 | "Find PATTERN in the current buffer and return its Ith submatch." | |
278 | (goto-char (point-min)) | |
279 | (if (re-search-forward pattern nil t) | |
280 | (match-string i))) | |
e1c0c2d1 | 281 | |
02d383eb | 282 | (defun vc-insert-file (file &optional limit blocksize) |
0e0d9831 GM |
283 | "Insert the contents of FILE into the current buffer. |
284 | ||
285 | Optional argument LIMIT is a regexp. If present, the file is inserted | |
286 | in chunks of size BLOCKSIZE (default 8 kByte), until the first | |
f8b72742 | 287 | occurrence of LIMIT is found. Anything from the start of that occurrence |
e30140ce AS |
288 | to the end of the buffer is then deleted. The function returns |
289 | non-nil if FILE exists and its contents were successfully inserted." | |
07de4c3d | 290 | (erase-buffer) |
ff40374a AS |
291 | (when (file-exists-p file) |
292 | (if (not limit) | |
293 | (insert-file-contents file) | |
294 | (if (not blocksize) (setq blocksize 8192)) | |
4d2806e2 SM |
295 | (let ((filepos 0)) |
296 | (while | |
297 | (and (< 0 (cadr (insert-file-contents | |
298 | file nil filepos (incf filepos blocksize)))) | |
299 | (progn (beginning-of-line) | |
e30140ce AS |
300 | (let ((pos (re-search-forward limit nil 'move))) |
301 | (if pos (delete-region (match-beginning 0) | |
302 | (point-max))) | |
303 | (not pos))))))) | |
ff40374a AS |
304 | (set-buffer-modified-p nil) |
305 | t)) | |
02d383eb | 306 | |
ce9f8ffb SM |
307 | (defun vc-find-root (file witness) |
308 | "Find the root of a checked out project. | |
309 | The function walks up the directory tree from FILE looking for WITNESS. | |
310 | If WITNESS if not found, return nil, otherwise return the root." | |
311 | (let ((root nil)) | |
312 | (while (not (or root | |
313 | (equal file (setq file (file-name-directory file))) | |
314 | (null file) | |
315 | (string-match vc-ignore-dir-regexp file))) | |
316 | (if (file-exists-p (expand-file-name witness file)) | |
317 | (setq root file) | |
318 | (setq file (directory-file-name file)))) | |
319 | root)) | |
320 | ||
14fef9de SM |
321 | ;; Access functions to file properties |
322 | ;; (Properties should be _set_ using vc-file-setprop, but | |
323 | ;; _retrieved_ only through these functions, which decide | |
324 | ;; if the property is already known or not. A property should | |
325 | ;; only be retrieved by vc-file-getprop if there is no | |
326 | ;; access function.) | |
02d383eb | 327 | |
14fef9de | 328 | ;; properties indicating the backend being used for FILE |
e1c0c2d1 | 329 | |
0e0d9831 GM |
330 | (defun vc-registered (file) |
331 | "Return non-nil if FILE is registered in a version control system. | |
332 | ||
1f22ad24 AS |
333 | This function performs the check each time it is called. To rely |
334 | on the result of a previous call, use `vc-backend' instead. If the | |
335 | file was previously registered under a certain backend, then that | |
336 | backend is tried first." | |
0e0d9831 | 337 | (let (handler) |
ce9f8ffb SM |
338 | (cond |
339 | ((string-match vc-ignore-dir-regexp (file-name-directory file)) nil) | |
340 | ((and (boundp 'file-name-handler-alist) | |
341 | (setq handler (find-file-name-handler file 'vc-registered))) | |
342 | ;; handler should set vc-backend and return t if registered | |
343 | (funcall handler 'vc-registered file)) | |
344 | (t | |
0e0d9831 GM |
345 | ;; There is no file name handler. |
346 | ;; Try vc-BACKEND-registered for each handled BACKEND. | |
347 | (catch 'found | |
1f22ad24 AS |
348 | (let ((backend (vc-file-getprop file 'vc-backend))) |
349 | (mapcar | |
350 | (lambda (b) | |
351 | (and (vc-call-backend b 'registered file) | |
352 | (vc-file-setprop file 'vc-backend b) | |
353 | (throw 'found t))) | |
f8b72742 | 354 | (if (or (not backend) (eq backend 'none)) |
1f22ad24 AS |
355 | vc-handled-backends |
356 | (cons backend vc-handled-backends)))) | |
0e0d9831 GM |
357 | ;; File is not registered. |
358 | (vc-file-setprop file 'vc-backend 'none) | |
ce9f8ffb | 359 | nil))))) |
0e0d9831 GM |
360 | |
361 | (defun vc-backend (file) | |
362 | "Return the version control type of FILE, nil if it is not registered." | |
363 | ;; `file' can be nil in several places (typically due to the use of | |
5232a436 | 364 | ;; code like (vc-backend buffer-file-name)). |
0e0d9831 GM |
365 | (when (stringp file) |
366 | (let ((property (vc-file-getprop file 'vc-backend))) | |
367 | ;; Note that internally, Emacs remembers unregistered | |
368 | ;; files by setting the property to `none'. | |
369 | (cond ((eq property 'none) nil) | |
370 | (property) | |
371 | ;; vc-registered sets the vc-backend property | |
372 | (t (if (vc-registered file) | |
373 | (vc-file-getprop file 'vc-backend) | |
374 | nil)))))) | |
375 | ||
376 | (defun vc-backend-subdirectory-name (file) | |
377 | "Return where the master and lock FILEs for the current directory are kept." | |
378 | (symbol-name (vc-backend file))) | |
e1c0c2d1 | 379 | |
02d383eb | 380 | (defun vc-name (file) |
5eb2b516 DL |
381 | "Return the master name of FILE. |
382 | If the file is not registered, or the master name is not known, return nil." | |
383 | ;; TODO: This should ultimately become obsolete, at least up here | |
0e0d9831 | 384 | ;; in vc-hooks. |
02d383eb | 385 | (or (vc-file-getprop file 'vc-name) |
64341022 AS |
386 | ;; force computation of the property by calling |
387 | ;; vc-BACKEND-registered explicitly | |
388 | (if (and (vc-backend file) | |
389 | (vc-call-backend (vc-backend file) 'registered file)) | |
8aa81ea8 | 390 | (vc-file-getprop file 'vc-name)))) |
e1c0c2d1 | 391 | |
04446ed0 | 392 | (defun vc-checkout-model (file) |
0e0d9831 GM |
393 | "Indicate how FILE is checked out. |
394 | ||
cb5af02a AS |
395 | If FILE is not registered, this function always returns nil. |
396 | For registered files, the possible values are: | |
0e0d9831 | 397 | |
cb5af02a | 398 | 'implicit FILE is always writeable, and checked out `implicitly' |
0e0d9831 GM |
399 | when the user saves the first changes to the file. |
400 | ||
cb5af02a | 401 | 'locking FILE is read-only if up-to-date; user must type |
db8afaee | 402 | \\[vc-next-action] before editing. Strict locking |
0e0d9831 GM |
403 | is assumed. |
404 | ||
cb5af02a | 405 | 'announce FILE is read-only if up-to-date; user must type |
db8afaee | 406 | \\[vc-next-action] before editing. But other users |
0e0d9831 GM |
407 | may be editing at the same time." |
408 | (or (vc-file-getprop file 'vc-checkout-model) | |
cb5af02a AS |
409 | (if (vc-backend file) |
410 | (vc-file-setprop file 'vc-checkout-model | |
411 | (vc-call checkout-model file))))) | |
7064821c | 412 | |
8d2b9c1a AS |
413 | (defun vc-user-login-name (file) |
414 | "Return the name under which the user accesses the given FILE." | |
415 | (or (and (eq (string-match tramp-file-name-regexp file) 0) | |
416 | ;; tramp case: execute "whoami" via tramp | |
417 | (let ((default-directory (file-name-directory file))) | |
418 | (with-temp-buffer | |
419 | (if (not (zerop (process-file "whoami" nil t))) | |
420 | ;; fall through if "whoami" didn't work | |
421 | nil | |
422 | ;; remove trailing newline | |
423 | (delete-region (1- (point-max)) (point-max)) | |
424 | (buffer-string))))) | |
425 | ;; normal case | |
426 | (user-login-name) | |
427 | ;; if user-login-name is nil, return the UID as a string | |
428 | (number-to-string (user-uid)))) | |
0e0d9831 GM |
429 | |
430 | (defun vc-state (file) | |
431 | "Return the version control state of FILE. | |
432 | ||
cb5af02a AS |
433 | If FILE is not registered, this function always returns nil. |
434 | For registered files, the value returned is one of: | |
0e0d9831 GM |
435 | |
436 | 'up-to-date The working file is unmodified with respect to the | |
437 | latest version on the current branch, and not locked. | |
438 | ||
439 | 'edited The working file has been edited by the user. If | |
440 | locking is used for the file, this state means that | |
441 | the current version is locked by the calling user. | |
442 | ||
443 | USER The current version of the working file is locked by | |
444 | some other USER (a string). | |
f8b72742 | 445 | |
0e0d9831 GM |
446 | 'needs-patch The file has not been edited by the user, but there is |
447 | a more recent version on the current branch stored | |
448 | in the master file. | |
449 | ||
450 | 'needs-merge The file has been edited by the user, and there is also | |
451 | a more recent version on the current branch stored in | |
452 | the master file. This state can only occur if locking | |
453 | is not used for the file. | |
454 | ||
455 | 'unlocked-changes The current version of the working file is not locked, | |
456 | but the working file has been changed with respect | |
457 | to that version. This state can only occur for files | |
458 | with locking; it represents an erroneous condition that | |
459 | should be resolved by the user (vc-next-action will | |
460 | prompt the user to do it)." | |
2a3897f5 SM |
461 | ;; FIXME: New (sub)states needed (?): |
462 | ;; - `added' (i.e. `edited' but with no base version yet, | |
463 | ;; typically represented by vc-workfile-version = "0") | |
464 | ;; - `conflict' (i.e. `edited' with conflict markers) | |
465 | ;; - `removed' | |
466 | ;; - `copied' and `moved' (might be handled by `removed' and `added') | |
0e0d9831 | 467 | (or (vc-file-getprop file 'vc-state) |
cb5af02a AS |
468 | (if (vc-backend file) |
469 | (vc-file-setprop file 'vc-state | |
470 | (vc-call state-heuristic file))))) | |
0e0d9831 | 471 | |
588c1bf9 AS |
472 | (defun vc-recompute-state (file) |
473 | "Recompute the version control state of FILE, and return it. | |
474 | This calls the possibly expensive function vc-BACKEND-state, | |
475 | rather than the heuristic." | |
476 | (vc-file-setprop file 'vc-state (vc-call state file))) | |
477 | ||
0e0d9831 GM |
478 | (defsubst vc-up-to-date-p (file) |
479 | "Convenience function that checks whether `vc-state' of FILE is `up-to-date'." | |
480 | (eq (vc-state file) 'up-to-date)) | |
481 | ||
482 | (defun vc-default-state-heuristic (backend file) | |
5eb2b516 DL |
483 | "Default implementation of vc-state-heuristic. |
484 | It simply calls the real state computation function `vc-BACKEND-state' | |
485 | and does not employ any heuristic at all." | |
0e0d9831 | 486 | (vc-call-backend backend 'state file)) |
1efcbf46 | 487 | |
e767004f AS |
488 | (defun vc-workfile-unchanged-p (file) |
489 | "Return non-nil if FILE has not changed since the last checkout." | |
490 | (let ((checkout-time (vc-file-getprop file 'vc-checkout-time)) | |
491 | (lastmod (nth 5 (file-attributes file)))) | |
04e77778 AS |
492 | (if (and checkout-time |
493 | ;; Tramp and Ange-FTP return this when they don't know the time. | |
494 | (not (equal lastmod '(0 0)))) | |
e767004f AS |
495 | (equal checkout-time lastmod) |
496 | (let ((unchanged (vc-call workfile-unchanged-p file))) | |
497 | (vc-file-setprop file 'vc-checkout-time (if unchanged lastmod 0)) | |
498 | unchanged)))) | |
499 | ||
500 | (defun vc-default-workfile-unchanged-p (backend file) | |
501 | "Check if FILE is unchanged by diffing against the master version. | |
502 | Return non-nil if FILE is unchanged." | |
f8836381 | 503 | (zerop (condition-case err |
4392edab AS |
504 | ;; If the implementation supports it, let the output |
505 | ;; go to *vc*, not *vc-diff*, since this is an internal call. | |
506 | (vc-call diff file nil nil "*vc*") | |
f8836381 AS |
507 | (wrong-number-of-arguments |
508 | ;; If this error came from the above call to vc-BACKEND-diff, | |
509 | ;; try again without the optional buffer argument (for | |
510 | ;; backward compatibility). Otherwise, resignal. | |
511 | (if (or (not (eq (cadr err) | |
512 | (indirect-function | |
513 | (vc-find-backend-function (vc-backend file) | |
514 | 'diff)))) | |
0d2ce4ef JB |
515 | (not (eq (caddr err) 4))) |
516 | (signal (car err) (cdr err)) | |
f8836381 | 517 | (vc-call diff file)))))) |
e767004f | 518 | |
e1c0c2d1 | 519 | (defun vc-workfile-version (file) |
cb5af02a AS |
520 | "Return the version level of the current workfile FILE. |
521 | If FILE is not registered, this function always returns nil." | |
0e0d9831 | 522 | (or (vc-file-getprop file 'vc-workfile-version) |
cb5af02a AS |
523 | (if (vc-backend file) |
524 | (vc-file-setprop file 'vc-workfile-version | |
525 | (vc-call workfile-version file))))) | |
f2ee4191 | 526 | |
0e0d9831 GM |
527 | (defun vc-default-registered (backend file) |
528 | "Check if FILE is registered in BACKEND using vc-BACKEND-master-templates." | |
529 | (let ((sym (vc-make-backend-sym backend 'master-templates))) | |
530 | (unless (get backend 'vc-templates-grabbed) | |
531 | (put backend 'vc-templates-grabbed t) | |
532 | (set sym (append (delq nil | |
533 | (mapcar | |
534 | (lambda (template) | |
535 | (and (consp template) | |
536 | (eq (cdr template) backend) | |
537 | (car template))) | |
3756d481 AS |
538 | (with-no-warnings |
539 | vc-master-templates))) | |
0e0d9831 GM |
540 | (symbol-value sym)))) |
541 | (let ((result (vc-check-master-templates file (symbol-value sym)))) | |
542 | (if (stringp result) | |
543 | (vc-file-setprop file 'vc-name result) | |
544 | nil)))) ; Not registered | |
545 | ||
546 | (defun vc-possible-master (s dirname basename) | |
547 | (cond | |
548 | ((stringp s) (format s dirname basename)) | |
549 | ((functionp s) | |
550 | ;; The template is a function to invoke. If the | |
551 | ;; function returns non-nil, that means it has found a | |
552 | ;; master. For backward compatibility, we also handle | |
553 | ;; the case that the function throws a 'found atom | |
554 | ;; and a pair (cons MASTER-FILE BACKEND). | |
555 | (let ((result (catch 'found (funcall s dirname basename)))) | |
556 | (if (consp result) (car result) result))))) | |
557 | ||
558 | (defun vc-check-master-templates (file templates) | |
cb5af02a | 559 | "Return non-nil if there is a master corresponding to FILE. |
0e0d9831 GM |
560 | |
561 | TEMPLATES is a list of strings or functions. If an element is a | |
562 | string, it must be a control string as required by `format', with two | |
563 | string placeholders, such as \"%sRCS/%s,v\". The directory part of | |
564 | FILE is substituted for the first placeholder, the basename of FILE | |
565 | for the second. If a file with the resulting name exists, it is taken | |
566 | as the master of FILE, and returned. | |
567 | ||
568 | If an element of TEMPLATES is a function, it is called with the | |
569 | directory part and the basename of FILE as arguments. It should | |
570 | return non-nil if it finds a master; that value is then returned by | |
571 | this function." | |
572 | (let ((dirname (or (file-name-directory file) "")) | |
573 | (basename (file-name-nondirectory file))) | |
574 | (catch 'found | |
5eb2b516 | 575 | (mapcar |
0e0d9831 GM |
576 | (lambda (s) |
577 | (let ((trial (vc-possible-master s dirname basename))) | |
578 | (if (and trial (file-exists-p trial) | |
579 | ;; Make sure the file we found with name | |
580 | ;; TRIAL is not the source file itself. | |
581 | ;; That can happen with RCS-style names if | |
582 | ;; the file name is truncated (e.g. to 14 | |
583 | ;; chars). See if either directory or | |
584 | ;; attributes differ. | |
585 | (or (not (string= dirname | |
586 | (file-name-directory trial))) | |
587 | (not (equal (file-attributes file) | |
588 | (file-attributes trial))))) | |
589 | (throw 'found trial)))) | |
590 | templates)))) | |
f2ee4191 | 591 | |
c844616c | 592 | (defun vc-toggle-read-only (&optional verbose) |
c43e436c | 593 | "Change read-only status of current buffer, perhaps via version control. |
db8afaee | 594 | |
c43e436c RS |
595 | If the buffer is visiting a file registered with version control, |
596 | then check the file in or out. Otherwise, just change the read-only flag | |
ec44193a KH |
597 | of the buffer. |
598 | With prefix argument, ask for version number to check in or check out. | |
599 | Check-out of a specified version number does not lock the file; | |
db8afaee AS |
600 | to do that, use this command a second time with no argument. |
601 | ||
602 | If you bind this function to \\[toggle-read-only], then Emacs checks files | |
603 | in or out whenever you toggle the read-only flag." | |
c844616c | 604 | (interactive "P") |
702220f3 | 605 | (if (or (and (boundp 'vc-dired-mode) vc-dired-mode) |
0e0d9831 | 606 | ;; use boundp because vc.el might not be loaded |
5232a436 | 607 | (vc-backend buffer-file-name)) |
c844616c | 608 | (vc-next-action verbose) |
594722a8 ER |
609 | (toggle-read-only))) |
610 | ||
e896a9e1 | 611 | (defun vc-default-make-version-backups-p (backend file) |
cb5af02a | 612 | "Return non-nil if unmodified versions should be backed up locally. |
9aa10a43 | 613 | The default is to switch off this feature." |
d445a975 AS |
614 | nil) |
615 | ||
e896a9e1 AS |
616 | (defun vc-version-backup-file-name (file &optional rev manual regexp) |
617 | "Return a backup file name for REV or the current version of FILE. | |
618 | If MANUAL is non-nil it means that a name for backups created by | |
619 | the user should be returned; if REGEXP is non-nil that means to return | |
620 | a regexp for matching all such backup files, regardless of the version." | |
e3f955b6 AS |
621 | (if regexp |
622 | (concat (regexp-quote (file-name-nondirectory file)) | |
623 | "\\.~[0-9.]+" (unless manual "\\.") "~") | |
f8b72742 JB |
624 | (expand-file-name (concat (file-name-nondirectory file) |
625 | ".~" (or rev (vc-workfile-version file)) | |
e3f955b6 AS |
626 | (unless manual ".") "~") |
627 | (file-name-directory file)))) | |
e896a9e1 AS |
628 | |
629 | (defun vc-delete-automatic-version-backups (file) | |
630 | "Delete all existing automatic version backups for FILE." | |
d455f4f7 SM |
631 | (condition-case nil |
632 | (mapcar | |
633 | 'delete-file | |
79e954d0 | 634 | (directory-files (or (file-name-directory file) default-directory) t |
d455f4f7 SM |
635 | (vc-version-backup-file-name file nil nil t))) |
636 | ;; Don't fail when the directory doesn't exist. | |
637 | (file-error nil))) | |
e896a9e1 AS |
638 | |
639 | (defun vc-make-version-backup (file) | |
640 | "Make a backup copy of FILE, which is assumed in sync with the repository. | |
641 | Before doing that, check if there are any old backups and get rid of them." | |
48b15d3f | 642 | (unless (and (fboundp 'msdos-long-file-names) |
ee9be3de | 643 | (not (with-no-warnings (msdos-long-file-names)))) |
48b15d3f | 644 | (vc-delete-automatic-version-backups file) |
27707243 AS |
645 | (condition-case nil |
646 | (copy-file file (vc-version-backup-file-name file) | |
647 | nil 'keep-date) | |
648 | ;; It's ok if it doesn't work (e.g. directory not writable), | |
649 | ;; since this is just for efficiency. | |
bf247b6e | 650 | (file-error |
27707243 AS |
651 | (message |
652 | (concat "Warning: Cannot make version backup; " | |
653 | "diff/revert therefore not local")))))) | |
d445a975 AS |
654 | |
655 | (defun vc-before-save () | |
656 | "Function to be called by `basic-save-buffer' (in files.el)." | |
657 | ;; If the file on disk is still in sync with the repository, | |
658 | ;; and version backups should be made, copy the file to | |
659 | ;; another name. This enables local diffs and local reverting. | |
5232a436 | 660 | (let ((file buffer-file-name)) |
d445a975 AS |
661 | (and (vc-backend file) |
662 | (vc-up-to-date-p file) | |
663 | (eq (vc-checkout-model file) 'implicit) | |
e896a9e1 AS |
664 | (vc-call make-version-backups-p file) |
665 | (vc-make-version-backup file)))) | |
d445a975 | 666 | |
e66eac08 | 667 | (defun vc-after-save () |
0e0d9831 | 668 | "Function to be called by `basic-save-buffer' (in files.el)." |
5eb2b516 | 669 | ;; If the file in the current buffer is under version control, |
0e0d9831 GM |
670 | ;; up-to-date, and locking is not used for the file, set |
671 | ;; the state to 'edited and redisplay the mode line. | |
5232a436 | 672 | (let ((file buffer-file-name)) |
8aa81ea8 | 673 | (and (vc-backend file) |
b23a2306 AS |
674 | (or (and (equal (vc-file-getprop file 'vc-checkout-time) |
675 | (nth 5 (file-attributes file))) | |
676 | ;; File has been saved in the same second in which | |
677 | ;; it was checked out. Clear the checkout-time | |
678 | ;; to avoid confusion. | |
679 | (vc-file-setprop file 'vc-checkout-time nil)) | |
680 | t) | |
0e0d9831 GM |
681 | (vc-up-to-date-p file) |
682 | (eq (vc-checkout-model file) 'implicit) | |
683 | (vc-file-setprop file 'vc-state 'edited) | |
684 | (vc-mode-line file) | |
099bd78a SM |
685 | (if (featurep 'vc) |
686 | ;; If VC is not loaded, then there can't be | |
687 | ;; any VC Dired buffer to synchronize. | |
688 | (vc-dired-resynch-file file))))) | |
04446ed0 | 689 | |
0e0d9831 | 690 | (defun vc-mode-line (file) |
7bc2b98b | 691 | "Set `vc-mode' to display type of version control for FILE. |
594722a8 | 692 | The value is set in the current buffer, which should be the buffer |
0e0d9831 | 693 | visiting FILE." |
67c6f446 | 694 | (interactive (list buffer-file-name)) |
5232a436 SM |
695 | (let ((backend (vc-backend file))) |
696 | (if (not backend) | |
697 | (setq vc-mode nil) | |
698 | (setq vc-mode (concat " " (if vc-display-status | |
699 | (vc-call mode-line-string file) | |
700 | (symbol-name backend)))) | |
701 | ;; If the file is locked by some other user, make | |
702 | ;; the buffer read-only. Like this, even root | |
703 | ;; cannot modify a file that someone else has locked. | |
704 | (and (equal file buffer-file-name) | |
705 | (stringp (vc-state file)) | |
706 | (setq buffer-read-only t)) | |
707 | ;; If the user is root, and the file is not owner-writable, | |
708 | ;; then pretend that we can't write it | |
709 | ;; even though we can (because root can write anything). | |
2a3897f5 SM |
710 | ;; This way, even root cannot modify a file that isn't locked. |
711 | (and (equal file buffer-file-name) | |
712 | (not buffer-read-only) | |
5232a436 SM |
713 | (zerop (user-real-uid)) |
714 | (zerop (logand (file-modes buffer-file-name) 128)) | |
715 | (setq buffer-read-only t))) | |
716 | (force-mode-line-update) | |
717 | backend)) | |
0e0d9831 GM |
718 | |
719 | (defun vc-default-mode-line-string (backend file) | |
720 | "Return string for placement in modeline by `vc-mode-line' for FILE. | |
721 | Format: | |
722 | ||
723 | \"BACKEND-REV\" if the file is up-to-date | |
724 | \"BACKEND:REV\" if the file is edited (or locked by the calling user) | |
725 | \"BACKEND:LOCKER:REV\" if the file is locked by somebody else | |
0e0d9831 GM |
726 | |
727 | This function assumes that the file is registered." | |
728 | (setq backend (symbol-name backend)) | |
729 | (let ((state (vc-state file)) | |
730 | (rev (vc-workfile-version file))) | |
099bd78a | 731 | (cond ((or (eq state 'up-to-date) |
0e0d9831 GM |
732 | (eq state 'needs-patch)) |
733 | (concat backend "-" rev)) | |
734 | ((stringp state) | |
735 | (concat backend ":" state ":" rev)) | |
736 | (t | |
737 | ;; Not just for the 'edited state, but also a fallback | |
738 | ;; for all other states. Think about different symbols | |
739 | ;; for 'needs-patch and 'needs-merge. | |
740 | (concat backend ":" rev))))) | |
f2ee4191 | 741 | |
a3a39848 | 742 | (defun vc-follow-link () |
0e0d9831 GM |
743 | "If current buffer visits a symbolic link, visit the real file. |
744 | If the real file is already visited in another buffer, make that buffer | |
745 | current, and kill the buffer that visits the link." | |
566f2169 | 746 | (let* ((truename (abbreviate-file-name (file-chase-links buffer-file-name))) |
e7f5ddc2 RS |
747 | (true-buffer (find-buffer-visiting truename)) |
748 | (this-buffer (current-buffer))) | |
749 | (if (eq true-buffer this-buffer) | |
750 | (progn | |
d8221951 | 751 | (kill-buffer this-buffer) |
e7f5ddc2 RS |
752 | ;; In principle, we could do something like set-visited-file-name. |
753 | ;; However, it can't be exactly the same as set-visited-file-name. | |
754 | ;; I'm not going to work out the details right now. -- rms. | |
d8221951 | 755 | (set-buffer (find-file-noselect truename))) |
e7f5ddc2 RS |
756 | (set-buffer true-buffer) |
757 | (kill-buffer this-buffer)))) | |
a3a39848 | 758 | |
b8d1db77 SM |
759 | (defun vc-default-find-file-hook (backend) |
760 | nil) | |
761 | ||
594722a8 | 762 | (defun vc-find-file-hook () |
be4d6a6f | 763 | "Function for `find-file-hook' activating VC mode if appropriate." |
18c8a18e PE |
764 | ;; Recompute whether file is version controlled, |
765 | ;; if user has killed the buffer and revisited. | |
060a1456 AS |
766 | (if vc-mode |
767 | (setq vc-mode nil)) | |
0e0d9831 | 768 | (when buffer-file-name |
f2ee4191 RS |
769 | (vc-file-clearprops buffer-file-name) |
770 | (cond | |
e1c0c2d1 | 771 | ((vc-backend buffer-file-name) |
0bfb74a9 | 772 | ;; Compute the state and put it in the modeline. |
f2ee4191 | 773 | (vc-mode-line buffer-file-name) |
0bfb74a9 SM |
774 | (unless vc-make-backup-files |
775 | ;; Use this variable, not make-backup-files, | |
776 | ;; because this is for things that depend on the file name. | |
b8d1db77 SM |
777 | (set (make-local-variable 'backup-inhibited) t)) |
778 | ;; Let the backend setup any buffer-local things he needs. | |
779 | (vc-call-backend (vc-backend buffer-file-name) 'find-file-hook)) | |
4d11f532 SM |
780 | ((let ((link-type (and (file-symlink-p buffer-file-name) |
781 | (vc-backend (file-chase-links buffer-file-name))))) | |
0bfb74a9 SM |
782 | (cond ((not link-type) nil) ;Nothing to do. |
783 | ((eq vc-follow-symlinks nil) | |
784 | (message | |
b8063212 | 785 | "Warning: symbolic link to %s-controlled source file" link-type)) |
0bfb74a9 SM |
786 | ((or (not (eq vc-follow-symlinks 'ask)) |
787 | ;; If we already visited this file by following | |
788 | ;; the link, don't ask again if we try to visit | |
789 | ;; it again. GUD does that, and repeated questions | |
790 | ;; are painful. | |
791 | (get-file-buffer | |
792 | (abbreviate-file-name | |
793 | (file-chase-links buffer-file-name)))) | |
794 | ||
795 | (vc-follow-link) | |
796 | (message "Followed link to %s" buffer-file-name) | |
797 | (vc-find-file-hook)) | |
798 | (t | |
799 | (if (yes-or-no-p (format | |
b8063212 | 800 | "Symbolic link to %s-controlled source file; follow link? " link-type)) |
0bfb74a9 SM |
801 | (progn (vc-follow-link) |
802 | (message "Followed link to %s" buffer-file-name) | |
803 | (vc-find-file-hook)) | |
804 | (message | |
b8063212 | 805 | "Warning: editing through the link bypasses version control") |
0bfb74a9 | 806 | )))))))) |
594722a8 | 807 | |
be4d6a6f | 808 | (add-hook 'find-file-hook 'vc-find-file-hook) |
594722a8 | 809 | |
14fef9de | 810 | ;; more hooks, this time for file-not-found |
594722a8 | 811 | (defun vc-file-not-found-hook () |
0e0d9831 GM |
812 | "When file is not found, try to check it out from version control. |
813 | Returns t if checkout was successful, nil otherwise. | |
d3d558a9 | 814 | Used in `find-file-not-found-functions'." |
5f42a1d4 RS |
815 | ;; When a file does not exist, ignore cached info about it |
816 | ;; from a previous visit. | |
817 | (vc-file-clearprops buffer-file-name) | |
4a330ab7 | 818 | (let ((backend (vc-backend buffer-file-name))) |
1e87be1b | 819 | (if backend (vc-call-backend backend 'find-file-not-found-hook)))) |
4a330ab7 SM |
820 | |
821 | (defun vc-default-find-file-not-found-hook (backend) | |
822 | (if (yes-or-no-p | |
823 | (format "File %s was lost; check out from version control? " | |
824 | (file-name-nondirectory buffer-file-name))) | |
825 | (save-excursion | |
826 | (require 'vc) | |
827 | (setq default-directory (file-name-directory buffer-file-name)) | |
828 | (not (vc-error-occurred (vc-checkout buffer-file-name)))))) | |
594722a8 | 829 | |
3756d481 | 830 | (add-hook 'find-file-not-found-functions 'vc-file-not-found-hook) |
594722a8 | 831 | |
f2ee4191 | 832 | (defun vc-kill-buffer-hook () |
0e0d9831 | 833 | "Discard VC info about a file when we kill its buffer." |
5232a436 SM |
834 | (if buffer-file-name |
835 | (vc-file-clearprops buffer-file-name))) | |
f2ee4191 | 836 | |
cd32d5d1 | 837 | (add-hook 'kill-buffer-hook 'vc-kill-buffer-hook) |
f2ee4191 | 838 | |
14fef9de SM |
839 | ;; Now arrange for (autoloaded) bindings of the main package. |
840 | ;; Bindings for this have to go in the global map, as we'll often | |
841 | ;; want to call them from random buffers. | |
842 | ||
843 | ;; Autoloading works fine, but it prevents shortcuts from appearing | |
844 | ;; in the menu because they don't exist yet when the menu is built. | |
845 | ;; (autoload 'vc-prefix-map "vc" nil nil 'keymap) | |
846 | (defvar vc-prefix-map | |
847 | (let ((map (make-sparse-keymap))) | |
848 | (define-key map "a" 'vc-update-change-log) | |
849 | (define-key map "b" 'vc-switch-backend) | |
850 | (define-key map "c" 'vc-cancel-version) | |
851 | (define-key map "d" 'vc-directory) | |
852 | (define-key map "g" 'vc-annotate) | |
853 | (define-key map "h" 'vc-insert-headers) | |
854 | (define-key map "i" 'vc-register) | |
855 | (define-key map "l" 'vc-print-log) | |
856 | (define-key map "m" 'vc-merge) | |
857 | (define-key map "r" 'vc-retrieve-snapshot) | |
858 | (define-key map "s" 'vc-create-snapshot) | |
859 | (define-key map "u" 'vc-revert-buffer) | |
860 | (define-key map "v" 'vc-next-action) | |
861 | (define-key map "=" 'vc-diff) | |
862 | (define-key map "~" 'vc-version-other-window) | |
863 | map)) | |
864 | (fset 'vc-prefix-map vc-prefix-map) | |
0e0d9831 | 865 | (define-key global-map "\C-xv" 'vc-prefix-map) |
624c0e9d | 866 | |
b662fbb8 RM |
867 | (if (not (boundp 'vc-menu-map)) |
868 | ;; Don't do the menu bindings if menu-bar.el wasn't loaded to defvar | |
869 | ;; vc-menu-map. | |
870 | () | |
871 | ;;(define-key vc-menu-map [show-files] | |
872 | ;; '("Show Files under VC" . (vc-directory t))) | |
9bef02e1 RS |
873 | (define-key vc-menu-map [vc-retrieve-snapshot] |
874 | '("Retrieve Snapshot" . vc-retrieve-snapshot)) | |
875 | (define-key vc-menu-map [vc-create-snapshot] | |
876 | '("Create Snapshot" . vc-create-snapshot)) | |
b64ea387 | 877 | (define-key vc-menu-map [vc-directory] '("VC Directory Listing" . vc-directory)) |
b662fbb8 | 878 | (define-key vc-menu-map [separator1] '("----")) |
14aa11f4 | 879 | (define-key vc-menu-map [vc-annotate] '("Annotate" . vc-annotate)) |
b662fbb8 RM |
880 | (define-key vc-menu-map [vc-rename-file] '("Rename File" . vc-rename-file)) |
881 | (define-key vc-menu-map [vc-version-other-window] | |
882 | '("Show Other Version" . vc-version-other-window)) | |
c1cd70af | 883 | (define-key vc-menu-map [vc-diff] '("Compare with Base Version" . vc-diff)) |
b662fbb8 RM |
884 | (define-key vc-menu-map [vc-update-change-log] |
885 | '("Update ChangeLog" . vc-update-change-log)) | |
886 | (define-key vc-menu-map [vc-print-log] '("Show History" . vc-print-log)) | |
887 | (define-key vc-menu-map [separator2] '("----")) | |
b662fbb8 RM |
888 | (define-key vc-menu-map [vc-insert-header] |
889 | '("Insert Header" . vc-insert-headers)) | |
c1cd70af AS |
890 | (define-key vc-menu-map [undo] '("Undo Last Check-In" . vc-cancel-version)) |
891 | (define-key vc-menu-map [vc-revert-buffer] | |
892 | '("Revert to Base Version" . vc-revert-buffer)) | |
893 | (define-key vc-menu-map [vc-update] | |
894 | '("Update to Latest Version" . vc-update)) | |
9314395d | 895 | (define-key vc-menu-map [vc-next-action] '("Check In/Out" . vc-next-action)) |
738efc8e KH |
896 | (define-key vc-menu-map [vc-register] '("Register" . vc-register))) |
897 | ||
14fef9de SM |
898 | ;; These are not correct and it's not currently clear how doing it |
899 | ;; better (with more complicated expressions) might slow things down | |
900 | ;; on older systems. | |
901 | ||
902 | ;;(put 'vc-rename-file 'menu-enable 'vc-mode) | |
903 | ;;(put 'vc-annotate 'menu-enable '(eq (vc-buffer-backend) 'CVS)) | |
904 | ;;(put 'vc-version-other-window 'menu-enable 'vc-mode) | |
905 | ;;(put 'vc-diff 'menu-enable 'vc-mode) | |
906 | ;;(put 'vc-update-change-log 'menu-enable | |
907 | ;; '(member (vc-buffer-backend) '(RCS CVS))) | |
908 | ;;(put 'vc-print-log 'menu-enable 'vc-mode) | |
909 | ;;(put 'vc-cancel-version 'menu-enable 'vc-mode) | |
910 | ;;(put 'vc-revert-buffer 'menu-enable 'vc-mode) | |
911 | ;;(put 'vc-insert-headers 'menu-enable 'vc-mode) | |
912 | ;;(put 'vc-next-action 'menu-enable 'vc-mode) | |
913 | ;;(put 'vc-register 'menu-enable '(and buffer-file-name (not vc-mode))) | |
594722a8 | 914 | |
594722a8 ER |
915 | (provide 'vc-hooks) |
916 | ||
ce9f8ffb | 917 | ;; arch-tag: 2e5a6fa7-1d30-48e2-8bd0-e3d335f04f32 |
594722a8 | 918 | ;;; vc-hooks.el ends here |