;;; vc.el --- drive a version-control system from within Emacs
-;; Copyright (C) 1992, 1993, 1994 Free Software Foundation, Inc.
+;; Copyright (C) 1992, 1993, 1994, 1995 Free Software Foundation, Inc.
;; Author: Eric S. Raymond <esr@snark.thyrsus.com>
-;; Maintainer: eggert@twinsun.com
-;; Version: 5.5
+;; Modified by:
+;; ttn@netcom.com
+;; Per Cederqvist <ceder@lysator.liu.edu>
+;; Andre Spiegel <spiegel@berlin.informatik.uni-stuttgart.de>
;; This file is part of GNU Emacs.
;; This was designed and implemented by Eric Raymond <esr@snark.thyrsus.com>.
;; Paul Eggert <eggert@twinsun.com>, Sebastian Kremer <sk@thp.uni-koeln.de>,
;; and Richard Stallman contributed valuable criticism, support, and testing.
+;; CVS support was added by Per Cederqvist <ceder@lysator.liu.se>
+;; in Jan-Feb 1994.
;;
-;; Supported version-control systems presently include SCCS and RCS;
-;; the RCS lock-stealing code doesn't work right unless you use RCS 5.6.2
-;; or newer. Currently (January 1994) that is only a beta test release.
+;; Supported version-control systems presently include SCCS, RCS, and CVS.
;;
-;; The RCS code assumes strict locking. You can support the RCS -x option
-;; by adding pairs to the vc-master-templates list.
+;; Some features will not work with old RCS versions. Where
+;; appropriate, VC finds out which version you have, and allows or
+;; disallows those features (stealing locks, for example, works only
+;; from 5.6.2 onwards).
+;; Even initial checkins will fail if your RCS version is so old that ci
+;; doesn't understand -t-; this has been known to happen to people running
+;; NExTSTEP 3.0.
+;;
+;; You can support the RCS -x option by adding pairs to the
+;; vc-master-templates list.
;;
;; Proper function of the SCCS diff commands requires the shellscript vcdiff
;; to be installed somewhere on Emacs's path for executables.
(cons '(vc-parent-buffer vc-parent-buffer-name)
minor-mode-alist)))
+;; To implement support for a new version-control system, add another
+;; branch to the vc-backend-dispatch macro and fill it in in each
+;; call. The variable vc-master-templates in vc-hooks.el will also
+;; have to change.
+
+(defmacro vc-backend-dispatch (f s r c)
+ "Execute FORM1, FORM2 or FORM3 for SCCS, RCS or CVS respectively.
+If FORM3 is `RCS', use FORM2 for CVS as well as RCS.
+\(CVS shares some code with RCS)."
+ (list 'let (list (list 'type (list 'vc-backend f)))
+ (list 'cond
+ (list (list 'eq 'type (quote 'SCCS)) s) ;; SCCS
+ (list (list 'eq 'type (quote 'RCS)) r) ;; RCS
+ (list (list 'eq 'type (quote 'CVS)) ;; CVS
+ (if (eq c 'RCS) r c))
+ )))
+
;; General customization
-(defvar vc-default-back-end nil
- "*Back-end actually used by this interface; may be SCCS or RCS.
-The value is only computed when needed to avoid an expensive search.")
(defvar vc-suppress-confirm nil
"*If non-nil, treat user as expert; suppress yes-no prompts on some things.")
-(defvar vc-keep-workfiles t
- "*If non-nil, don't delete working files after registering changes.")
(defvar vc-initial-comment nil
"*Prompt for initial comment when a file is registered.")
(defvar vc-command-messages nil
"*Display run messages from back-end commands.")
-(defvar vc-mistrust-permissions 'file-symlink-p
- "*Don't assume that permissions and ownership track version-control status.")
(defvar vc-checkin-switches nil
"*Extra switches passed to the checkin program by \\[vc-checkin].")
-(defvar vc-path
- (if (file-exists-p "/usr/sccs")
- '("/usr/sccs") nil)
- "*List of extra directories to search for version control commands.")
+(defvar vc-checkout-switches nil
+ "*Extra switches passed to the checkout program by \\[vc-checkout].")
+(defvar vc-directory-exclusion-list '("SCCS" "RCS" "CVS")
+ "*Directory names ignored by functions that recursively walk file trees.")
(defconst vc-maximum-comment-ring-size 32
"Maximum number of saved comments in the comment ring.")
(defvar vc-checkin-hook nil
"*List of functions called after a checkin is done. See `run-hooks'.")
+(defvar vc-make-buffer-writable-hook nil
+ "*List of functions called when a buffer is made writable. See `run-hooks.'
+This hook is only used when the version control system is CVS. It
+might be useful for sites who uses locking with CVS, or who uses link
+farms to gold trees.")
+
;; Header-insertion hair
(defvar vc-header-alist
- '((SCCS "\%W\%") (RCS "\$Id\$"))
+ '((SCCS "\%W\%") (RCS "\$Id\$") (CVS "\$Id\$"))
"*Header keywords to be inserted when `vc-insert-headers' is executed.")
(defvar vc-static-header-alist
'(("\\.c$" .
Verify that the file really is not locked
and that its contents match what the master file says.")
+(defvar vc-rcs-release nil
+ "*The release number of your RCS installation, as a string.
+If nil, VC itself computes this value when it is first needed.")
+
+(defvar vc-sccs-release nil
+ "*The release number of your SCCS installation, as a string.
+If nil, VC itself computes this value when it is first needed.")
+
+(defvar vc-cvs-release nil
+ "*The release number of your SCCS installation, as a string.
+If nil, VC itself computes this value when it is first needed.")
+
;; Variables the user doesn't need to know about.
(defvar vc-log-entry-mode nil)
(defvar vc-log-operation nil)
(defvar vc-log-after-operation-hook nil)
(defvar vc-checkout-writable-buffer-hook 'vc-checkout-writable-buffer)
+;; In a log entry buffer, this is a local variable
+;; that points to the buffer for which it was made
+;; (either a file, or a VC dired buffer).
(defvar vc-parent-buffer nil)
(defvar vc-parent-buffer-name nil)
(defvar vc-comment-ring-index nil)
(defvar vc-last-comment-match nil)
-;; File property caching
+;; Back-portability to Emacs 18
+
+(defun file-executable-p-18 (f)
+ (let ((modes (file-modes f)))
+ (and modes (not (zerop (logand 292))))))
+
+(defun file-regular-p-18 (f)
+ (let ((attributes (file-attributes f)))
+ (and attributes (not (car attributes)))))
+
+; Conditionally rebind some things for Emacs 18 compatibility
+(if (not (boundp 'minor-mode-map-alist))
+ (progn
+ (setq compilation-old-error-list nil)
+ (fset 'file-executable-p 'file-executable-p-18)
+ (fset 'shrink-window-if-larger-than-buffer 'beginning-of-buffer)
+ ))
+
+(if (not (fboundp 'file-regular-p))
+ (fset 'file-regular-p 'file-regular-p-18))
+
+;;; Find and compare backend releases
+
+(defun vc-backend-release (backend)
+ ;; Returns which backend release is installed on this system.
+ (cond
+ ((eq backend 'RCS)
+ (or vc-rcs-release
+ (and (zerop (vc-do-command nil 2 "rcs" nil nil "-V"))
+ (save-excursion
+ (set-buffer (get-buffer "*vc*"))
+ (setq vc-rcs-release
+ (car (vc-parse-buffer
+ '(("^RCS version \\([0-9.]+ *.*\\)" 1)))))))
+ (setq vc-rcs-release 'unknown)))
+ ((eq backend 'CVS)
+ (or vc-cvs-release
+ (and (zerop (vc-do-command nil 1 "cvs" nil nil "-v"))
+ (save-excursion
+ (set-buffer (get-buffer "*vc*"))
+ (setq vc-cvs-release
+ (car (vc-parse-buffer
+ '(("^Concurrent Versions System (CVS) \\([0-9.]+\\)"
+ 1)))))))
+ (setq vc-cvs-release 'unknown)))
+ ((eq backend 'SCCS)
+ vc-sccs-release)))
+
+(defun vc-release-greater-or-equal (r1 r2)
+ ;; Compare release numbers, represented as strings.
+ ;; Release components are assumed cardinal numbers, not decimal
+ ;; fractions (5.10 is a higher release than 5.9). Omitted fields
+ ;; are considered lower (5.6.7 is earlier than 5.6.7.1).
+ ;; Comparison runs till the end of the string is found, or a
+ ;; non-numeric component shows up (5.6.7 is earlier than "5.6.7 beta",
+ ;; which is probably not what you want in some cases).
+ ;; This code is suitable for existing RCS release numbers.
+ ;; CVS releases are handled reasonably, too (1.3 < 1.4* < 1.5).
+ (let (v1 v2 i1 i2)
+ (catch 'done
+ (or (and (string-match "^\\.?\\([0-9]+\\)" r1)
+ (setq i1 (match-end 0))
+ (setq v1 (string-to-number (match-string 1 r1)))
+ (or (and (string-match "^\\.?\\([0-9]+\\)" r2)
+ (setq i2 (match-end 0))
+ (setq v2 (string-to-number (match-string 1 r2)))
+ (if (> v1 v2) (throw 'done t)
+ (if (< v1 v2) (throw 'done nil)
+ (throw 'done
+ (vc-release-greater-or-equal
+ (substring r1 i1)
+ (substring r2 i2)))))))
+ (throw 'done t)))
+ (or (and (string-match "^\\.?\\([0-9]+\\)" r2)
+ (throw 'done nil))
+ (throw 'done t)))))
+
+(defun vc-backend-release-p (backend release)
+ ;; Return t if we have RELEASE of BACKEND or better
+ (let (i r (ri 0) (ii 0) is rs (installation (vc-backend-release backend)))
+ (if (not (eq installation 'unknown))
+ (cond
+ ((or (eq backend 'RCS) (eq backend 'CVS))
+ (vc-release-greater-or-equal installation release))))))
+
+;;; functions that operate on RCS revision numbers
+
+(defun vc-trunk-p (rev)
+ ;; return t if REV is a revision on the trunk
+ (not (eq nil (string-match "\\`[0-9]+\\.[0-9]+\\'" rev))))
+
+(defun vc-branch-part (rev)
+ ;; return the branch part of a revision number REV
+ (substring rev 0 (string-match "\\.[0-9]+\\'" rev)))
-(defun vc-file-clearprops (file)
- ;; clear all properties of a given file
- (setplist (intern file vc-file-prop-obarray) nil))
+;; File property caching
(defun vc-clear-context ()
"Clear all cached file properties and the comment ring."
;; log buffer with a nonzero local value of vc-comment-ring-index.
(setq vc-comment-ring nil))
+(defun vc-file-clear-masterprops (file)
+ ;; clear all properties of FILE that were retrieved
+ ;; from the master file
+ (vc-file-setprop file 'vc-latest-version nil)
+ (vc-file-setprop file 'vc-your-latest-version nil)
+ (vc-backend-dispatch file
+ (progn ;; SCCS
+ (vc-file-setprop file 'vc-master-locks nil))
+ (progn ;; RCS
+ (vc-file-setprop file 'vc-default-branch nil)
+ (vc-file-setprop file 'vc-head-version nil)
+ (vc-file-setprop file 'vc-master-workfile-version nil)
+ (vc-file-setprop file 'vc-master-locks nil))
+ (progn
+ (vc-file-setprop file 'vc-cvs-status nil))))
+
+(defun vc-head-version (file)
+ ;; Return the RCS head version of FILE
+ (cond ((vc-file-getprop file 'vc-head-version))
+ (t (vc-fetch-master-properties file)
+ (vc-file-getprop file 'vc-head-version))))
+
;; Random helper functions
+(defun vc-latest-on-branch-p (file)
+ ;; return t iff the current workfile version of FILE is
+ ;; the latest on its branch.
+ (vc-backend-dispatch file
+ ;; SCCS
+ (string= (vc-workfile-version file) (vc-latest-version file))
+ ;; RCS
+ (let ((workfile-version (vc-workfile-version file)) tip-version)
+ (if (vc-trunk-p workfile-version)
+ (progn
+ ;; Re-fetch the head version number. This is to make
+ ;; sure that no-one has checked in a new version behind
+ ;; our back.
+ (vc-fetch-master-properties file)
+ (string= (vc-file-getprop file 'vc-head-version)
+ workfile-version))
+ ;; If we are not on the trunk, we need to examine the
+ ;; whole current branch. (vc-master-workfile-version
+ ;; is not what we need.)
+ (save-excursion
+ (set-buffer (get-buffer-create "*vc-info*"))
+ (vc-insert-file (vc-name file) "^desc")
+ (setq tip-version (car (vc-parse-buffer (list (list
+ (concat "^\\(" (regexp-quote (vc-branch-part workfile-version))
+ "\\.[0-9]+\\)\ndate[ \t]+\\([0-9.]+\\);") 1 2)))))
+ (if (get-buffer "*vc-info*")
+ (kill-buffer (get-buffer "*vc-info*")))
+ (string= tip-version workfile-version))))
+ ;; CVS
+ t))
+
(defun vc-registration-error (file)
(if file
(error "File %s is not under version control" file)
exec-path)
nil)))
-(defun vc-do-command (okstatus command file &rest flags)
+(defun vc-do-command (buffer okstatus command file last &rest flags)
"Execute a version-control command, notifying user and checking for errors.
+Output from COMMAND goes to BUFFER, or *vc* if BUFFER is nil.
The command is successful if its exit status does not exceed OKSTATUS.
-Output from COMMAND goes to buffer *vc*. The last argument of the command is
-the master name of FILE; this is appended to an optional list of FLAGS."
- (setq file (expand-file-name file))
+The last argument of the command is the master name of FILE if LAST is
+`MASTER', or the workfile of FILE if LAST is `WORKFILE'; this is appended
+to an optional list of FLAGS."
+ (and file (setq file (expand-file-name file)))
+ (if (not buffer) (setq buffer "*vc*"))
(if vc-command-messages
(message "Running %s on %s..." command file))
(let ((obuf (current-buffer)) (camefrom (current-buffer))
(squeezed nil)
(vc-file (and file (vc-name file)))
+ (olddir default-directory)
status)
- (set-buffer (get-buffer-create "*vc*"))
+ (set-buffer (get-buffer-create buffer))
(set (make-local-variable 'vc-parent-buffer) camefrom)
(set (make-local-variable 'vc-parent-buffer-name)
(concat " from " (buffer-name camefrom)))
+ (setq default-directory olddir)
(erase-buffer)
- ;; This is so that command arguments typed in the *vc* buffer will
- ;; have reasonable defaults.
- (setq default-directory (file-name-directory file))
-
(mapcar
(function (lambda (s) (and s (setq squeezed (append squeezed (list s))))))
flags)
- (if vc-file
+ (if (and vc-file (eq last 'MASTER))
(setq squeezed (append squeezed (list vc-file))))
- (let ((default-directory (file-name-directory (or file "./")))
- (exec-path (if vc-path (append exec-path vc-path) exec-path)))
+ (if (eq last 'WORKFILE)
+ (progn
+ (let* ((pwd (expand-file-name default-directory))
+ (preflen (length pwd)))
+ (if (string= (substring file 0 preflen) pwd)
+ (setq file (substring file preflen))))
+ (setq squeezed (append squeezed (list file)))))
+ (let ((exec-path (append vc-path exec-path))
+ ;; Add vc-path to PATH for the execution of this command.
+ (process-environment
+ (cons (concat "PATH=" (getenv "PATH")
+ path-separator
+ (mapconcat 'identity vc-path path-separator))
+ process-environment)))
(setq status (apply 'call-process command nil t nil squeezed)))
(goto-char (point-max))
+ (set-buffer-modified-p nil)
(forward-line -1)
(if (or (not (integerp status)) (< okstatus status))
(progn
- (pop-to-buffer "*vc*")
+ (pop-to-buffer buffer)
(goto-char (point-min))
(shrink-window-if-larger-than-buffer)
(error "Running %s...FAILED (%s)" command
;;; Save a bit of the text around POSN in the current buffer, to help
;;; us find the corresponding position again later. This works even
;;; if all markers are destroyed or corrupted.
+;;; A lot of this was shamelessly lifted from Sebastian Kremer's rcs.el mode.
(defun vc-position-context (posn)
(list posn
(buffer-size)
;; to beginning of OSTRING
(- (point) (length context-string))))))))
-(defun vc-revert-buffer1 (&optional arg no-confirm)
- ;; Most of this was shamelessly lifted from Sebastian Kremer's rcs.el mode.
- ;; Revert buffer, try to keep point and mark where user expects them in spite
- ;; of changes because of expanded version-control key words.
- ;; This is quite important since otherwise typeahead won't work as expected.
- (interactive "P")
- (widen)
+(defun vc-buffer-context ()
+ ;; Return a list '(point-context mark-context reparse); from which
+ ;; vc-restore-buffer-context can later restore the context.
(let ((point-context (vc-position-context (point)))
;; Use mark-marker to avoid confusion in transient-mark-mode.
(mark-context (if (eq (marker-buffer (mark-marker)) (current-buffer))
(setq errors (cdr errors)))
(if buffer-error-marked-p buffer))))
(buffer-list)))))))
-
- ;; the actual revisit
- (revert-buffer arg no-confirm)
-
+ (list point-context mark-context reparse)))
+
+(defun vc-restore-buffer-context (context)
+ ;; Restore point/mark, and reparse any affected compilation buffers.
+ ;; CONTEXT is that which vc-buffer-context returns.
+ (let ((point-context (nth 0 context))
+ (mark-context (nth 1 context))
+ (reparse (nth 2 context)))
;; Reparse affected compilation buffers.
(while reparse
(if (car reparse)
(let ((new-mark (vc-find-position-by-context mark-context)))
(if new-mark (set-mark new-mark))))))
+(defun vc-revert-buffer1 (&optional arg no-confirm)
+ ;; Revert buffer, try to keep point and mark where user expects them in spite
+ ;; of changes because of expanded version-control key words.
+ ;; This is quite important since otherwise typeahead won't work as expected.
+ (interactive "P")
+ (widen)
+ (let ((context (vc-buffer-context)))
+ (revert-buffer arg no-confirm)
+ (vc-restore-buffer-context context)))
+
(defun vc-buffer-sync (&optional not-urgent)
;; Make sure the current buffer and its working file are in sync
(or (equal checkout-time lastmod)
(and (or (not checkout-time) want-differences-if-changed)
(let ((unchanged (zerop (vc-backend-diff file nil nil
- (not want-differences-if-changed)))))
+ (not want-differences-if-changed)))))
;; 0 stands for an unknown time; it can't match any mod time.
(vc-file-setprop file 'vc-checkout-time (if unchanged lastmod 0))
unchanged)))))
(defun vc-next-action-on-file (file verbose &optional comment)
;;; If comment is specified, it will be used as an admin or checkin comment.
- (let (owner version (vc-file (vc-name file)))
+ (let ((vc-file (vc-name file))
+ (vc-type (vc-backend file))
+ owner version buffer)
(cond
;; if there is no master file corresponding, create one
((not vc-file)
- (vc-register verbose comment))
+ (vc-register verbose comment)
+ (if vc-initial-comment
+ (setq vc-log-after-operation-hook
+ 'vc-checkout-writable-buffer-hook)
+ (vc-checkout-writable-buffer file)))
+
+ ;; CVS: changes to the master file need to be
+ ;; merged back into the working file
+ ((and (eq vc-type 'CVS)
+ (or (eq (vc-cvs-status file) 'needs-checkout)
+ (eq (vc-cvs-status file) 'needs-merge)))
+ (if (or vc-dired-mode
+ (yes-or-no-p
+ (format "%s is not up-to-date. Merge in changes now? "
+ (buffer-name))))
+ (progn
+ (if vc-dired-mode
+ (and (setq buffer (get-file-buffer file))
+ (buffer-modified-p buffer)
+ (switch-to-buffer-other-window buffer)
+ (vc-buffer-sync t))
+ (setq buffer (current-buffer))
+ (vc-buffer-sync t))
+ (if (and buffer (buffer-modified-p buffer)
+ (not (yes-or-no-p
+ (format
+ "Buffer %s modified; merge file on disc anyhow? "
+ (buffer-name buffer)))))
+ (error "Merge aborted"))
+ (if (not (zerop (vc-backend-merge-news file)))
+ ;; Overlaps detected - what now? Should use some
+ ;; fancy RCS conflict resolving package, or maybe
+ ;; emerge, but for now, simply warn the user with a
+ ;; message.
+ (message "Conflicts detected!"))
+ (and buffer
+ (vc-resynch-buffer file t (not (buffer-modified-p buffer)))))
+ (error "%s needs update" (buffer-name))))
;; if there is no lock on the file, assert one and get it
((not (setq owner (vc-locking-user file)))
(if (and vc-checkout-carefully
(not (vc-workfile-unchanged-p file t)))
(if (save-window-excursion
- (pop-to-buffer "*vc*")
+ (pop-to-buffer "*vc-diff*")
(goto-char (point-min))
(insert-string (format "Changes to %s since last lock:\n\n"
file))
(vc-revert-buffer1 t t)
(vc-checkout-writable-buffer file))
)
- (vc-checkout-writable-buffer file)))
+ (if verbose
+ (if (not (eq vc-type 'SCCS))
+ (vc-checkout file nil
+ (read-string "Branch or version to move to: "))
+ (error "Sorry, this is not implemented for SCCS."))
+ (if (vc-latest-on-branch-p file)
+ (vc-checkout-writable-buffer file)
+ (if (yes-or-no-p
+ "This is not the latest version. Really lock it? ")
+ (vc-checkout-writable-buffer file)
+ (if (yes-or-no-p "Lock the latest version instead? ")
+ (vc-checkout-writable-buffer file
+ (vc-branch-part (vc-workfile-version file))))))
+ )))
;; a checked-out version exists, but the user may not own the lock
- ((not (string-equal owner (user-login-name)))
+ ((and (not (eq vc-type 'CVS))
+ (not (string-equal owner (user-login-name))))
(if comment
(error "Sorry, you can't steal the lock on %s this way" file))
+ (and (eq vc-type 'RCS)
+ (not (vc-backend-release-p 'RCS "5.6.2"))
+ (error "File is locked by %s." owner))
(vc-steal-lock
file
- (and verbose (read-string "Version to steal: "))
+ (if verbose (read-string "Version to steal: ")
+ (vc-workfile-version file))
owner))
-
+
;; OK, user owns the lock on the file
(t
- (find-file file)
+ (if vc-dired-mode
+ (find-file-other-window file)
+ (find-file file))
;; give luser a chance to save before checking in.
(vc-buffer-sync)
;; to saving it; in that case, don't revert,
;; because the user might intend to save
;; after finishing the log entry.
- (if (and (vc-workfile-unchanged-p file)
+ (if (and (vc-workfile-unchanged-p file)
(not (buffer-modified-p)))
- (progn
+ ;; DO NOT revert the file without asking the user!
+ (cond
+ ((yes-or-no-p "Revert to master version? ")
(vc-backend-revert file)
- ;; DO NOT revert the file without asking the user!
- (vc-resynch-window file t nil))
+ (vc-resynch-window file t t)))
;; user may want to set nonstandard parameters
(if verbose
)))))
(defun vc-next-action-dired (file rev comment)
- ;; We've accepted a log comment, now do a vc-next-action using it on all
- ;; marked files.
- (set-buffer vc-parent-buffer)
- (dired-map-over-marks
- (save-window-excursion
- (let ((file (dired-get-filename)))
+ ;; Do a vc-next-action-on-file on all the marked files, possibly
+ ;; passing on the log comment we've just entered.
+ (let ((configuration (current-window-configuration))
+ (dired-buffer (current-buffer))
+ (dired-dir default-directory))
+ (dired-map-over-marks
+ (let ((file (dired-get-filename)) p)
(message "Processing %s..." file)
+ ;; Adjust the default directory so that checkouts
+ ;; go to the right place.
+ (setq default-directory (file-name-directory file))
(vc-next-action-on-file file nil comment)
- (message "Processing %s...done" file)))
- nil t)
- )
+ (set-buffer dired-buffer)
+ (setq default-directory dired-dir)
+ (vc-dired-update-line file)
+ (set-window-configuration configuration)
+ (message "Processing %s...done" file))
+ nil t)))
;; Here's the major entry point.
;;;###autoload
(defun vc-next-action (verbose)
"Do the next logical checkin or checkout operation on the current file.
+ If you call this from within a VC dired buffer with no files marked,
+it will operate on the file in the current line.
+ If you call this from within a VC dired buffer, and one or more
+files are marked, it will accept a log message and then operate on
+each one. The log message will be used as a comment for any register
+or checkin operations, but ignored when doing checkouts. Attempted
+lock steals will raise an error.
+ A prefix argument lets you specify the version number to use.
+
+For RCS and SCCS files:
If the file is not already registered, this registers it for version
control and then retrieves a writable, locked copy for editing.
If the file is registered and not locked by anyone, this checks out
read-only copy of the changed file is left in place afterwards.
If the file is registered and locked by someone else, you are given
the option to steal the lock.
- If you call this from within a VC dired buffer with no files marked,
-it will operate on the file in the current line.
- If you call this from within a VC dired buffer, and one or more
-files are marked, it will accept a log message and then operate on
-each one. The log message will be used as a comment for any register
-or checkin operations, but ignored when doing checkouts. Attempted
-lock steals will raise an error.
- For checkin, a prefix argument lets you specify the version number to use."
+For CVS files:
+ If the file is not already registered, this registers it for version
+control. This does a \"cvs add\", but no \"cvs commit\".
+ If the file is added but not committed, it is committed.
+ If your working file is changed, but the repository file is
+unchanged, this pops up a buffer for entry of a log message; when the
+message has been entered, it checks in the resulting changes along
+with the logmessage as change commentary. A writable file is retained.
+ If the repository file is changed, you are asked if you want to
+merge in the changes into your working copy."
+
(interactive "P")
(catch 'nogo
(if vc-dired-mode
(let ((files (dired-get-marked-files)))
- (if (= (length files) 1)
- (find-file-other-window (dired-get-filename))
- (vc-start-entry nil nil nil
- "Enter a change comment for the marked files."
- 'vc-next-action-dired)
- (throw 'nogo nil))))
+ (if (string= ""
+ (mapconcat
+ (function (lambda (f)
+ (if (eq (vc-backend f) 'CVS)
+ (if (or (eq (vc-cvs-status f) 'locally-modified)
+ (eq (vc-cvs-status f) 'locally-added))
+ "@" "")
+ (if (vc-locking-user f) "@" ""))))
+ files ""))
+ (vc-next-action-dired nil nil "dummy")
+ (vc-start-entry nil nil nil
+ "Enter a change comment for the marked files."
+ 'vc-next-action-dired))
+ (throw 'nogo nil)))
(while vc-parent-buffer
(pop-to-buffer vc-parent-buffer))
(if buffer-file-name
;;; These functions help the vc-next-action entry point
-(defun vc-checkout-writable-buffer (&optional file)
+(defun vc-checkout-writable-buffer (&optional file rev)
"Retrieve a writable copy of the latest version of the current buffer's file."
- (vc-checkout (or file (buffer-file-name)) t)
+ (vc-checkout (or file (buffer-file-name)) t rev)
)
;;;###autoload
(defun vc-register (&optional override comment)
"Register the current file into your version-control system."
(interactive "P")
- (if (vc-name buffer-file-name)
- (error "This file is already registered"))
+ (or buffer-file-name
+ (error "No visited file"))
+ (let ((master (vc-name buffer-file-name)))
+ (and master (file-exists-p master)
+ (error "This file is already registered"))
+ (and master
+ (not (y-or-n-p "Previous master file has vanished. Make a new one? "))
+ (error "This file is already registered")))
;; Watch out for new buffers of size 0: the corresponding file
;; does not exist yet, even though buffer-modified-p is nil.
(if (and (not (buffer-modified-p))
(not (file-exists-p buffer-file-name)))
(set-buffer-modified-p t))
(vc-buffer-sync)
+ (cond ((not vc-make-backup-files)
+ ;; inhibit backup for this buffer
+ (make-local-variable 'backup-inhibited)
+ (setq backup-inhibited t)))
(vc-admin
buffer-file-name
(and override
(and (string= buffer-file-name file)
(if keep
(progn
+ ;; temporarily remove vc-find-file-hook, so that
+ ;; we don't lose the properties
+ (remove-hook 'find-file-hooks 'vc-find-file-hook)
(vc-revert-buffer1 t noquery)
+ (add-hook 'find-file-hooks 'vc-find-file-hook)
(vc-mode-line buffer-file-name))
- (progn
- (delete-window)
- (kill-buffer (current-buffer))))))
+ (kill-buffer (current-buffer)))))
+
+(defun vc-resynch-buffer (file &optional keep noquery)
+ ;; if FILE is currently visited, resynch its buffer
+ (let ((buffer (get-file-buffer file)))
+ (if buffer
+ (save-excursion
+ (set-buffer buffer)
+ (vc-resynch-window file keep noquery)))))
(defun vc-start-entry (file rev comment msg action &optional after-hook)
;; Accept a comment for an operation on FILE revision REV. If COMMENT
;; is nil, pop up a VC-log buffer, emit MSG, and set the
;; action on close to ACTION; otherwise, do action immediately.
- ;; Remember the file's buffer in parent-buffer (current one if no file).
+ ;; Remember the file's buffer in vc-parent-buffer (current one if no file).
;; AFTER-HOOK specifies the local value for vc-log-operation-hook.
(let ((parent (if file (find-file-noselect file) (current-buffer))))
(if comment
(set (make-local-variable 'vc-parent-buffer) parent)
(set (make-local-variable 'vc-parent-buffer-name)
(concat " from " (buffer-name vc-parent-buffer)))
- (vc-mode-line (or file " (no file)"))
+ (if file (vc-mode-line file))
(vc-log-mode)
(make-local-variable 'vc-log-after-operation-hook)
(if after-hook
(vc-start-entry file rev
(or comment (not vc-initial-comment))
"Enter initial comment." 'vc-backend-admin
- 'vc-checkout-writable-buffer-hook))
+ nil))
-(defun vc-checkout (file &optional writable)
+(defun vc-checkout (file &optional writable rev)
"Retrieve a copy of the latest version of the given file."
;; If ftp is on this system and the name matches the ange-ftp format
;; for a remote file, the user is trying something that won't work.
(if (and (string-match "^/[^/:]+:" file) (vc-find-binary "ftp"))
(error "Sorry, you can't check out files over FTP"))
- (vc-backend-checkout file writable)
- (if (string-equal file buffer-file-name)
- (vc-resynch-window file t t))
- )
+ (vc-backend-checkout file writable rev)
+ (vc-resynch-buffer file t t))
(defun vc-steal-lock (file rev &optional owner)
"Steal the lock on the current workfile."
- (interactive)
- (if (not owner)
- (setq owner (vc-locking-user file)))
- (if (not (y-or-n-p (format "Take the lock on %s:%s from %s? " file rev owner)))
- (error "Steal cancelled"))
- (pop-to-buffer (get-buffer-create "*VC-mail*"))
- (setq default-directory (expand-file-name "~/"))
- (auto-save-mode auto-save-default)
- (mail-mode)
- (erase-buffer)
- (mail-setup owner (format "%s:%s" file rev) nil nil nil
- (list (list 'vc-finish-steal file rev)))
- (goto-char (point-max))
- (insert
- (format "I stole the lock on %s:%s, " file rev)
- (current-time-string)
- ".\n")
- (message "Please explain why you stole the lock. Type C-c C-c when done."))
+ (let (file-description)
+ (if (not owner)
+ (setq owner (vc-locking-user file)))
+ (if rev
+ (setq file-description (format "%s:%s" file rev))
+ (setq file-description file))
+ (if (not (y-or-n-p (format "Take the lock on %s from %s? "
+ file-description owner)))
+ (error "Steal cancelled"))
+ (pop-to-buffer (get-buffer-create "*VC-mail*"))
+ (setq default-directory (expand-file-name "~/"))
+ (auto-save-mode auto-save-default)
+ (mail-mode)
+ (erase-buffer)
+ (mail-setup owner (format "Stolen lock on %s" file-description) nil nil nil
+ (list (list 'vc-finish-steal file rev)))
+ (goto-char (point-max))
+ (insert
+ (format "I stole the lock on %s, " file-description)
+ (current-time-string)
+ ".\n")
+ (message "Please explain why you stole the lock. Type C-c C-c when done.")))
;; This is called when the notification has been sent.
(defun vc-finish-steal (file version)
(vc-backend-steal file version)
- (vc-resynch-window file t t))
+ (if (get-file-buffer file)
+ (save-excursion
+ (set-buffer (get-file-buffer file))
+ (vc-resynch-window file t t))))
(defun vc-checkin (file &optional rev comment)
"Check in the file specified by FILE.
The optional argument REV may be a string specifying the new version level
\(if nil increment the current level). The file is either retained with write
permissions zeroed, or deleted (according to the value of `vc-keep-workfiles').
+If the back-end is CVS, a writable workfile is always kept.
COMMENT is a comment string; if omitted, a buffer is
popped up to accept a comment."
(vc-start-entry file rev comment
(indent-to indentation))
(setq end (point))))
;; Fill the inserted text, preserving open-parens at bol.
- (let ((paragraph-separate (concat paragraph-separate "\\|^\\s *\\s("))
- (paragraph-start (concat paragraph-start "\\|^\\s *\\s(")))
+ (let ((paragraph-separate (concat paragraph-separate "\\|\\s *\\s("))
+ (paragraph-start (concat paragraph-start "\\|\\s *\\s(")))
(beginning-of-line)
(fill-region (point) end))
;; Canonicalize the white space at the end of the entry so it is
(ring-insert vc-comment-ring (buffer-string))
))
;; Sync parent buffer in case the user modified it while editing the comment.
+ ;; But not if it is a vc-dired buffer.
(save-excursion
- (let ((buffer (get-file-buffer vc-log-file)))
- (if buffer
- (progn
- (set-buffer buffer)
- (vc-buffer-sync)))))
- ;; OK, do it to it
- (if vc-log-operation
- (save-excursion
- (funcall vc-log-operation
- vc-log-file
- vc-log-version
- (buffer-string)))
- (error "No log operation is pending"))
- ;; save the vc-log-after-operation-hook of log buffer
- (let ((after-hook vc-log-after-operation-hook))
+ (set-buffer vc-parent-buffer)
+ (or vc-dired-mode
+ (vc-buffer-sync)))
+ (if (not vc-log-operation) (error "No log operation is pending"))
+ ;; save the parameters held in buffer-local variables
+ (let ((log-operation vc-log-operation)
+ (log-file vc-log-file)
+ (log-version vc-log-version)
+ (log-entry (buffer-string))
+ (after-hook vc-log-after-operation-hook))
;; Return to "parent" buffer of this checkin and remove checkin window
(pop-to-buffer vc-parent-buffer)
(let ((logbuf (get-buffer "*VC-log*")))
(delete-windows-on logbuf)
(kill-buffer logbuf))
+ ;; OK, do it to it
+ (save-excursion
+ (funcall log-operation
+ log-file
+ log-version
+ log-entry))
;; Now make sure we see the expanded headers
(if buffer-file-name
(vc-resynch-window buffer-file-name vc-keep-workfiles t))
;; problem is that the `old' file doesn't exist to be
;; visited. This plays hell with numerous assumptions in
;; the diff.el and compile.el machinery.
- (pop-to-buffer "*vc*")
- (pop-to-buffer "*vc*")
+ (pop-to-buffer "*vc-diff*")
+ (setq default-directory (file-name-directory file))
(if (= 0 (buffer-size))
(progn
(setq unchanged t)
" and "
(or rel2 "current workfile(s)")
":\n\n")
- (set-buffer (get-buffer-create "*vc*"))
+ (set-buffer (get-buffer-create "*vc-diff*"))
(cd file)
(vc-file-tree-walk
+ default-directory
(function (lambda (f)
(message "Looking at %s" f)
(and
)
(if (zerop (vc-backend-diff file rel1 rel2))
(message "No changes to %s between %s and %s." file rel1 rel2)
- (pop-to-buffer "*vc*"))))
+ (pop-to-buffer "*vc-diff*"))))
;;;###autoload
(defun vc-version-other-window (rev)
(let* ((delims (cdr (assq major-mode vc-comment-alist)))
(comment-start-vc (or (car delims) comment-start "#"))
(comment-end-vc (or (car (cdr delims)) comment-end ""))
- (hdstrings (cdr (assoc (vc-backend-deduce (buffer-file-name)) vc-header-alist))))
+ (hdstrings (cdr (assoc (vc-backend (buffer-file-name)) vc-header-alist))))
(mapcar (function (lambda (s)
(insert comment-start-vc "\t" s "\t"
comment-end-vc "\n")))
)
)))))
-;; The VC directory submode. Coopt Dired for this.
-;; All VC commands get mapped into logical equivalents.
-
-(defvar vc-dired-prefix-map (make-sparse-keymap))
-(define-key vc-dired-prefix-map "\C-xv" vc-prefix-map)
+(defun vc-clear-headers ()
+ ;; Clear all version headers in the current buffer, i.e. reset them
+ ;; to the nonexpanded form. Only implemented for RCS, yet.
+ ;; Don't lose point and mark during this.
+ (let ((context (vc-buffer-context)))
+ (goto-char (point-min))
+ (while (re-search-forward "\\$\\([A-Za-z]+\\): [^\\$]+\\$" nil t)
+ (replace-match "$\\1$"))
+ (vc-restore-buffer-context context)))
-(or (not (boundp 'minor-mode-map-alist))
- (assq 'vc-dired-mode minor-mode-map-alist)
- (setq minor-mode-map-alist
- (cons (cons 'vc-dired-mode vc-dired-prefix-map)
- minor-mode-map-alist)))
+;; The VC directory major mode. Coopt Dired for this.
+;; All VC commands get mapped into logical equivalents.
-(defun vc-dired-mode ()
- "The augmented Dired minor mode used in VC directory buffers.
+(define-derived-mode vc-dired-mode dired-mode "Dired under VC"
+ "The major mode used in VC directory buffers. It is derived from Dired.
All Dired commands operate normally. Users currently locking listed files
are listed in place of the file's owner and group.
Keystrokes bound to VC commands will execute as though they had been called
on a buffer attached to the file named in the current Dired buffer line."
- (setq vc-dired-mode t)
- (setq vc-mode " under VC"))
+ (setq vc-dired-mode t))
+
+(define-key vc-dired-mode-map "\C-xv" vc-prefix-map)
+(define-key vc-dired-mode-map "g" 'vc-dired-update)
+(define-key vc-dired-mode-map "=" 'vc-diff)
+
+(defun vc-dired-state-info (file)
+ ;; Return the string that indicates the version control status
+ ;; on a VC dired line.
+ (let ((cvs-state (and (eq (vc-backend file) 'CVS)
+ (vc-cvs-status file))))
+ (if cvs-state
+ (cond ((eq cvs-state 'up-to-date) nil)
+ ((eq cvs-state 'needs-checkout) "patch")
+ ((eq cvs-state 'locally-modified) "modified")
+ ((eq cvs-state 'needs-merge) "merge")
+ ((eq cvs-state 'unresolved-conflict) "conflict")
+ ((eq cvs-state 'locally-added) "added"))
+ (vc-locking-user file))))
(defun vc-dired-reformat-line (x)
;; Hack a directory-listing line, plugging in locking-user info in
;; (insert (concat x "\t")))
;;
;; This code, like dired, assumes UNIX -l format.
- (forward-word 1) ;; skip over any extra field due to -ibs options
- (if x (setq x (concat "(" x ")")))
- (if (re-search-forward "\\([0-9]+ \\).................\\( .*\\)" nil 0)
- (let ((rep (substring (concat x " ") 0 9)))
- (replace-match (concat "\\1" rep "\\2") t)))
- )
+ (let ((pos (point)) limit perm owner date-and-file)
+ (end-of-line)
+ (setq limit (point))
+ (goto-char pos)
+ (cond
+ ((or
+ (re-search-forward ;; owner and group
+"\\([drwxlts-]+ \\) *[0-9]+ \\([^ ]+\\) +[^ ]+ +[0-9]+\\( [^ 0-9]+ [0-9 ][0-9] .*\\)"
+ limit t)
+ (re-search-forward ;; only owner displayed
+"\\([drwxlts-]+ \\) *[0-9]+ \\([^ ]+\\) +[0-9]+\\( [^ 0-9]+ [0-9 ][0-9] .*\\)"
+ limit t))
+ (setq perm (match-string 1)
+ owner (match-string 2)
+ date-and-file (match-string 3)))
+ ((re-search-forward ;; OS/2 -l format, no links, owner, group
+"\\([drwxlts-]+ \\) *[0-9]+\\( [^ 0-9]+ [0-9 ][0-9] .*\\)"
+ limit t)
+ (setq perm (match-string 1)
+ date-and-file (match-string 2))))
+ (if (numberp x) (setq x (or owner (number-to-string x))))
+ (if x (setq x (concat "(" x ")")))
+ (let ((rep (substring (concat x " ") 0 10)))
+ (replace-match (concat perm rep date-and-file)))))
+
+(defun vc-dired-update-line (file)
+ ;; Update the vc-dired listing line of file -- it is assumed
+ ;; that point is already on this line. Don't use dired-do-redisplay
+ ;; for this, because it cannot handle the way vc-dired deals with
+ ;; subdirectories.
+ (beginning-of-line)
+ (forward-char 2)
+ (let ((start (point)))
+ (forward-line 1)
+ (beginning-of-line)
+ (delete-region start (point))
+ (insert-directory file dired-listing-switches)
+ (forward-line -1)
+ (end-of-line)
+ (delete-char (- (length file)))
+ (insert (substring file (length (expand-file-name default-directory))))
+ (goto-char start))
+ (vc-dired-reformat-line (vc-dired-state-info file)))
+
+(defun vc-dired-update (verbose)
+ (interactive "P")
+ (vc-directory default-directory verbose))
;;; Note in Emacs 18 the following defun gets overridden
;;; with the symbol 'vc-directory-18. See below.
;;;###autoload
-(defun vc-directory (verbose)
- "Show version-control status of all files under the current directory."
- (interactive "P")
+(defun vc-directory (dirname verbose)
+ "Show version-control status of the current directory and subdirectories.
+Normally it creates a Dired buffer that lists only the locked files
+in all these directories. With a prefix argument, it lists all files."
+ (interactive "DDired under VC (directory): \nP")
+ (setq dirname (expand-file-name dirname))
+ ;; force a trailing slash
+ (if (not (eq (elt dirname (1- (length dirname))) ?/))
+ (setq dirname (concat dirname "/")))
(let (nonempty
- (dl (length default-directory))
- (filelist nil) (userlist nil)
+ (dl (length dirname))
+ (filelist nil) (statelist nil)
+ (old-dir default-directory)
dired-buf
dired-buf-mod-count)
(vc-file-tree-walk
- (function (lambda (f)
- (if (vc-registered f)
- (let ((user (vc-locking-user f)))
- (and (or verbose user)
- (setq filelist (cons (substring f dl) filelist))
- (setq userlist (cons user userlist))))))))
- (save-excursion
- ;; This uses a semi-documented feature of dired; giving a switch
- ;; argument forces the buffer to refresh each time.
- (dired
- (cons default-directory (nreverse filelist))
- dired-listing-switches)
- (setq dired-buf (current-buffer))
- (setq nonempty (not (zerop (buffer-size)))))
+ dirname
+ (function
+ (lambda (f)
+ (if (vc-registered f)
+ (let ((state (vc-dired-state-info f)))
+ (and (or verbose state)
+ (setq filelist (cons (substring f dl) filelist))
+ (setq statelist (cons state statelist))))))))
+ (save-window-excursion
+ (save-excursion
+ ;; This uses a semi-documented feature of dired; giving a switch
+ ;; argument forces the buffer to refresh each time.
+ (setq dired-buf
+ (dired-internal-noselect
+ (cons dirname (nreverse filelist))
+ dired-listing-switches 'vc-dired-mode))
+ (setq nonempty (not (eq 0 (length filelist))))))
+ (switch-to-buffer dired-buf)
+ ;; Make a few modifications to the header
+ (setq buffer-read-only nil)
+ (goto-char (point-min))
+ (forward-line 1) ;; Skip header line
+ (let ((start (point))) ;; Erase (but don't remove) the
+ (end-of-line) ;; "wildcard" line.
+ (delete-region start (point)))
+ (beginning-of-line)
(if nonempty
(progn
- (pop-to-buffer dired-buf)
- (vc-dired-mode)
- (goto-char (point-min))
- (setq buffer-read-only nil)
- (forward-line 1) ;; Skip header line
+ ;; Plug the version information into the individual lines
(mapcar
(function
(lambda (x)
(forward-char 2) ;; skip dired's mark area
(vc-dired-reformat-line x)
(forward-line 1))) ;; go to next line
- (nreverse userlist))
+ (nreverse statelist))
(setq buffer-read-only t)
(goto-char (point-min))
+ (dired-next-line 2)
)
+ (dired-next-line 1)
+ (insert " ")
+ (setq buffer-read-only t)
(message "No files are currently %s under %s"
- (if verbose "registered" "locked") default-directory))
+ (if verbose "registered" "locked") dirname))
))
;; Emacs 18 version
(erase-buffer)
(cd dir)
(vc-file-tree-walk
+ default-directory
(function (lambda (f)
(if (vc-registered f)
(let ((user (vc-locking-user f)))
"%s %s\n"
(concat user) f))))))))
(setq nonempty (not (zerop (buffer-size)))))
+
(if nonempty
(progn
(pop-to-buffer "*vc-status*" t)
(or (boundp 'minor-mode-map-alist)
(fset 'vc-directory 'vc-directory-18))
-; Emacs 18 also lacks these.
-(or (boundp 'compilation-old-error-list)
- (setq compilation-old-error-list nil))
-
;; Named-configuration support for SCCS
(defun vc-add-triple (name file rev)
(save-excursion
- (find-file (concat (vc-backend-subdirectory-name file) "/" vc-name-assoc-file))
+ (find-file (expand-file-name
+ vc-name-assoc-file
+ (file-name-as-directory
+ (expand-file-name (vc-backend-subdirectory-name file)
+ (file-name-directory file)))))
(goto-char (point-max))
(insert name "\t:\t" file "\t" rev "\n")
(basic-save-buffer)
(defun vc-record-rename (file newname)
(save-excursion
- (find-file (concat (vc-backend-subdirectory-name file) "/" vc-name-assoc-file))
+ (find-file
+ (expand-file-name
+ vc-name-assoc-file
+ (file-name-as-directory
+ (expand-file-name (vc-backend-subdirectory-name file)
+ (file-name-directory file)))))
(goto-char (point-min))
;; (replace-regexp (concat ":" (regexp-quote file) "$") (concat ":" newname))
(while (re-search-forward (concat ":" (regexp-quote file) "$") nil t)
(and (>= firstchar ?0) (<= firstchar ?9)))
name)
(t
- (car (vc-master-info
- (concat (vc-backend-subdirectory-name file) "/" vc-name-assoc-file)
- (list (concat name "\t:\t" file "\t\\(.+\\)"))))
- )))
+ (save-excursion
+ (set-buffer (get-buffer-create "*vc-info*"))
+ (vc-insert-file
+ (expand-file-name
+ vc-name-assoc-file
+ (file-name-as-directory
+ (expand-file-name (vc-backend-subdirectory-name file)
+ (file-name-directory file)))))
+ (prog1
+ (car (vc-parse-buffer
+ (list (list (concat name "\t:\t" file "\t\\(.+\\)") 1))))
+ (kill-buffer "*vc-info*"))))
+ ))
;; Named-configuration entry points
-(defun vc-locked-example ()
- ;; Return an example of why the current directory is not ready to be snapshot
- ;; or nil if no such example exists.
- (catch 'vc-locked-example
- (vc-file-tree-walk
- (function (lambda (f)
- (if (and (vc-registered f) (vc-locking-user f))
- (throw 'vc-locked-example f)))))
- nil))
+(defun vc-snapshot-precondition ()
+ ;; Scan the tree below the current directory.
+ ;; If any files are locked, return the name of the first such file.
+ ;; (This means, neither snapshot creation nor retrieval is allowed.)
+ ;; If one or more of the files are currently visited, return `visited'.
+ ;; Otherwise, return nil.
+ (let ((status nil))
+ (catch 'vc-locked-example
+ (vc-file-tree-walk
+ default-directory
+ (function (lambda (f)
+ (and (vc-registered f)
+ (if (vc-locking-user f) (throw 'vc-locked-example f)
+ (if (get-file-buffer f) (setq status 'visited)))))))
+ status)))
;;;###autoload
(defun vc-create-snapshot (name)
directory. For each file, the version level of its latest
version becomes part of the named configuration."
(interactive "sNew snapshot name: ")
- (let ((locked (vc-locked-example)))
- (if locked
- (error "File %s is locked" locked)
+ (let ((result (vc-snapshot-precondition)))
+ (if (stringp result)
+ (error "File %s is locked" result)
(vc-file-tree-walk
+ default-directory
(function (lambda (f) (and
(vc-name f)
(vc-backend-assign-name f name)))))
Otherwise, all registered files are checked out (unlocked) at their version
levels in the snapshot."
(interactive "sSnapshot name to retrieve: ")
- (let ((locked (vc-locked-example)))
- (if locked
- (error "File %s is locked" locked)
+ (let ((result (vc-snapshot-precondition))
+ (update nil))
+ (if (stringp result)
+ (error "File %s is locked" result)
+ (if (eq result 'visited)
+ (setq update (yes-or-no-p "Update the affected buffers? ")))
(vc-file-tree-walk
+ default-directory
(function (lambda (f) (and
(vc-name f)
(vc-error-occurred
- (vc-backend-checkout f nil name))))))
+ (vc-backend-checkout f nil name)
+ (if update (vc-resynch-buffer f t t)))))))
)))
;; Miscellaneous other entry points
(while vc-parent-buffer
(pop-to-buffer vc-parent-buffer))
(if (and buffer-file-name (vc-name buffer-file-name))
- (progn
- (vc-backend-print-log buffer-file-name)
+ (let ((file buffer-file-name))
+ (vc-backend-print-log file)
(pop-to-buffer (get-buffer-create "*vc*"))
+ (setq default-directory (file-name-directory file))
(while (looking-at "=*\n")
(delete-char (- (match-end 0) (match-beginning 0)))
(forward-line -1))
(defun vc-revert-buffer ()
"Revert the current buffer's file back to the latest checked-in version.
This asks for confirmation if the buffer contents are not identical
-to that version."
+to that version.
+If the back-end is CVS, this will give you the most recent revision of
+the file on the branch you are editing."
(interactive)
(if vc-dired-mode
(find-file-other-window (dired-get-filename)))
(if (and changed (or vc-suppress-confirm
(not (yes-or-no-p "Discard changes? "))))
(progn
- (delete-window)
+ (if (and (window-dedicated-p (selected-window))
+ (one-window-p t 'selected-frame))
+ (make-frame-invisible (selected-frame))
+ (delete-window))
(error "Revert cancelled"))
(set-buffer obuf))
(if changed
- (delete-window))
+ (if (and (window-dedicated-p (selected-window))
+ (one-window-p t 'selected-frame))
+ (make-frame-invisible (selected-frame))
+ (delete-window)))
(vc-backend-revert file)
(vc-resynch-window file t t)
)
(find-file-other-window (dired-get-filename)))
(while vc-parent-buffer
(pop-to-buffer vc-parent-buffer))
- (let* ((target (concat (vc-latest-version (buffer-file-name))))
- (yours (concat (vc-your-latest-version (buffer-file-name))))
- (prompt (if (string-equal yours target)
- "Remove your version %s from master? "
- "Version %s was not your change. Remove it anyway? ")))
- (if (null (yes-or-no-p (format prompt target)))
+ (cond
+ ((eq (vc-backend (buffer-file-name)) 'CVS)
+ (error "Unchecking files under CVS is dangerous and not supported in VC"))
+ ((vc-locking-user (buffer-file-name))
+ (error "This version is locked. Use vc-revert-buffer to discard changes."))
+ ((not (vc-latest-on-branch-p (buffer-file-name)))
+ (error "This is not the latest version. VC cannot cancel it.")))
+ (let ((target (vc-workfile-version (buffer-file-name))))
+ (if (null (yes-or-no-p "Remove this version from master? "))
nil
+ (setq norevert (or norevert (not
+ (yes-or-no-p "Revert buffer to most recent remaining version? "))))
(vc-backend-uncheck (buffer-file-name) target)
- (if (or norevert
- (not (yes-or-no-p "Revert buffer to most recent remaining version? ")))
- (vc-mode-line (buffer-file-name))
- (vc-checkout (buffer-file-name) nil)))
- ))
+ (if (not norevert)
+ (vc-checkout (buffer-file-name) nil)
+ ;; If norevert, lock the most recent remaining version,
+ ;; and mark the buffer modified.
+ (if (eq (vc-backend (buffer-file-name)) 'RCS)
+ (progn (setq buffer-read-only nil)
+ (vc-clear-headers)))
+ (vc-backend-checkout (buffer-file-name) t (vc-branch-part target))
+ (set-visited-file-name (buffer-file-name))
+ (vc-mode-line (buffer-file-name)))
+ (message "Version %s has been removed from the master." target)
+ )))
+;;;###autoload
(defun vc-rename-file (old new)
"Rename file OLD to NEW, and rename its master file likewise."
(interactive "fVC rename file: \nFRename to: ")
+ ;; There are several ways of renaming files under CVS 1.3, but they all
+ ;; have serious disadvantages. See the FAQ (available from think.com in
+ ;; pub/cvs/). I'd rather send the user an error, than do something he might
+ ;; consider to be wrong. When the famous, long-awaited rename database is
+ ;; implemented things might change for the better. This is unlikely to occur
+ ;; until CVS 2.0 is released. --ceder 1994-01-23 21:27:51
+ (if (eq (vc-backend old) 'CVS)
+ (error "Renaming files under CVS is dangerous and not supported in VC."))
(let ((oldbuf (get-file-buffer old)))
(if (and oldbuf (buffer-modified-p oldbuf))
(error "Please save files before moving them"))
(error "This is not a safe thing to do in the presence of symbolic links"))
(rename-file
oldmaster
- (let ((backend (vc-backend-deduce old))
+ (let ((backend (vc-backend old))
(newdir (or (file-name-directory new) ""))
(newbase (file-name-nondirectory new)))
(catch 'found
(set-buffer-modified-p nil))))
;; This had FILE, I changed it to OLD. -- rms.
(vc-backend-dispatch old
- (vc-record-rename old new)
- nil)
+ (vc-record-rename old new) ;SCCS
+ nil ;RCS
+ nil ;CVS
+ )
)
;;;###autoload
file)
(while buffers
(setq file (buffer-file-name (car buffers)))
- (and file (vc-backend-deduce file)
+ (and file (vc-backend file)
(setq files (cons file files)))
(setq buffers (cdr buffers)))
files))
(message "Computing change log entries... %s"
(if (or (null args)
(eq 0 (apply 'call-process "rcs2log" nil t nil
- "-n"
- (user-login-name)
- (user-full-name)
- user-mail-address
+ "-u"
+ (concat (user-login-name)
+ "\t"
+ (user-full-name)
+ "\t"
+ user-mail-address)
(mapcar (function
(lambda (f)
(file-relative-name
args))))
"done" "failed"))))
-;; Functions for querying the master and lock files.
-
-(defun vc-match-substring (bn)
- (buffer-substring (match-beginning bn) (match-end bn)))
-
-(defun vc-parse-buffer (patterns &optional file properties)
- ;; Use PATTERNS to parse information out of the current buffer
- ;; by matching each regular expression in the list and returning \\1.
- ;; If a regexp has two tag brackets, assume the second is a date
- ;; field and we want the most recent entry matching the template.
- ;; If FILE and PROPERTIES are given, the latter must be a list of
- ;; properties of the same length as PATTERNS; each property is assigned
- ;; the corresponding value.
- (mapcar (function (lambda (p)
- (goto-char (point-min))
- (if (string-match "\\\\(.*\\\\(" p)
- (let ((latest-date "") (latest-val))
- (while (re-search-forward p nil t)
- (let ((date (vc-match-substring 2)))
- (if (string< latest-date date)
- (progn
- (setq latest-date date)
- (setq latest-val
- (vc-match-substring 1))))))
- latest-val))
- (prog1
- (let ((value nil))
- (if (re-search-forward p nil t)
- (setq value (vc-match-substring 1)))
- (if file
- (vc-file-setprop file (car properties) value))
- value)
- (setq properties (cdr properties)))))
- patterns)
- )
-
-(defun vc-master-info (file fields &optional rfile properties)
- ;; Search for information in a master file.
- (if (and file (file-exists-p file))
- (save-excursion
- (let ((buf))
- (setq buf (create-file-buffer file))
- (set-buffer buf))
- (erase-buffer)
- (insert-file-contents file nil)
- (set-buffer-modified-p nil)
- (auto-save-mode nil)
- (prog1
- (vc-parse-buffer fields rfile properties)
- (kill-buffer (current-buffer)))
- )
- (if rfile
- (mapcar
- (function (lambda (p) (vc-file-setprop rfile p nil)))
- properties))
- )
- )
-
-(defun vc-log-info (command file patterns &optional properties)
- ;; Search for information in log program output
- (if (and file (file-exists-p file))
- (save-excursion
- (let ((buf))
- (setq buf (get-buffer-create "*vc*"))
- (set-buffer buf))
- (apply 'vc-do-command 0 command file nil)
- (set-buffer-modified-p nil)
- (prog1
- (vc-parse-buffer patterns file properties)
- (kill-buffer (current-buffer))
- )
- )
- (if file
- (mapcar
- (function (lambda (p) (vc-file-setprop file p nil)))
- properties))
- )
- )
-
-(defun vc-locking-user (file)
- "Return the name of the person currently holding a lock on FILE.
-Return nil if there is no such person."
- (setq file (expand-file-name file)) ;; ??? Work around bug in 19.0.4
- (if (or (not vc-keep-workfiles)
- (eq vc-mistrust-permissions 't)
- (and vc-mistrust-permissions
- (funcall vc-mistrust-permissions (vc-backend-subdirectory-name file))))
- (vc-true-locking-user file)
- ;; This implementation assumes that any file which is under version
- ;; control and has -rw-r--r-- is locked by its owner. This is true
- ;; for both RCS and SCCS, which keep unlocked files at -r--r--r--.
- ;; We have to be careful not to exclude files with execute bits on;
- ;; scripts can be under version control too. Also, we must ignore
- ;; the group-read and other-read bits, since paranoid users turn them off.
- ;; This hack wins because calls to the very expensive vc-fetch-properties
- ;; function only have to be made if (a) the file is locked by someone
- ;; other than the current user, or (b) some untoward manipulation
- ;; behind vc's back has changed the owner or the `group' or `other'
- ;; write bits.
- (let ((attributes (file-attributes file)))
- (cond ((string-match ".r-..-..-." (nth 8 attributes))
- nil)
- ((and (= (nth 2 attributes) (user-uid))
- (string-match ".rw..-..-." (nth 8 attributes)))
- (user-login-name))
- (t
- (vc-true-locking-user file))))))
-
-(defun vc-true-locking-user (file)
- ;; The slow but reliable version
- (vc-fetch-properties file)
- (vc-file-getprop file 'vc-locking-user))
-
-(defun vc-latest-version (file)
- ;; Return version level of the latest version of FILE
- (vc-fetch-properties file)
- (vc-file-getprop file 'vc-latest-version))
-
-(defun vc-your-latest-version (file)
- ;; Return version level of the latest version of FILE checked in by you
- (vc-fetch-properties file)
- (vc-file-getprop file 'vc-your-latest-version))
-
;; Collect back-end-dependent stuff here
-;;
-;; Everything eventually funnels through these functions. To implement
-;; support for a new version-control system, add another branch to the
-;; vc-backend-dispatch macro and fill it in in each call. The variable
-;; vc-master-templates in vc-hooks.el will also have to change.
-
-(defmacro vc-backend-dispatch (f s r)
- "Execute FORM1 or FORM2 depending on whether we're using SCCS or RCS."
- (list 'let (list (list 'type (list 'vc-backend-deduce f)))
- (list 'cond
- (list (list 'eq 'type (quote 'SCCS)) s) ;; SCCS
- (list (list 'eq 'type (quote 'RCS)) r) ;; RCS
- )))
-
-(defun vc-lock-file (file)
- ;; Generate lock file name corresponding to FILE
- (let ((master (vc-name file)))
- (and
- master
- (string-match "\\(.*/\\)s\\.\\(.*\\)" master)
- (concat
- (substring master (match-beginning 1) (match-end 1))
- "p."
- (substring master (match-beginning 2) (match-end 2))))))
-
-
-(defun vc-fetch-properties (file)
- ;; Re-fetch all properties associated with the given file.
- ;; Currently these properties are:
- ;; vc-locking-user
- ;; vc-locked-version
- ;; vc-latest-version
- ;; vc-your-latest-version
- (vc-backend-dispatch
- file
- ;; SCCS
- (progn
- (vc-master-info (vc-lock-file file)
- (list
- "^[^ ]+ [^ ]+ \\([^ ]+\\)"
- "^\\([^ ]+\\)")
- file
- '(vc-locking-user vc-locked-version))
- (vc-master-info (vc-name file)
- (list
- "^\001d D \\([^ ]+\\)"
- (concat "^\001d D \\([^ ]+\\) .* "
- (regexp-quote (user-login-name)) " ")
- )
- file
- '(vc-latest-version vc-your-latest-version))
- )
- ;; RCS
- (vc-log-info "rlog" file
- (list
- "^locks: strict\n\t\\([^:]+\\)"
- "^locks: strict\n\t[^:]+: \\(.+\\)"
- "^revision[\t ]+\\([0-9.]+\\).*\ndate: \\([ /0-9:]+\\);"
- (concat
- "^revision[\t ]+\\([0-9.]+\\)\n.*author: "
- (regexp-quote (user-login-name))
- ";"))
- '(vc-locking-user vc-locked-version
- vc-latest-version vc-your-latest-version))
- ))
-
-(defun vc-backend-subdirectory-name (&optional file)
- ;; Where the master and lock files for the current directory are kept
- (symbol-name
- (or
- (and file (vc-backend-deduce file))
- vc-default-back-end
- (setq vc-default-back-end (if (vc-find-binary "rcs") 'RCS 'SCCS)))))
(defun vc-backend-admin (file &optional rev comment)
;; Register a file into the version-control system
((file-exists-p (vc-backend-subdirectory-name)) vc-default-back-end)
((file-exists-p "RCS") 'RCS)
((file-exists-p "SCCS") 'SCCS)
+ ((file-exists-p "CVS") 'CVS)
(t vc-default-back-end))))
(cond ((eq backend 'SCCS)
- (vc-do-command 0 "admin" file ;; SCCS
+ (vc-do-command nil 0 "admin" file 'MASTER ;; SCCS
(and rev (concat "-r" rev))
"-fb"
(concat "-i" file)
(file-name-nondirectory file)))
(delete-file file)
(if vc-keep-workfiles
- (vc-do-command 0 "get" file)))
+ (vc-do-command nil 0 "get" file 'MASTER)))
((eq backend 'RCS)
- (vc-do-command 0 "ci" file ;; RCS
+ (vc-do-command nil 0 "ci" file 'MASTER ;; RCS
+ ;; if available, use the secure registering option
+ (and (vc-backend-release-p 'RCS "5.6.4") "-i")
(concat (if vc-keep-workfiles "-u" "-r") rev)
(and comment (concat "-t-" comment))
- file)
+ file))
+ ((eq backend 'CVS)
+ (vc-do-command nil 0 "cvs" file 'WORKFILE ;; CVS
+ "add"
+ (and comment (string-match "[^\t\n ]" comment)
+ (concat "-m" comment)))
)))
(message "Registering %s...done" file)
)
(defun vc-backend-checkout (file &optional writable rev workfile)
;; Retrieve a copy of a saved version into a workfile
- (let ((filename (or workfile file)))
+ (let ((filename (or workfile file))
+ (file-buffer (get-file-buffer file))
+ (old-default-dir default-directory))
(message "Checking out %s..." filename)
- (vc-backend-dispatch file
- (vc-do-command 0 "get" file ;; SCCS
- (if writable "-e")
- (if workfile (concat "-G" workfile))
- (and rev (concat "-r" (vc-lookup-triple file rev))))
- (if workfile ;; RCS
- ;; RCS doesn't let us check out into arbitrary file names directly.
- ;; Use `co -p' and make stdout point to the correct file.
- (let ((vc-modes (logior (file-modes (vc-name file))
- (if writable 128 0)))
- (failed t))
- (unwind-protect
- (progn
- (vc-do-command
- 0 "/bin/sh" file "-c"
- (format "umask %o; exec >\"$1\" || exit; shift; umask %o; exec co \"$@\""
- (logand 511 (lognot vc-modes))
- (logand 511 (lognot (default-file-modes))))
- "" ; dummy argument for shell's $0
- filename
- (if writable "-l")
- (concat "-p" rev))
- (setq failed nil))
- (and failed (file-exists-p filename) (delete-file filename))))
- (vc-do-command 0 "co" file
- (if writable "-l")
- (and rev (concat "-r" rev))))
- )
- (or workfile
- (vc-file-setprop file 'vc-checkout-time (nth 5 (file-attributes file))))
- (message "Checking out %s...done" filename))
- )
+ (save-excursion
+ ;; Change buffers to get local value of vc-checkin-switches.
+ (if file-buffer (set-buffer file-buffer))
+ ;; Adjust the default-directory so that the check-out creates
+ ;; the file in the right place. The old value is restored below.
+ (setq default-directory (file-name-directory filename))
+ (vc-backend-dispatch file
+ (if workfile;; SCCS
+ ;; Some SCCS implementations allow checking out directly to a
+ ;; file using the -G option, but then some don't so use the
+ ;; least common denominator approach and use the -p option
+ ;; ala RCS.
+ (let ((vc-modes (logior (file-modes (vc-name file))
+ (if writable 128 0)))
+ (failed t))
+ (unwind-protect
+ (progn
+ (apply 'vc-do-command
+ nil 0 "/bin/sh" file 'MASTER "-c"
+ ;; Some shells make the "" dummy argument into $0
+ ;; while others use the shell's name as $0 and
+ ;; use the "" as $1. The if-statement
+ ;; converts the latter case to the former.
+ (format "if [ x\"$1\" = x ]; then shift; fi; \
+ umask %o; exec >\"$1\" || exit; \
+ shift; umask %o; exec get \"$@\""
+ (logand 511 (lognot vc-modes))
+ (logand 511 (lognot (default-file-modes))))
+ "" ; dummy argument for shell's $0
+ filename
+ (if writable "-e")
+ "-p" (and rev
+ (concat "-r" (vc-lookup-triple file rev)))
+ vc-checkout-switches)
+ (setq failed nil))
+ (and failed (file-exists-p filename) (delete-file filename))))
+ (apply 'vc-do-command nil 0 "get" file 'MASTER ;; SCCS
+ (if writable "-e")
+ (and rev (concat "-r" (vc-lookup-triple file rev)))
+ vc-checkout-switches)
+ (vc-file-setprop file 'vc-workfile-version nil))
+ (if workfile ;; RCS
+ ;; RCS doesn't let us check out into arbitrary file names directly.
+ ;; Use `co -p' and make stdout point to the correct file.
+ (let ((vc-modes (logior (file-modes (vc-name file))
+ (if writable 128 0)))
+ (failed t))
+ (unwind-protect
+ (progn
+ (apply 'vc-do-command
+ nil 0 "/bin/sh" file 'MASTER "-c"
+ ;; See the SCCS case, above, regarding the
+ ;; if-statement.
+ (format "if [ x\"$1\" = x ]; then shift; fi; \
+ umask %o; exec >\"$1\" || exit; \
+ shift; umask %o; exec co \"$@\""
+ (logand 511 (lognot vc-modes))
+ (logand 511 (lognot (default-file-modes))))
+ "" ; dummy argument for shell's $0
+ filename
+ (if writable "-l")
+ (concat "-p" rev)
+ vc-checkout-switches)
+ (setq failed nil))
+ (and failed (file-exists-p filename) (delete-file filename))))
+ (let (new-version)
+ ;; if we should go to the head of the trunk,
+ ;; clear the default branch first
+ (and rev (string= rev "")
+ (vc-do-command nil 0 "rcs" file 'MASTER "-b"))
+ ;; now do the checkout
+ (apply 'vc-do-command
+ nil 0 "co" file 'MASTER
+ ;; If locking is not strict, force to overwrite
+ ;; the writable workfile.
+ (if (eq (vc-checkout-model file) 'implicit) "-f")
+ (if writable "-l")
+ (if rev (concat "-r" rev)
+ ;; if no explicit revision was specified,
+ ;; check out that of the working file
+ (let ((workrev (vc-workfile-version file)))
+ (if workrev (concat "-r" workrev)
+ nil)))
+ vc-checkout-switches)
+ ;; determine the new workfile version
+ (save-excursion
+ (set-buffer "*vc*")
+ (goto-char (point-min))
+ (setq new-version
+ (if (re-search-forward "^revision \\([0-9.]+\\).*\n" nil t)
+ (buffer-substring (match-beginning 1) (match-end 1)))))
+ (vc-file-setprop file 'vc-workfile-version new-version)
+ ;; if necessary, adjust the default branch
+ (and rev (not (string= rev ""))
+ (vc-do-command nil 0 "rcs" file 'MASTER
+ (concat "-b" (if (vc-latest-on-branch-p file)
+ (if (vc-trunk-p new-version) nil
+ (vc-branch-part new-version))
+ new-version))))))
+ (if workfile ;; CVS
+ ;; CVS is much like RCS
+ (let ((failed t))
+ (unwind-protect
+ (progn
+ (apply 'vc-do-command
+ nil 0 "/bin/sh" file 'WORKFILE "-c"
+ "exec >\"$1\" || exit; shift; exec cvs update \"$@\""
+ "" ; dummy argument for shell's $0
+ workfile
+ (concat "-r" rev)
+ "-p"
+ vc-checkout-switches)
+ (setq failed nil))
+ (and failed (file-exists-p filename) (delete-file filename))))
+ ;; default for verbose checkout: clear the sticky tag
+ ;; so that the actual update will get the head of the trunk
+ (and rev (string= rev "")
+ (vc-do-command nil 0 "cvs" file 'WORKFILE "update" "-A"))
+ ;; If a revision was specified, check that out.
+ (if rev
+ (apply 'vc-do-command nil 0 "cvs" file 'WORKFILE
+ (and writable (eq (vc-checkout-model file) 'manual) "-w")
+ "update"
+ (and rev (not (string= rev ""))
+ (concat "-r" rev))
+ vc-checkout-switches)
+ ;; If no revision was specified, simply make the file writable.
+ (and writable
+ (or (eq (vc-checkout-model file) 'manual)
+ (zerop (logand 128 (file-modes file))))
+ (set-file-modes file (logior 128 (file-modes file)))))
+ (if rev (vc-file-setprop file 'vc-workfile-version nil))))
+ (setq default-directory old-default-dir)
+ (cond
+ ((not workfile)
+ (vc-file-clear-masterprops file)
+ (if writable
+ (vc-file-setprop file 'vc-locking-user (user-login-name)))
+ (vc-file-setprop file
+ 'vc-checkout-time (nth 5 (file-attributes file)))))
+ (message "Checking out %s...done" filename))))
(defun vc-backend-logentry-check (file)
(vc-backend-dispatch file
(goto-char 512)
(error
"Log must be less than 512 characters; point is now at pos 512")))
- nil)
+ nil ;; RCS
+ nil) ;; CVS
)
-(defun vc-backend-checkin (file &optional rev comment)
+(defun vc-backend-checkin (file rev comment)
;; Register changes to FILE as level REV with explanatory COMMENT.
;; Automatically retrieves a read-only version of the file with
;; keywords expanded if vc-keep-workfiles is non-nil, otherwise
;; it deletes the workfile.
+ ;; Adaption for RCS branch support: if this is an explicit checkin,
+ ;; or if the checkin creates a new branch, set the master file branch
+ ;; accordingly.
(message "Checking in %s..." file)
+ ;; "This log message intentionally left almost blank".
+ ;; RCS 5.7 gripes about white-space-only comments too.
+ (or (and comment (string-match "[^\t\n ]" comment))
+ (setq comment "*** empty log message ***"))
(save-excursion
;; Change buffers to get local value of vc-checkin-switches.
(set-buffer (or (get-file-buffer file) (current-buffer)))
+ ;; Clear the master-properties. Do that here, not at the
+ ;; end, because if the check-in fails we want them to get
+ ;; re-computed before the next try.
+ (vc-file-clear-masterprops file)
(vc-backend-dispatch file
+ ;; SCCS
(progn
- (apply 'vc-do-command 0 "delta" file
+ (apply 'vc-do-command nil 0 "delta" file 'MASTER
(if rev (concat "-r" rev))
(concat "-y" comment)
vc-checkin-switches)
+ (vc-file-setprop file 'vc-locking-user 'none)
+ (vc-file-setprop file 'vc-workfile-version nil)
(if vc-keep-workfiles
- (vc-do-command 0 "get" file))
+ (vc-do-command nil 0 "get" file 'MASTER))
)
- (apply 'vc-do-command 0 "ci" file
- (concat (if vc-keep-workfiles "-u" "-r") rev)
- (concat "-m" comment)
- vc-checkin-switches)
- ))
- (vc-file-setprop file 'vc-locking-user nil)
- (message "Checking in %s...done" file)
- )
+ ;; RCS
+ (let ((old-version (vc-workfile-version file)) new-version)
+ (apply 'vc-do-command nil 0 "ci" file 'MASTER
+ ;; if available, use the secure check-in option
+ (and (vc-backend-release-p 'RCS "5.6.4") "-j")
+ (concat (if vc-keep-workfiles "-u" "-r") rev)
+ (concat "-m" comment)
+ vc-checkin-switches)
+ (vc-file-setprop file 'vc-locking-user 'none)
+ (vc-file-setprop file 'vc-workfile-version nil)
+
+ ;; determine the new workfile version
+ (set-buffer "*vc*")
+ (goto-char (point-min))
+ (if (or (re-search-forward
+ "new revision: \\([0-9.]+\\);" nil t)
+ (re-search-forward
+ "reverting to previous revision \\([0-9.]+\\)" nil t))
+ (progn (setq new-version (buffer-substring (match-beginning 1)
+ (match-end 1)))
+ (vc-file-setprop file 'vc-workfile-version new-version)))
+
+ ;; if we got to a different branch, adjust the default
+ ;; branch accordingly
+ (cond
+ ((and old-version new-version
+ (not (string= (vc-branch-part old-version)
+ (vc-branch-part new-version))))
+ (vc-do-command nil 0 "rcs" file 'MASTER
+ (if (vc-trunk-p new-version) "-b"
+ (concat "-b" (vc-branch-part new-version))))
+ ;; If this is an old RCS release, we might have
+ ;; to remove a remaining lock.
+ (if (not (vc-backend-release-p 'RCS "5.6.2"))
+ ;; exit status of 1 is also accepted.
+ ;; It means that the lock was removed before.
+ (vc-do-command nil 1 "rcs" file 'MASTER
+ (concat "-u" old-version))))))
+ ;; CVS
+ (progn
+ ;; explicit check-in to the trunk requires a
+ ;; double check-in (first unexplicit) (CVS-1.3)
+ (condition-case nil
+ (progn
+ (if (and rev (vc-trunk-p rev))
+ (apply 'vc-do-command nil 0 "cvs" file 'WORKFILE
+ "ci" "-m" "intermediate"
+ vc-checkin-switches))
+ (apply 'vc-do-command nil 0 "cvs" file 'WORKFILE
+ "ci" (if rev (concat "-r" rev))
+ (concat "-m" comment)
+ vc-checkin-switches))
+ (error (if (eq (vc-cvs-status file) 'needs-merge)
+ ;; The CVS output will be on top of this message.
+ (error "Type C-x 0 C-x C-q to merge in changes.")
+ (error "Check in FAILED."))))
+ ;; determine and store the new workfile version
+ (set-buffer "*vc*")
+ (goto-char (point-min))
+ (if (re-search-forward
+ "^\\(new\\|initial\\) revision: \\([0-9.]+\\)" nil t)
+ (vc-file-setprop file 'vc-workfile-version
+ (buffer-substring (match-beginning 2)
+ (match-end 2)))
+ (vc-file-setprop file 'vc-workfile-version nil))
+ ;; if this was an explicit check-in, remove the sticky tag
+ (if rev
+ (vc-do-command nil 0 "cvs" file 'WORKFILE "update" "-A"))
+ (vc-file-setprop file 'vc-locking-user 'none)
+ (vc-file-setprop file 'vc-checkout-time
+ (nth 5 (file-attributes file))))))
+ (message "Checking in %s...done" file))
(defun vc-backend-revert (file)
;; Revert file to latest checked-in version.
+ ;; (for RCS, to workfile version)
(message "Reverting %s..." file)
+ (vc-file-clear-masterprops file)
(vc-backend-dispatch
file
- (progn ;; SCCS
- (vc-do-command 0 "unget" file nil)
- (vc-do-command 0 "get" file nil))
- (vc-do-command 0 "co" file "-f" "-u")) ;; RCS. This deletes the work file.
- (vc-file-setprop file 'vc-locking-user nil)
+ ;; SCCS
+ (progn
+ (vc-do-command nil 0 "unget" file 'MASTER nil)
+ (vc-do-command nil 0 "get" file 'MASTER nil))
+ ;; RCS
+ (vc-do-command nil 0 "co" file 'MASTER
+ "-f" (concat "-u" (vc-workfile-version file)))
+ ;; CVS
+ (progn
+ (delete-file file)
+ (vc-do-command nil 0 "cvs" file 'WORKFILE "update")))
+ (vc-file-setprop file 'vc-locking-user 'none)
+ (vc-file-setprop file 'vc-checkout-time (nth 5 (file-attributes file)))
(message "Reverting %s...done" file)
)
;; Steal the lock on the current workfile. Needs RCS 5.6.2 or later for -M.
(message "Stealing lock on %s..." file)
(vc-backend-dispatch file
- (progn
- (vc-do-command 0 "unget" file "-n" (if rev (concat "-r" rev)))
- (vc-do-command 0 "get" file "-g" (if rev (concat "-r" rev)))
+ (progn ;SCCS
+ (vc-do-command nil 0 "unget" file 'MASTER "-n" (if rev (concat "-r" rev)))
+ (vc-do-command nil 0 "get" file 'MASTER "-g" (if rev (concat "-r" rev)))
)
- (vc-do-command 0 "rcs" file "-M" (concat "-u" rev) (concat "-l" rev)))
+ (vc-do-command nil 0 "rcs" file 'MASTER ;RCS
+ "-M" (concat "-u" rev) (concat "-l" rev))
+ (error "You cannot steal a CVS lock; there are no CVS locks to steal.") ;CVS
+ )
(vc-file-setprop file 'vc-locking-user (user-login-name))
(message "Stealing lock on %s...done" file)
)
(defun vc-backend-uncheck (file target)
- ;; Undo the latest checkin. Note: this code will have to get a lot
- ;; smarter when we support multiple branches.
+ ;; Undo the latest checkin.
(message "Removing last change from %s..." file)
(vc-backend-dispatch file
- (vc-do-command 0 "rmdel" file (concat "-r" target))
- (vc-do-command 0 "rcs" file (concat "-o" target))
+ (vc-do-command nil 0 "rmdel" file 'MASTER (concat "-r" target))
+ (vc-do-command nil 0 "rcs" file 'MASTER (concat "-o" target))
+ nil ;; this is never reached under CVS
)
(message "Removing last change from %s...done" file)
)
(defun vc-backend-print-log (file)
- ;; Print change log associated with FILE to buffer *vc*.
- (vc-do-command 0
- (vc-backend-dispatch file "prs" "rlog")
- file)
- )
+ ;; Get change log associated with FILE.
+ (vc-backend-dispatch
+ file
+ (vc-do-command nil 0 "prs" file 'MASTER)
+ (vc-do-command nil 0 "rlog" file 'MASTER)
+ (vc-do-command nil 0 "cvs" file 'WORKFILE "rlog")))
(defun vc-backend-assign-name (file name)
;; Assign to a FILE's latest version a given NAME.
(vc-backend-dispatch file
- (vc-add-triple name file (vc-latest-version file)) ;; SCCS
- (vc-do-command 0 "rcs" file (concat "-n" name ":")) ;; RCS
+ (vc-add-triple name file (vc-latest-version file)) ;; SCCS
+ (vc-do-command nil 0 "rcs" file 'MASTER (concat "-n" name ":")) ;; RCS
+ (vc-do-command nil 0 "cvs" file 'WORKFILE "tag" name) ;; CVS
)
)
(defun vc-backend-diff (file &optional oldvers newvers cmp)
;; Get a difference report between two versions of FILE.
;; Get only a brief comparison report if CMP, a difference report otherwise.
- (if (eq (vc-backend-deduce file) 'SCCS)
+ (let ((backend (vc-backend file)))
+ (cond
+ ((eq backend 'SCCS)
(setq oldvers (vc-lookup-triple file oldvers))
(setq newvers (vc-lookup-triple file newvers)))
- (let* ((command (or (vc-backend-dispatch file "vcdiff" "rcsdiff")
- (vc-registration-error file)))
- (options (append (list (and cmp "--brief")
- "-q"
- (and oldvers (concat "-r" oldvers))
- (and newvers (concat "-r" newvers)))
- (and (not cmp)
- (if (listp diff-switches)
- diff-switches
- (list diff-switches)))))
- (status (apply 'vc-do-command 2 command file options)))
- ;; Some RCS versions don't understand "--brief"; work around this.
- (if (eq status 2)
- (apply 'vc-do-command 1 command file (if cmp (cdr options) options))
- status)))
+ ((eq backend 'RCS)
+ (if (not oldvers) (setq oldvers (vc-workfile-version file)))))
+ ;; SCCS and RCS shares a lot of code.
+ (cond
+ ((or (eq backend 'SCCS) (eq backend 'RCS))
+ (let* ((command (if (eq backend 'SCCS)
+ "vcdiff"
+ "rcsdiff"))
+ (mode (if (eq backend 'RCS) 'WORKFILE 'MASTER))
+ (options (append (list (and cmp "--brief")
+ "-q"
+ (and oldvers (concat "-r" oldvers))
+ (and newvers (concat "-r" newvers)))
+ (and (not cmp)
+ (if (listp diff-switches)
+ diff-switches
+ (list diff-switches)))))
+ (status (apply 'vc-do-command "*vc-diff*" 2
+ command file mode options)))
+ ;; Some RCS versions don't understand "--brief"; work around this.
+ (if (eq status 2)
+ (apply 'vc-do-command "*vc-diff*" 1 command file 'WORKFILE
+ (if cmp (cdr options) options))
+ status)))
+ ;; CVS is different.
+ ((eq backend 'CVS)
+ (if (string= (vc-workfile-version file) "0") ;CVS
+ ;; This file is added but not yet committed; there is no master file.
+ (if (or oldvers newvers)
+ (error "No revisions of %s exist" file)
+ (if cmp 1 ;; file is added but not committed,
+ ;; we regard this as "changed".
+ ;; diff it against /dev/null.
+ (apply 'vc-do-command
+ "*vc-diff*" 1 "diff" file 'WORKFILE
+ (append (if (listp diff-switches)
+ diff-switches
+ (list diff-switches)) '("/dev/null")))))
+ ;; cmp is not yet implemented -- we always do a full diff.
+ (apply 'vc-do-command
+ "*vc-diff*" 1 "cvs" file 'WORKFILE "diff"
+ (and oldvers (concat "-r" oldvers))
+ (and newvers (concat "-r" newvers))
+ (if (listp diff-switches)
+ diff-switches
+ (list diff-switches)))))
+ (t
+ (vc-registration-error file)))))
+
+(defun vc-backend-merge-news (file)
+ ;; Merge in any new changes made to FILE.
+ (message "Merging changes into %s..." file)
+ (prog1
+ (vc-backend-dispatch
+ file
+ (error "vc-backend-merge-news not meaningful for SCCS files") ;SCCS
+ (error "vc-backend-merge-news not meaningful for RCS files") ;RCS
+ (save-excursion ; CVS
+ (vc-file-clear-masterprops file)
+ (vc-file-setprop file 'vc-workfile-version nil)
+ (vc-file-setprop file 'vc-locking-user nil)
+ (vc-do-command nil 0 "cvs" file 'WORKFILE "update")
+ ;; CVS doesn't return an error code if conflicts are detected.
+ ;; Since we want to warn the user about it (and possibly start
+ ;; emerge later), scan the output and see if this occurred.
+ (set-buffer (get-buffer "*vc*"))
+ (goto-char (point-min))
+ (if (re-search-forward "^cvs update: conflicts found in .*" nil t)
+ 1 ;; error code for caller
+ 0 ;; no conflict detected
+ )))
+ (message "Merging changes into %s...done" file)))
(defun vc-check-headers ()
"Check if the current file has any headers in it."
(vc-backend-dispatch buffer-file-name
(re-search-forward "%[MIRLBSDHTEGUYFPQCZWA]%" nil t) ;; SCCS
(re-search-forward "\\$[A-Za-z\300-\326\330-\366\370-\377]+\\(: [\t -#%-\176\240-\377]*\\)?\\$" nil t) ;; RCS
+ 'RCS ;; CVS works like RCS in this regard.
)
))
vc-header-alist Which keywords to insert when adding headers
with \\[vc-insert-headers]. Defaults to
- '(\"\%\W\%\") under SCCS, '(\"\$Id\$\") under RCS.
+ '(\"\%\W\%\") under SCCS, '(\"\$Id\$\") under
+ RCS and CVS.
vc-static-header-alist By default, version headers inserted in C files
get stuffed in a static string area so that
- ident(RCS) or what(SCCS) can see them in the
- compiled object code. You can override this
- by setting this variable to nil, or change
+ ident(RCS/CVS) or what(SCCS) can see them in
+ the compiled object code. You can override
+ this by setting this variable to nil, or change
the header template by changing it.
vc-command-messages if non-nil, display run messages from the
;;; These things should probably be generally available
-(defun vc-file-tree-walk (func &rest args)
- "Walk recursively through default directory.
+(defun vc-file-tree-walk (dirname func &rest args)
+ "Walk recursively through DIRNAME.
Invoke FUNC f ARGS on each non-directory file f underneath it."
- (vc-file-tree-walk-internal default-directory func args)
- (message "Traversing directory %s...done" default-directory))
+ (vc-file-tree-walk-internal (expand-file-name dirname) func args)
+ (message "Traversing directory %s...done" dirname))
(defun vc-file-tree-walk-internal (file func args)
(if (not (file-directory-p file))
(apply func file args)
- (message "Traversing directory %s..." file)
+ (message "Traversing directory %s..." (abbreviate-file-name file))
(let ((dir (file-name-as-directory file)))
(mapcar
(function
(lambda (f) (or
(string-equal f ".")
(string-equal f "..")
+ (member f vc-directory-exclusion-list)
(let ((dirf (concat dir f)))
(or
(file-symlink-p dirf) ;; Avoid possible loops
;;; DEVELOPER'S NOTES ON CONCURRENCY PROBLEMS IN THIS CODE
;;;
;;; These may be useful to anyone who has to debug or extend the package.
+;;; (Note that this information corresponds to versions 5.x. Some of it
+;;; might have been invalidated by the additions to support branching
+;;; and RCS keyword lookup. AS, 1995/03/24)
;;;
;;; A fundamental problem in VC is that there are time windows between
;;; vc-next-action's computations of the file's version-control state and
;;; B 5 . 6 7 8 co -l get -e checkout
;;; C 9 10 . 11 12 co -u unget; get revert
;;; D 13 14 15 . 16 ci -u -m<comment> delta -y<comment>; get checkin
-;;; E 17 18 19 20 . rcs -u -M ; rcs -l unget -n ; get -g steal lock
+;;; E 17 18 19 20 . rcs -u -M -l unget -n ; get -g steal lock
;;;
;;; All commands take the master file name as a last argument (not shown).
;;;
;;; Potential cause: someone else's admin during window P, with
;;; caller's admin happening before their checkout.
;;;
-;;; RCS: ci will fail with a "no lock set by <user>" message.
+;;; RCS: Prior to version 5.6.4, ci fails with message
+;;; "no lock set by <user>". From 5.6.4 onwards, VC uses the new
+;;; ci -i option and the message is "<file>,v: already exists".
;;; SCCS: admin will fail with error (ad19).
;;;
;;; We can let these errors be passed up to the user.
;;;
;;; Potential cause: self-race during window P.
;;;
-;;; RCS: will revert the file to the last saved version and unlock it.
+;;; RCS: Prior to version 5.6.4, reverts the file to the last saved
+;;; version and unlocks it. From 5.6.4 onwards, VC uses the new
+;;; ci -i option, failing with message "<file>,v: already exists".
;;; SCCS: will fail with error (ad19).
;;;
;;; Either of these consequences is acceptable.
;;;
;;; Potential cause: self-race during window P.
;;;
-;;; RCS: will register the caller's workfile as a delta with a
-;;; null change comment (the -t- switch will be ignored).
+;;; RCS: Prior to version 5.6.4, VC registers the caller's workfile as
+;;; a delta with a null change comment (the -t- switch will be
+;;; ignored). From 5.6.4 onwards, VC uses the new ci -i option,
+;;; failing with message "<file>,v: already exists".
;;; SCCS: will fail with error (ad19).
;;;
;;; 4. File looked unregistered but is locked by someone else.
;;; Potential cause: someone else's admin during window P, with
;;; caller's admin happening *after* their checkout.
;;;
-;;; RCS: will fail with a "no lock set by <user>" message.
+;;; RCS: Prior to version 5.6.4, ci fails with a
+;;; "no lock set by <user>" message. From 5.6.4 onwards,
+;;; VC uses the new ci -i option, failing with message
+;;; "<file>,v: already exists".
;;; SCCS: will fail with error (ad19).
;;;
;;; We can let these errors be passed up to the user.
;;;
;;; Potential cause: master file got nuked during window P.
;;;
-;;; RCS: Checks in the user's version as an initial delta.
+;;; RCS: Prior to version 5.6.4, checks in the user's version as an
+;;; initial delta. From 5.6.4 onwards, VC uses the new ci -j
+;;; option, failing with message "no such file or directory".
;;; SCCS: will fail with error ut4.
;;;
-;;; This case is kind of nasty. It means VC may fail to detect the
-;;; loss of previous version information.
+;;; This case is kind of nasty. Under RCS prior to version 5.6.4,
+;;; VC may fail to detect the loss of previous version information.
;;;
;;; 14. File looks like it's locked by the calling user and changed, but it's
;;; actually unlocked.
;;;
;;; In order of decreasing severity:
;;;
-;;; Cases 11 and 15 under RCS are the only one that potentially lose work.
+;;; Cases 11 and 15 are the only ones that potentially lose work.
;;; They would require a self-race for this to happen.
;;;
;;; Case 13 in RCS loses information about previous deltas, retaining
HCoop / bpt / emacs.git / blobdiff