xemacs-beta: lisp/packages/vc.el comparison

comparison lisp/packages/vc.el @ 151:59463afc5666 r20-3b2

Import from CVS: tag r20-3b2

author	cvs
date	Mon, 13 Aug 2007 09:37:19 +0200
parents	318232e2a3f0
children	25f70ba0133c

comparison

equal deleted inserted replaced

-:8ebb1c0f0f6f
+:59463afc5666
 ;;; vc.el --- drive a version-control system from within Emacs
-;; Copyright (C) 1992, 1993, 1994 Free Software Foundation, Inc.
+;; Copyright (C) 1992, 93, 94, 95, 96 Free Software Foundation, Inc.
-;; Copyright (C) 1995 Tinker Systems and INS Engineering Corp.
+;; Author:     Eric S. Raymond <esr@snark.thyrsus.com>
-;; Author: Eric S. Raymond <esr@snark.thyrsus.com>
+;; Maintainer: Andre Spiegel <spiegel@inf.fu-berlin.de>
-;; Maintainer: ttn@netcom.com
+;; XEmacs conversion: Steve Baur <steve@altair.xemacs.org>
-;; Version: 5.6
+;; This file is part of GNU Emacs.
-;; This file is part of XEmacs.
+;; GNU Emacs is free software; you can redistribute it and/or modify
-;; XEmacs is free software; you can redistribute it and/or modify it
+;; it under the terms of the GNU General Public License as published by
-;; under the terms of the GNU General Public License as published by
 ;; the Free Software Foundation; either version 2, or (at your option)
 ;; any later version.
-;; XEmacs is distributed in the hope that it will be useful, but
+;; GNU Emacs is distributed in the hope that it will be useful,
-;; WITHOUT ANY WARRANTY; without even the implied warranty of
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
-;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-;; General Public License for more details.
+;; GNU General Public License for more details.
 ;; You should have received a copy of the GNU General Public License
-;; along with XEmacs; see the file COPYING.  If not, write to the
+;; along with GNU Emacs; see the file COPYING.  If not, write to the
 ;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 ;; Boston, MA 02111-1307, USA.
-;;; Synched up with: It's not clear at this point.
-;;; mly synched this with FSF at version 5.4.  Stig did a whole lot
-;;; of stuff to it since then, and so has the FSF.
 ;;; Commentary:
 ;; This mode is fully documented in the Emacs user's manual.
 ;;
 ;; 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.
+;; in Jan-Feb 1994.  Further enhancements came from ttn.netcom.com and
-;;
+;; Andre Spiegel <spiegel@inf.fu-berlin.de>.
-;; XEmacs fixes, CVS fixes, and general improvements
-;; by Jonathan Stigelman <Stig@hackvan.com>
 ;;
 ;; Supported version-control systems presently include SCCS, RCS, and CVS.
-;; 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.
+;; 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.
 ;;
-;; The RCS code assumes strict locking.  You can support the RCS -x option
+;; You can support the RCS -x option by adding pairs to the
-;; by adding pairs to the vc-master-templates list.
+;; 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.
 ;;
 ;; If your site uses the ChangeLog convention supported by Emacs, the
 ;;; Code:
 (require 'vc-hooks)
 (require 'ring)
-(eval-when-compile (require 'dired))    ; for dired-map-over-marks macro
+(eval-when-compile (require 'dired))	; for dired-map-over-marks macro
 (if (not (assoc 'vc-parent-buffer minor-mode-alist))
 (setq minor-mode-alist
 	  (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.
-If the back-end is CVS, workfiles are always kept, regardless of the
-value of this flag.")
 (defvar vc-initial-comment nil
-"*Prompt for initial comment when a file is registered.")
+"*If non-nil, prompt for initial comment when a file is registered.")
 (defvar vc-command-messages nil
-"*Display run messages from back-end commands.")
+"*If non-nil, display run messages from back-end commands.")
-(defvar vc-mistrust-permissions 'file-symlink-p
+(defvar vc-register-switches nil
-"*Don't assume that permissions and ownership track version-control status.")
+"*A string or list of strings specifying extra switches passed
+to the register program by \\[vc-register].")
 (defvar vc-checkin-switches nil
-"*Extra switches passed to the checkin program by \\[vc-checkin].")
+"*A string or list of strings specifying extra switches passed
+to the checkin program by \\[vc-checkin].")
 (defvar vc-checkout-switches nil
-"*Extra switches passed to the checkout program by \\[vc-checkout].")
+"*A string or list of strings specifying extra switches passed
-(defvar vc-path
+to the checkout program by \\[vc-checkout].")
-(if (file-exists-p "/usr/sccs")
+(defvar vc-directory-exclusion-list '("SCCS" "RCS" "CVS")
-'("/usr/sccs") nil)
+"*A list of directory names ignored by functions that recursively
-"*List of extra directories to search for version control commands.")
+walk file trees.")
-(defvar vc-directory-exclusion-list '("SCCS" "RCS")
-"*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.")
-;;; XEmacs - This is dumped into loaddefs.el already.
+;;; This is duplicated in diff.el.
-;(defvar diff-switches "-c"
+;;; XEmacs: remove
-;  "*A string or list of strings specifying switches to be passed to diff.")
+;;(defvar diff-switches "-c"
+;;  "*A string or list of strings specifying switches to be be passed to diff.")
+;;;###autoload
+(defvar vc-before-checkin-hook nil
+"*Normal hook (list of functions) run before a file gets checked in.
+See `run-hooks'.")
 ;;;###autoload
 (defvar vc-checkin-hook nil
-"*List of functions called after a checkin is done.  See `run-hooks'.")
+"*Normal hook (List of functions) run after a checkin is done.
+See `run-hooks'.")
-;;;###autoload
-(defvar vc-before-checkin-hook nil
-"*List of functions called before 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\$") (CVS "\$Id\$"))
-"*Header keywords to be inserted when `vc-insert-headers' is executed.")
+"*Header keywords to be inserted by `vc-insert-headers'.
+Must be a list of two-element lists, the first element of each must
+be `RCS', `CVS', or `SCCS'.  The second element is the string to
+be inserted for this particular backend.")
 (defvar vc-static-header-alist
 '(("\\.c$" .
 "\n#ifndef lint\nstatic char vcid[] = \"\%s\";\n#endif /* lint */\n"))
 "*Associate static header string templates with file types.  A \%s in the
 template is replaced with the first string associated with the file's
 Add an entry in this list if you need to override the normal comment-start
 and comment-end variables.  This will only be necessary if the mode language
 is sensitive to blank lines.")
 ;; Default is to be extra careful for super-user.
-(defvar vc-checkout-carefully (= (user-uid) 0) ; #### - this prevents preloading!
+(defvar vc-checkout-carefully (= (user-uid) 0)
 "*Non-nil means be extra-careful in checkout.
 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 CVS 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)
 (defconst vc-name-assoc-file "VC-names")
 (defvar vc-dired-mode nil)
 (make-variable-buffer-local 'vc-dired-mode)
-(defvar vc-comment-ring nil)
+(defvar vc-comment-ring (make-ring vc-maximum-comment-ring-size))
 (defvar vc-comment-ring-index nil)
 (defvar vc-last-comment-match nil)
+;; 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 nil "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)))
 ;; File property caching
-(defun vc-file-clearprops (file)
-;; clear all properties of a given file
-(setplist (intern file vc-file-prop-obarray) nil))
 (defun vc-clear-context ()
 "Clear all cached file properties and the comment ring."
 (interactive)
 (fillarray vc-file-prop-obarray nil)
 ;; Note: there is potential for minor lossage here if there is an open
 ;; log buffer with a nonzero local value of vc-comment-ring-index.
-(setq vc-comment-ring nil))
+(setq vc-comment-ring (make-ring vc-maximum-comment-ring-size)))
+(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)
 (error "Buffer %s is not associated with a file" (buffer-name))))
 (defvar vc-binary-assoc nil)
+;; XEmacs:  Function referred to in vc-hooks.el
+;;;###autoload
 (defun vc-find-binary (name)
 "Look for a command anywhere on the subprocess-command search path."
 (or (cdr (assoc name vc-binary-assoc))
-;; XEmacs - use locate-file
+(catch 'found
-(let ((full (locate-file name exec-path nil 1)))
+	(mapcar
-	(if full
+	 (function
-	    (setq vc-binary-assoc (cons (cons name full) vc-binary-assoc)))
+	  (lambda (s)
-	full)))
+	    (if s
+		(let ((full (concat s "/" name)))
-(defun vc-do-command (okstatus command file last &rest flags)
+		  (if (file-executable-p full)
+		      (progn
+			(setq vc-binary-assoc
+			      (cons (cons name full) vc-binary-assoc))
+			(throw 'found full)))))))
+	 exec-path)
+	nil)))
+(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
+(If OKSTATUS is nil, that means to ignore errors.)
-the master name of FILE if LAST is 'MASTER, or the workfile of FILE if LAST is
+The last argument of the command is the master name of FILE if LAST is
-'WORKFILE; this is appended to an optional list of FLAGS."
+`MASTER', or the workfile of FILE if LAST is `WORKFILE'; this is appended
-(setq file (expand-file-name file))
+to an optional list of FLAGS."
-(let ((camefrom (current-buffer))
+(and file (setq file (expand-file-name file)))
-	(pwd (file-name-directory (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)
-;;; #### - don't know why this code was here...to beautify the echo message?
+(set-buffer (get-buffer-create buffer))
-;;;	   the version of code below doesn't break default-directory, but it
-;;;	   still might mess up CVS and RCS because they like to operate on
-;;;	   files in the current directory. --Stig
-;;;
-;;;     (if (string-match (concat "^" (regexp-quote pwd)) file)
-;;;         (setq file (substring file (match-end 0)))
-;;;       (setq pwd (file-name-directory file)))
-(if vc-command-messages
-	(message "Running %s on %s..." command file))
-(set-buffer (get-buffer-create "*vc*"))
-(setq default-directory pwd
-	  file (file-name-nondirectory file))
 (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)
 (mapcar
 (function (lambda (s) (and s (setq squeezed (append squeezed (list s))))))
 flags)
 (if (and vc-file (eq last 'MASTER))
 	(setq squeezed (append squeezed (list vc-file))))
 (if (eq last 'WORKFILE)
-	(setq squeezed (append squeezed (list file))))
+	(progn
-(let ((exec-path (if vc-path (append vc-path exec-path) exec-path))
+	  (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 (copy-sequence process-environment)))
+	  (process-environment
-(setenv "PATH" (mapconcat 'identity exec-path ":"))
+	   (cons (concat "PATH=" (getenv "PATH")
+			 path-separator
+			 (mapconcat 'identity vc-path path-separator))
+		 process-environment))
+	  (w32-quote-process-args t))
 (setq status (apply 'call-process command nil t nil squeezed)))
 (goto-char (point-max))
-(set-buffer-modified-p nil)		; XEmacs - fsf uses `not-modified'
+(set-buffer-modified-p nil)
 (forward-line -1)
-(if (or (not (integerp status)) (< okstatus status))
+(if (or (not (integerp status)) (and okstatus (< 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
 		 (if (integerp status)
 		     (format "status %d" status)
 		   status))
 	  )
 (if vc-command-messages
 	  (message "Running %s...OK" command))
 )
-(set-buffer camefrom)
+(set-buffer obuf)
 status)
 )
 ;;; 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)
 	(buffer-substring posn
 			  (min (point-max) (+ posn 100)))))
 			 ;; beginning of buffer like backward-char would
 			 (search-forward context-string nil t)))
 	      ;; to beginning of OSTRING
 	      (- (point) (length context-string))))))))
-(defun vc-revert-buffer1 (&optional arg no-confirm)
+(defun vc-buffer-context ()
-;; Most of this was shamelessly lifted from Sebastian Kremer's rcs.el mode.
+;; Return a list '(point-context mark-context reparse); from which
-;; Revert buffer, try to keep point and mark where user expects them in spite
+;; vc-restore-buffer-context can later restore the context.
-;; 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 ((point-context (vc-position-context (point)))
 	;; Use mark-marker to avoid confusion in transient-mark-mode.
-	;; XEmacs - mark-marker t
+	(mark-context  (if (eq (marker-buffer (mark-marker #+xemacs t))
-	(mark-context  (if (eq (marker-buffer (mark-marker t)) (current-buffer))
+			       (current-buffer))
-			   (vc-position-context (mark-marker t))))
+			   (vc-position-context (mark-marker #+xemacs t))))
+	;; Make the right thing happen in transient-mark-mode.
+	(mark-active nil)
 	;; We may want to reparse the compilation buffer after revert
 	(reparse (and (boundp 'compilation-error-list) ;compile loaded
-		      ;; Construct a list; each elt is nil or a buffer
+		      (let ((curbuf (current-buffer)))
-		      ;; iff that buffer is a compilation output buffer
+			;; Construct a list; each elt is nil or a buffer
-		      ;; that contains markers into the current buffer.
+			;; iff that buffer is a compilation output buffer
-		      (save-excursion
+			;; that contains markers into the current buffer.
-			(mapcar (function
+			(save-excursion
-				 (lambda (buffer)
+			  (mapcar (function
-				   (set-buffer buffer)
+				   (lambda (buffer)
-				   (let ((errors (or
+				    (set-buffer buffer)
-						  compilation-old-error-list
+				    (let ((errors (or
-						  compilation-error-list))
+						   compilation-old-error-list
-					 (buffer-error-marked-p nil))
+						   compilation-error-list))
-				     (while (and (consp errors)
+					  (buffer-error-marked-p nil))
-						 (not buffer-error-marked-p))
+				      (while (and (consp errors)
-				       (and (markerp (cdr (car errors)))
+						  (not buffer-error-marked-p))
-					    (eq buffer
+					(and (markerp (cdr (car errors)))
-						(marker-buffer
+					     (eq buffer
-						 (cdr (car errors))))
+						 (marker-buffer
-					    (setq buffer-error-marked-p t))
+						  (cdr (car errors))))
-				       (setq errors (cdr errors)))
+					     (setq buffer-error-marked-p t))
-				     (if buffer-error-marked-p buffer))))
+					(setq errors (cdr errors)))
-				(buffer-list))))))
+				      (if buffer-error-marked-p buffer))))
+				  (buffer-list)))))))
-;; The FSF version intentionally runs font-lock here.  That
+(list point-context mark-context reparse)))
-;; usually just leads to a correctly font-locked buffer being
-;; redone.  #### We should detect the cases where the font-locking
+(defun vc-restore-buffer-context (context)
-;; may be incorrect (such as on reverts).  We know that it is fine
+;; Restore point/mark, and reparse any affected compilation buffers.
-;; during regular checkin and checkouts.
+;; CONTEXT is that which vc-buffer-context returns.
+(let ((point-context (nth 0 context))
-;; the actual revisit
+	(mark-context (nth 1 context))
-(revert-buffer arg no-confirm)
+	(reparse (nth 2 context)))
 ;; Reparse affected compilation buffers.
 (while reparse
 (if (car reparse)
 	  (save-excursion
 	    (set-buffer (car reparse))
 (if new-point (goto-char new-point)))
 (if mark-context
 	(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)))
+;; t means don't call normal-mode; that's to preserve various minor modes.
+(revert-buffer arg no-confirm t)
+(vc-restore-buffer-context context)))
 (defun vc-buffer-sync (&optional not-urgent)
 ;; Make sure the current buffer and its working file are in sync
 ;; NOT-URGENT means it is ok to continue if the user says not to save.
 (if (buffer-modified-p)
 	  (save-buffer)
 	(if not-urgent
 	    nil
 	  (error "Aborted")))))
-;;;###autoload
-(defun vc-file-status ()
-"Display the current status of the file being visited.
-Currently, this is only defined for CVS.  The information provided in the
-modeline is generally sufficient for RCS and SCCS."
-;; by Stig@hackvan.com
-(interactive)
-(vc-buffer-sync t)
-(let ((type (vc-backend-deduce buffer-file-name))
-	(file buffer-file-name))
-(cond ((null type)
-	   (if buffer-file-name
-	       (message "`%s' is not registered with a version control system."
-			buffer-file-name)
-	     (ding)
-	     (message "Buffer `%s' has no associated file."
-		      (buffer-name (current-buffer)))))
-	  ((eq 'CVS type)
-	   (vc-do-command 0 "cvs" file 'WORKFILE "status" "-v")
-	   (set-buffer "*vc*")
-	   (set-buffer-modified-p nil)
-	   ;; reparse the status information, since we have it handy...
-	   (vc-parse-buffer '("Status: \\(.*\\)") file '(vc-cvs-status))
-	   (goto-char (point-min))
-	   (shrink-window-if-larger-than-buffer
-	    (display-buffer (current-buffer))))
-	  ((eq 'CC type)
-	   (vc-do-command 0 "cleartool" file 'WORKFILE "describe")
-	   (set-buffer "*vc*")
-	   (set-buffer-modified-p nil)
-	   (goto-char (point-min))
-	   (shrink-window-if-larger-than-buffer
-	    (display-buffer (current-buffer))))
-	  (t
-	   (ding)
-	   (message "Operation not yet defined for RCS or SCCS.")))
-))
 (defun vc-workfile-unchanged-p (file &optional want-differences-if-changed)
 ;; Has the given workfile changed since last checkout?
-(cond ((and (eq 'CVS (vc-backend-deduce file))
+(let ((checkout-time (vc-file-getprop file 'vc-checkout-time))
-	      (not want-differences-if-changed))
+	(lastmod (nth 5 (file-attributes file))))
+(or (equal checkout-time lastmod)
-	 (let ((status (vc-file-getprop file 'vc-cvs-status)))
+	(and (or (not checkout-time) want-differences-if-changed)
-	   ;; #### - should this have some kind of timeout?  how often does
+	     (let ((unchanged (zerop (vc-backend-diff file nil nil
-	   ;; this get called?  possibly the cached information should be
+					  (not want-differences-if-changed)))))
-	   ;; flushed out of hand.  The only concern is the VC menu, which
+	       ;; 0 stands for an unknown time; it can't match any mod time.
-	   ;; may indirectly call this function.
+	       (vc-file-setprop file 'vc-checkout-time (if unchanged lastmod 0))
-	   (or status			; #### - caching is error-prone
+	       unchanged)))))
-	       (setq status (car (vc-log-info "cvs" file 'WORKFILE '("status")
-					      '("Status: \\(.*\\)")
-					      '(vc-cvs-status)))))
-	   (string= status "Up-to-date")))
-	(t
-	 (let ((checkout-time (vc-file-getprop file 'vc-checkout-time))
-	       (lastmod (nth 5 (file-attributes file)))
-	       unchanged)
-	   (or (equal checkout-time lastmod)
-	       (and (or (not checkout-time) want-differences-if-changed)
-		    (setq unchanged
-			  (zerop (vc-backend-diff file nil nil
-						  (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 ((vc-file (vc-name file))
-	(vc-type (vc-backend-deduce file))
+	(vc-type (vc-backend file))
-	owner version)
+	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
-;; if there is no lock on the file, assert one and get it
+	  (setq vc-log-after-operation-hook
-((and (not (eq vc-type 'CVS))	;There are no locks in CVS.
+		'vc-checkout-writable-buffer-hook)
-	   (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*")
-		(goto-char (point-min))
-		(insert (format "Changes to %s since last lock:\n\n" file))
-		(not (beep))
-		(yes-or-no-p
-		 "File has unlocked changes, claim lock retaining changes? "))
-	      (progn (vc-backend-steal file)
-		     (vc-mode-line file))
-	    (if (not (yes-or-no-p "Revert to checked-in version, instead? "))
-		(error "Checkout aborted.")
-	      (vc-revert-buffer1 t t)
-	      (vc-checkout-writable-buffer file))
-	    )
 	(vc-checkout-writable-buffer file)))
-;; a checked-out version exists, but the user may not own the lock
+;; CVS: changes to the master file need to be
-((and (not (eq vc-type 'CVS))	;There are no locks in CVS.
+;; merged back into the working file
-	   (not (string-equal owner (user-login-name))))
-(if comment
-	  (error "Sorry, you can't steal the lock on %s this way" file))
-(vc-steal-lock
-file
-(and verbose (read-string "Version to steal: "))
-owner))
-;; changes to the master file needs to be merged back into the
-;; working file
 ((and (eq vc-type 'CVS)
-	   ;; "0" means "added, but not yet committed"
+	   (or (eq (vc-cvs-status file) 'needs-checkout)
-	   (not (string= (vc-file-getprop file 'vc-your-latest-version) "0"))
+	       (eq (vc-cvs-status file) 'needs-merge)))
-	   (progn
+(if (or vc-dired-mode
-	     (vc-fetch-properties file)
+	      (yes-or-no-p
-	     (not (string= (vc-file-getprop file 'vc-your-latest-version)
+	       (format "%s is not up-to-date.  Merge in changes now? "
-			   (vc-file-getprop file 'vc-latest-version)))))
+		       (buffer-name))))
-(vc-buffer-sync)
-(if (yes-or-no-p (format "%s is not up-to-date.  Merge in changes now? "
-			       (buffer-name)))
 	  (progn
-	    (if (and (buffer-modified-p)
+	    (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-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!"))
-	    (vc-resynch-window file t (not (buffer-modified-p))))
+	    (and buffer
+		 (vc-resynch-buffer file t (not (buffer-modified-p buffer)))))
 	(error "%s needs update" (buffer-name))))
-((and buffer-read-only (eq vc-type 'CVS))
+;; If there is no lock on the file, assert one and get it.
-(toggle-read-only)
+;; (With implicit checkout, make sure not to lose unsaved changes.)
-;; Sites who make link farms to a read-only gold tree (or
+((progn (and (eq (vc-checkout-model file) 'implicit)
-;; something similar) can use the hook below to break the
+(buffer-modified-p buffer)
-;; sym-link.
+(vc-buffer-sync))
-(run-hooks 'vc-make-buffer-writable-hook))
+(not (setq owner (vc-locking-user file))))
+(if (and vc-checkout-carefully
-;; OK, user owns the lock on the file (or we are running CVS)
+	       (not (vc-workfile-unchanged-p file t)))
+	  (if (save-window-excursion
+		(pop-to-buffer "*vc-diff*")
+		(goto-char (point-min))
+		(insert-string (format "Changes to %s since last lock:\n\n"
+				       file))
+		(not (beep))
+		(yes-or-no-p
+		      (concat "File has unlocked changes, "
+		       "claim lock retaining changes? ")))
+	      (progn (vc-backend-steal file)
+		     (vc-mode-line file))
+	    (if (not (yes-or-no-p "Revert to checked-in version, instead? "))
+		(error "Checkout aborted")
+	      (vc-revert-buffer1 t t)
+	      (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
+		     (if (vc-trunk-p (vc-workfile-version file))
+""  ;; this means check out latest on trunk
+(vc-branch-part (vc-workfile-version file)))))))
+	  )))
+;; a checked-out version exists, but the user may not own the lock
+((and (not (eq vc-type 'CVS))
+	   (not (string-equal owner (vc-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
+(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)
-;; give luser a chance to save before checking in.
+	    (find-file file))
-(vc-buffer-sync)
+	  ;; give luser a chance to save before checking in.
-;; Revert if file is unchanged and buffer is too.
+	  (vc-buffer-sync)
-;; If buffer is modified, that means the user just said no
-;; to saving it; in that case, don't revert,
+	  ;; Revert if file is unchanged and buffer is too.
-;; because the user might intend to save
+	  ;; If buffer is modified, that means the user just said no
-;; after finishing the log entry.
+	  ;; to saving it; in that case, don't revert,
-(if (and (vc-workfile-unchanged-p file)
+	  ;; because the user might intend to save
-	       (not (buffer-modified-p)))
+	  ;; after finishing the log entry.
-	  (progn
+	  (if (and (vc-workfile-unchanged-p file)
-	    (if (eq vc-type 'CVS)
+		   (not (buffer-modified-p)))
-		(message "No changes to %s" file)
+	       ;; DO NOT revert the file without asking the user!
+	      (cond
-	      (vc-backend-revert file)
+	       ((yes-or-no-p "Revert to master version? ")
-	      ;; DO NOT revert the file without asking the user!
+		(vc-backend-revert file)
-	      (vc-resynch-window file t nil)))
+		(vc-resynch-window file t t)))
-	;; user may want to set nonstandard parameters
+	    ;; user may want to set nonstandard parameters
-	(if verbose
+	    (if verbose
-	    (setq version (read-string "New version level: ")))
+		(setq version (read-string "New version level: ")))
-	;; OK, let's do the checkin
+	    ;; OK, let's do the checkin
-	(vc-checkin file version comment)
+	    (vc-checkin file version comment)
-	)))))
+	    )))))
 (defun vc-next-action-dired (file rev comment)
-;; We've accepted a log comment, now do a vc-next-action using it on all
+;; Do a vc-next-action-on-file on all the marked files, possibly
-;; marked files.
+;; passing on the log comment we've just entered.
-(set-buffer vc-parent-buffer)
+(let ((configuration (current-window-configuration))
-(dired-map-over-marks
+	(dired-buffer (current-buffer))
-(save-window-excursion
+	(dired-dir default-directory))
-(let ((file (dired-get-filename)))
+(dired-map-over-marks
+(let ((file (dired-get-filename)) p
+	   (default-directory default-directory))
 (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)))
+(set-buffer dired-buffer)
-nil t)
+(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
 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 the file has not been changed, neither in your working area or
-in the repository, a message is printed and nothing is done.
 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.
+merge in the changes into your working copy."
-The following is true regardless of which version control system you
-are using:
-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."
 (interactive "P")
 (catch 'nogo
 (if vc-dired-mode
 	(let ((files (dired-get-marked-files)))
-	  (if (= (length files) 1)
+	  (if (string= ""
-	      (find-file-other-window (car files))
+		 (mapconcat
-	    (vc-start-entry nil nil nil
+	             (function (lambda (f)
-			    "Enter a change comment for the marked files."
+			 (if (eq (vc-backend f) 'CVS)
-			    'vc-next-action-dired)
+			     (if (or (eq (vc-cvs-status f) 'locally-modified)
-	    (throw 'nogo nil))))
+				     (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
 	(vc-next-action-on-file buffer-file-name verbose)
 (vc-registration-error nil))))
 ;;; 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")
+(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? "))
 (if (and (not (buffer-modified-p))
 	   (zerop (buffer-size))
 	   (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
 	(read-string
 	 (format "Initial version level for %s: " buffer-file-name))))
 )
 (defun vc-resynch-window (file &optional keep noquery)
 ;; If the given file is in the current buffer,
-;; either revert on it so we see expanded keyworks,
+;; either revert on it so we see expanded keywords,
 ;; or unvisit it (depending on vc-keep-workfiles)
 ;; NOQUERY if non-nil inhibits confirmation for reverting.
 ;; NOQUERY should be t *only* if it is known the only difference
 ;; between the buffer and the file is due to RCS rather than user editing!
 (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
+	 (kill-buffer (current-buffer)))))
-	   (delete-window)
-	   (kill-buffer (current-buffer))))))
+(defun vc-resynch-buffer (file &optional keep noquery)
+;; if FILE is currently visited, resynch its buffer
-(defun vc-start-entry (file rev comment msg action &optional after-hook before-hook)
+(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 vc-parent-buffer (current one if no file).
 ;; AFTER-HOOK specifies the local value for vc-log-operation-hook.
-;; BEFORE-HOOK specifies a hook to run before even asking for the
-;; checkin comments.
 (let ((parent (if file (find-file-noselect file) (current-buffer))))
-(when before-hook
+(if vc-before-checkin-hook
-(save-excursion
+(if file
-	(set-buffer parent)
+(save-excursion
-	(run-hooks before-hook)))
+(set-buffer parent)
+(run-hooks 'vc-before-checkin-hook))
+(run-hooks 'vc-before-checkin-hook)))
 (if comment
 	(set-buffer (get-buffer-create "*VC-log*"))
 (pop-to-buffer (get-buffer-create "*VC-log*")))
 (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)
+(vc-log-mode file)
 (make-local-variable 'vc-log-after-operation-hook)
 (if after-hook
 	(setq vc-log-after-operation-hook after-hook))
 (setq vc-log-operation action)
-(setq vc-log-file file)
 (setq vc-log-version rev)
 (if comment
 	(progn
 	  (erase-buffer)
 	  (if (eq comment t)
 FILE is the unmodified name of the file.  REV should be the base version
 level to check it in under.  COMMENT, if specified, is the checkin comment."
 (vc-start-entry file rev
 		  (or comment (not vc-initial-comment))
 		  "Enter initial comment." 'vc-backend-admin
-		  nil 'vc-before-checkin-hook))
+		  nil))
-(defun vc-checkout (file &optional writable)
+;; XEmacs: Function referred to in vc-hooks.el.
+;;;###autoload
+(defun vc-checkout (file &optional writable rev)
 "Retrieve a copy of the latest version of the given file."
-;; XEmacs - ftp is suppressed by the check for a filename handler in
-;;	      vc-registered, so this is needless surplussage
 ;; 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"))
+(if (and (string-match "^/[^/:]+:" file) (vc-find-binary "ftp"))
-;;       (error "Sorry, you can't check out files over FTP"))
+(error "Sorry, you can't check out files over FTP"))
-(vc-backend-checkout file writable)
+(vc-backend-checkout file writable rev)
-(if (string-equal file buffer-file-name)
+(vc-resynch-buffer file t t))
-(vc-resynch-window file t t))
-)
 (defun vc-steal-lock (file rev &optional owner)
 "Steal the lock on the current workfile."
 (let (file-description)
 (if (not owner)
 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
 		  "Enter a change comment." 'vc-backend-checkin
-		  'vc-checkin-hook 'vc-before-checkin-hook))
+		  'vc-checkin-hook))
 ;;; Here is a checkin hook that may prove useful to sites using the
 ;;; ChangeLog facility supported by Emacs.
 (defun vc-comment-to-change-log (&optional whoami file-name)
 "Enter last VC comment into change log file for current buffer's file.
 		   (list current-prefix-arg
 			 (prompt-for-change-log-name))))
 ;; Make sure the defvar for add-log-current-defun-function has been executed
 ;; before binding it.
 (require 'add-log)
-(let (				; Extract the comment first so we get any error before doing anything.
+(let (;; Extract the comment first so we get any error before doing anything.
 	(comment (ring-ref vc-comment-ring 0))
 	;; Don't let add-change-log-entry insert a defun name.
 	(add-log-current-defun-function 'ignore)
 	end)
 ;; Call add-log to do half the work.
 	(while (< (point) end)
 	  (forward-line 1)
 	  (indent-to indentation))
 	(setq end (point))))
 ;; Fill the inserted text, preserving open-parens at bol.
-(let ((paragraph-separate (concat paragraph-separate "\\|^\\s *\\s("))
+(let ((paragraph-separate (concat paragraph-separate "\\|\\s *\\s("))
-	  (paragraph-start (concat paragraph-start "\\|^\\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
 ;; separated from the next entry by a single blank line.
 (skip-syntax-forward " " end)
 	(if (not (bolp))
 	    (newline))
 	;; Comment too long?
 	(vc-backend-logentry-check vc-log-file)
 	;; Record the comment in the comment ring
-	(if (null vc-comment-ring)
-	    (setq vc-comment-ring (make-ring vc-maximum-comment-ring-size)))
 	(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
 (set-buffer vc-parent-buffer)
 (or vc-dired-mode
 	(vc-buffer-sync)))
-;; OK, do it to it
+(if (not vc-log-operation) (error "No log operation is pending"))
-(if vc-log-operation
+;; save the parameters held in buffer-local variables
-(save-excursion
+(let ((log-operation vc-log-operation)
-	(funcall vc-log-operation
+	(log-file vc-log-file)
-		 vc-log-file
+	(log-version vc-log-version)
-		 vc-log-version
+	(log-entry (buffer-string))
-		 (buffer-string)))
+	(after-hook vc-log-after-operation-hook))
-(error "No log operation is pending"))
-;; save the vc-log-after-operation-hook of log buffer
-(let ((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))
-(run-hooks after-hook)))
+(run-hooks after-hook 'vc-finish-logentry-hook)))
 ;; Code for access to the comment ring
 (defun vc-previous-comment (arg)
 "Cycle backwards through comment history."
 (interactive "*p")
 (let ((len (ring-length vc-comment-ring)))
-(cond ((or (not len) (<= len 0))	; XEmacs change from Barry Warsaw
+(cond ((<= len 0)
 	   (message "Empty comment ring")
 	   (ding))
 	  (t
 	   (erase-buffer)
 	   ;; Initialize the index on the first use of this command
 	   ;; so that the first M-p gets index 0, and the first M-n gets
 	   ;; index -1.
 	   (if (null vc-comment-ring-index)
 	       (setq vc-comment-ring-index
 		     (if (> arg 0) -1
-		       (if (< arg 0) 1 0))))
+			 (if (< arg 0) 1 0))))
 	   (setq vc-comment-ring-index
 		 (mod (+ vc-comment-ring-index arg) len))
 	   (message "%d" (1+ vc-comment-ring-index))
 	   (insert (ring-ref vc-comment-ring vc-comment-ring-index))))))
 (setq str vc-last-comment-match)
 (setq vc-last-comment-match str))
 (if (null vc-comment-ring-index)
 (setq vc-comment-ring-index -1))
 (let ((str (regexp-quote str))
-	(len (ring-length vc-comment-ring))
+(len (ring-length vc-comment-ring))
 	(n (1+ vc-comment-ring-index)))
 (while (and (< n len) (not (string-match str (ring-ref vc-comment-ring n))))
 (setq n (+ n 1)))
 (cond ((< n len)
 	   (vc-previous-comment (- n vc-comment-ring-index)))
 (setq str vc-last-comment-match)
 (setq vc-last-comment-match str))
 (if (null vc-comment-ring-index)
 (setq vc-comment-ring-index 0))
 (let ((str (regexp-quote str))
+(len (ring-length vc-comment-ring))
 	(n vc-comment-ring-index))
 (while (and (>= n 0) (not (string-match str (ring-ref vc-comment-ring n))))
 (setq n (- n 1)))
 (cond ((>= n 0)
 	   (vc-next-comment (- n vc-comment-ring-index)))
 "Display diffs between file versions.
 Normally this compares the current file and buffer with the most recent
 checked in version of that file.  This uses no arguments.
 With a prefix argument, it reads the file name to use
 and two version designators specifying which versions to compare."
-(interactive "P")
+(interactive (list current-prefix-arg t))
 (if vc-dired-mode
 (set-buffer (find-file-noselect (dired-get-filename))))
 (while vc-parent-buffer
 (pop-to-buffer vc-parent-buffer))
 (if historic
 (call-interactively 'vc-version-diff)
 (if (or (null buffer-file-name) (null (vc-name buffer-file-name)))
 	(error
 	 "There is no version-control master associated with this buffer"))
 (or (and file (vc-name file))
 	  (vc-registration-error file))
 (vc-buffer-sync not-urgent)
 (setq unchanged (vc-workfile-unchanged-p buffer-file-name))
 (if unchanged
-	  (message "No changes to %s since latest version." file)
+	  (message "No changes to %s since latest version" file)
 	(vc-backend-diff file)
 	;; Ideally, we'd like at this point to parse the diff so that
 	;; the buffer effectively goes into compilation mode and we
 	;; can visit the old and new change locations via next-error.
 	;; Unfortunately, this is just too painful to do.  The basic
 	;; 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*")
+	(set-buffer "*vc-diff*")
 	(setq default-directory (file-name-directory file))
 	(if (= 0 (buffer-size))
 	    (progn
 	      (setq unchanged t)
-	      (message "No changes to %s since latest version." file))
+	      (message "No changes to %s since latest version" file))
+(pop-to-buffer "*vc-diff*")
 	  (goto-char (point-min))
 	  (shrink-window-if-larger-than-buffer)))
 (not unchanged))))
-;;;###autoload
 (defun vc-version-diff (file rel1 rel2)
 "For FILE, report diffs between two stored versions REL1 and REL2 of it.
 If FILE is a directory, generate diffs between versions for all registered
 files in or below it."
-;; XEmacs - better prompt
+(interactive "FFile or directory to diff: \nsOlder version: \nsNewer version: ")
-(interactive "FFile or directory to diff: \nsOlder version (default is repository): \nsNewer version (default is workfile): ")
 (if (string-equal rel1 "") (setq rel1 nil))
 (if (string-equal rel2 "") (setq rel2 nil))
 (if (file-directory-p file)
 (let ((camefrom (current-buffer)))
 	(set-buffer (get-buffer-create "*vc-status*"))
 	(insert "Diffs between "
 		(or rel1 "last version checked in")
 		" 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
 		      (not (file-directory-p f))
 		      (vc-registered f)
 	(goto-char (point-min))
 	(set-buffer-modified-p nil)
 	)
 (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)
 "Visit version REV of the current buffer in another window.
 If the current buffer is named `F', the version is named `F.~REV~'.
 If `F.~REV~' already exists, it is used instead of being re-created."
 (interactive "sVersion to visit (default is latest version): ")
 (if vc-dired-mode
 (set-buffer (find-file-noselect (dired-get-filename))))
 (while vc-parent-buffer
 (pop-to-buffer vc-parent-buffer))
 (if (and buffer-file-name (vc-name buffer-file-name))
 (let* ((version (if (string-equal rev "")
 			  (vc-latest-version buffer-file-name)
 			rev))
 	     (filename (concat buffer-file-name ".~" version "~")))
-	(or (file-exists-p filename)
+	 (or (file-exists-p filename)
-	    (vc-backend-checkout buffer-file-name nil version filename))
+	     (vc-backend-checkout buffer-file-name nil version filename))
-	(find-file-other-window filename))
+	 (find-file-other-window filename))
 (vc-registration-error buffer-file-name)))
 ;; Header-insertion code
 ;;;###autoload
 the variable `vc-header-alist'."
 (interactive)
 (if vc-dired-mode
 (find-file-other-window (dired-get-filename)))
 (while vc-parent-buffer
 (pop-to-buffer vc-parent-buffer))
 (save-excursion
 (save-restriction
 (widen)
 (if (or (not (vc-check-headers))
 	      (y-or-n-p "Version headers already exist.  Insert another set? "))
 	  (progn
 	    (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)
+		   (hdstrings (cdr (assoc (vc-backend (buffer-file-name)) vc-header-alist))))
-					  vc-header-alist))))
+	      (mapcar (function (lambda (s)
-	      (mapcar #'(lambda (s)
+				  (insert comment-start-vc "\t" s "\t"
-			  (insert comment-start-vc "\t" s "\t"
+					  comment-end-vc "\n")))
-				  comment-end-vc "\n"))
 		      hdstrings)
 	      (if vc-static-header-alist
-		  (mapcar #'(lambda (f)
+		  (mapcar (function (lambda (f)
-			      (if (and buffer-file-name
+				      (if (string-match (car f) buffer-file-name)
-				       (string-match (car f) buffer-file-name))
+					  (insert (format (cdr f) (car hdstrings))))))
-				  (insert (format (cdr f) (car hdstrings)))))
 			  vc-static-header-alist))
 	      )
 	    )))))
-;; The VC directory submode.  Coopt Dired for this.
+(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)))
+;; The VC directory major mode.  Coopt Dired for this.
 ;; All VC commands get mapped into logical equivalents.
-;; XEmacs
+(define-derived-mode vc-dired-mode dired-mode "Dired under VC"
-(defvar vc-dired-prefix-map (let ((map (make-sparse-keymap)))
+"The major mode used in VC directory buffers.  It is derived from Dired.
-			      (set-keymap-name map 'vc-dired-prefix-map)
-			      (define-key map "\C-xv" vc-prefix-map)
-			      map))
-(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)))
-(defun vc-dired-mode ()
-"The augmented Dired minor mode used in VC directory buffers.
 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-dired-mode t))
-(setq vc-mode " under VC"))
+(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
 ;; place of the user and group info.  Should have the beneficial
 ;; side-effect of shortening the listing line.  Each call starts with
 ;;
 ;; Simplest possible one:
 ;; (insert (concat x "\t")))
 ;;
 ;; This code, like dired, assumes UNIX -l format.
-(forward-word 1)			; skip over any extra field due to -ibs options
+(let ((pos (point)) limit perm owner date-and-file)
-(cond ((numberp x)			; This hack is used by the CVS code.  See vc-locking-user.
+(end-of-line)
-	 (cond
+(setq limit (point))
-	  ((re-search-forward "\\([0-9]+ \\)\\([^ ]+\\)\\( .*\\)" nil 0)
+(goto-char pos)
-	   (save-excursion
+(cond
-	     (goto-char (match-beginning 2))
+((or
-	     (insert "(")
+(re-search-forward  ;; owner and group
-	     (goto-char (1+ (match-end 2)))
+"\\([drwxlts-]+ \\) *[0-9]+ \\([^ ]+\\) +[^ ]+ +[0-9]+\\( [^ 0-9]+ [0-9 ][0-9] .*\\)"
-	     (insert ")")
+	  limit t)
-	     (delete-char (- 17 (- (match-end 2) (match-beginning 2))))
+(re-search-forward  ;; only owner displayed
-	     (insert (substring "      " 0
+"\\([drwxlts-]+ \\) *[0-9]+ \\([^ ]+\\) +[0-9]+\\( [^ 0-9]+ [0-9 ][0-9] .*\\)"
-				(- 7 (- (match-end 2) (match-beginning 2)))))))))
+	  limit t))
-	(t
+(setq perm          (match-string 1)
-	 (if x (setq x (concat "(" x ")")))
+	    owner         (match-string 2)
-	 (if (re-search-forward "\\([0-9]+ \\).................\\( .*\\)" nil 0)
+	    date-and-file (match-string 3)))
-	     (let ((rep (substring (concat x "                 ") 0 9)))
+((re-search-forward  ;; OS/2 -l format, no links, owner, group
-	       (replace-match (concat "\\1" rep "\\2") t)))
+"\\([drwxlts-]+ \\) *[0-9]+\\( [^ 0-9]+ [0-9 ][0-9] .*\\)"
-	 )))
+limit t)
+(setq perm          (match-string 1)
+	    date-and-file (match-string 2))))
+(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 (dir verbose &optional nested)
+(defun vc-directory (dirname verbose)
-"Show version-control status of all files in the directory DIR.
+"Show version-control status of the current directory and subdirectories.
-If the second argument VERBOSE is non-nil, show all files;
+Normally it creates a Dired buffer that lists only the locked files
-otherwise show only files that current locked in the version control system.
+in all these directories.  With a prefix argument, it lists all files."
-Interactively, supply a prefix arg to make VERBOSE non-nil.
+(interactive "DDired under VC (directory): \nP")
+(require 'dired)
-If the optional third argument NESTED is non-nil,
+(setq dirname (expand-file-name dirname))
-scan the entire tree of subdirectories of the current directory."
+;; force a trailing slash
-(interactive "DVC status of directory: \nP")
+(if (not (eq (elt dirname (1- (length dirname))) ?/))
-(let* (nonempty
+(setq dirname (concat dirname "/")))
-	 (dl (+ 1 (length (directory-file-name (expand-file-name dir)))))
+(let (nonempty
-	 (filelist nil) (userlist nil)
+	(dl (if (featurep 'xemacs)
-	 dired-buf
+		(+ 1 (length (directory-file-name (expand-file-name dir))))
-	 (subfunction
+	      (length dirname)))
-	  (function (lambda (f)
+	(filelist nil) (statelist nil)
-		      (if (vc-registered f)
+	(old-dir default-directory)
-			  (let ((user (vc-locking-user f)))
+	dired-buf
-			    (and (or verbose user)
+	dired-buf-mod-count)
-				 (setq filelist (cons (substring f dl) filelist))
+(vc-file-tree-walk
-				 (setq userlist (cons user userlist)))))))))
+dirname
-(let ((default-directory (expand-file-name dir)))
+(function
-(if nested
+(lambda (f)
-	  (vc-file-tree-walk subfunction)
+	(if (vc-registered f)
-	(vc-dir-all-files subfunction)))
+	    (let ((state (vc-dired-state-info f)))
-(save-excursion
+	      (and (or verbose state)
-(dired (cons dir (nreverse filelist))
+		   (setq filelist (cons (substring f dl) filelist))
-	     dired-listing-switches)
+		   (setq statelist (cons state statelist))))))))
-(rename-buffer (generate-new-buffer-name "VC-DIRED"))
+(save-window-excursion
-(setq dired-buf (current-buffer))
+(save-excursion
-(setq nonempty (not (zerop (buffer-size)))))
+	;; 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)
+	  ;; Plug the version information into the individual lines
-	  (vc-dired-mode)
-	  (goto-char (point-min))
-	  (setq buffer-read-only nil)
-	  (forward-line 1)		; Skip header line
 	  (mapcar
 	   (function
 	    (lambda (x)
-	      (forward-char 2)		; skip dired's mark area
+	     (forward-char 2)	;; skip dired's mark area
-	      (vc-dired-reformat-line x)
+	     (vc-dired-reformat-line x)
-	      (forward-line 1)))	; go to next line
+	     (forward-line 1)))	;; go to next line
-	   (nreverse userlist))
+	   (nreverse statelist))
-	  (dired-insert-set-properties (point-min) (point-max))
+	  (if (featurep 'xemacs)
+	      (dired-insert-set-properties (point-min) (point-max)))
 	  (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") dirname))
+))
+;; Emacs 18 version
+(defun vc-directory-18 (verbose)
+"Show version-control status of all files under the current directory."
+(interactive "P")
+(let (nonempty (dir default-directory))
+(save-excursion
+(set-buffer (get-buffer-create "*vc-status*"))
+(erase-buffer)
+(cd dir)
+(vc-file-tree-walk
+default-directory
+(function (lambda (f)
+		   (if (vc-registered f)
+		       (let ((user (vc-locking-user f)))
+			 (if (or user verbose)
+			     (insert (format
+				      "%s	%s\n"
+				      (concat user) f))))))))
+(setq nonempty (not (zerop (buffer-size)))))
+(if nonempty
+	(progn
+	  (pop-to-buffer "*vc-status*" t)
+	  (goto-char (point-min))
+	  (shrink-window-if-larger-than-buffer)))
 (message "No files are currently %s under %s"
 	       (if verbose "registered" "locked") default-directory))
-))
+)
-(defun make-string-stringlist (stringlist)
+(or (boundp 'minor-mode-map-alist)
-"Turn a list of strings into a string of space-delimited elements."
+(fset 'vc-directory 'vc-directory-18))
-(save-excursion
-(let ((tlist stringlist)
-	  (buf (generate-new-buffer "*stringlist*")))
-(set-buffer buf)
-(insert (car tlist))
-(setq tlist (cdr tlist))
-(while (not (null tlist))
-	(setq s (car tlist))
-	(insert s)
-	(if (cdr tlist) (insert " "))
-	(setq tlist (cdr tlist)))
-(setq string (buffer-string))
-(kill-this-buffer)
-string
-)))
 ;; 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)
 (kill-buffer (current-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)
 (replace-match (concat ":" newname) nil nil))
 (basic-save-buffer)
 (cond ((null name) name)
 	((let ((firstchar (aref name 0)))
 	   (and (>= firstchar ?0) (<= firstchar ?9)))
 	 name)
 	(t
-	 (car (vc-master-info
+	 (save-excursion
-	       (concat (vc-backend-subdirectory-name file) "/" vc-name-assoc-file)
+	   (set-buffer (get-buffer-create "*vc-info*"))
-	       (list (concat name "\t:\t" file "\t\\(.+\\)"))))
+	   (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 ()
+(defun vc-snapshot-precondition ()
-;; Return an example of why the current directory is not ready to be snapshot
+;; Scan the tree below the current directory.
-;; or nil if no such example exists.
+;; If any files are locked, return the name of the first such file.
-(catch 'vc-locked-example
+;; (This means, neither snapshot creation nor retrieval is allowed.)
-(vc-file-tree-walk
+;; If one or more of the files are currently visited, return `visited'.
-(function (lambda (f)
+;; Otherwise, return nil.
-		 (if (and (vc-registered f) (vc-locking-user f))
+(let ((status nil))
-		     (throw 'vc-locked-example f)))))
+(catch 'vc-locked-example
-nil))
+(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)
 "Make a snapshot called NAME.
 The snapshot is made from all registered files at or below the current
 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)))
+(let ((result (vc-snapshot-precondition)))
-(if locked
+(if (stringp result)
-	(error "File %s is locked" locked)
+	(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)))))
 )))
 "Retrieve the snapshot called NAME.
 This function fails if any files are locked at or below the current directory
 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)))
+(let ((result (vc-snapshot-precondition))
-(if locked
+	(update nil))
-(error "File %s is locked" locked)
+(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
 ;;;###autoload
 "List the change log of the current buffer in a window."
 (interactive)
 (if vc-dired-mode
 (set-buffer (find-file-noselect (dired-get-filename))))
 (while vc-parent-buffer
 (pop-to-buffer vc-parent-buffer))
 (if (and buffer-file-name (vc-name buffer-file-name))
 (let ((file buffer-file-name))
-(vc-backend-print-log file)
+	(vc-backend-print-log file)
 	(pop-to-buffer (get-buffer-create "*vc*"))
 	(setq default-directory (file-name-directory file))
+	(goto-char (point-max)) (forward-line -1)
 	(while (looking-at "=*\n")
 	  (delete-char (- (match-end 0) (match-beginning 0)))
 	  (forward-line -1))
 	(goto-char (point-min))
 	(if (looking-at "[\b\t\n\v\f\r ]+")
 	    (delete-char (- (match-end 0) (match-beginning 0))))
-(shrink-window-if-larger-than-buffer)
+	(shrink-window-if-larger-than-buffer)
+	;; move point to the log entry for the current version
+	(and (not (eq (vc-backend file) 'SCCS))
+	     (re-search-forward
+	      ;; also match some context, for safety
+	      (concat "----\nrevision " (vc-workfile-version file)
+		      "\\(\tlocked by:.*\n\\|\n\\)date: ") nil t)
+	     ;; set the display window so that
+	     ;; the whole log entry is displayed
+	     (let (start end lines)
+	       (beginning-of-line) (forward-line -1) (setq start (point))
+	       (if (not (re-search-forward "^----*\nrevision" nil t))
+		   (setq end (point-max))
+		 (beginning-of-line) (forward-line -1) (setq end (point)))
+	       (setq lines (count-lines start end))
+	       (cond
+		;; if the global information and this log entry fit
+		;; into the window, display from the beginning
+		((< (count-lines (point-min) end) (window-height))
+		 (goto-char (point-min))
+		 (recenter 0)
+		 (goto-char start))
+		;; if the whole entry fits into the window,
+		;; display it centered
+		((< (1+ lines) (window-height))
+		 (goto-char start)
+		 (recenter (1- (- (/ (window-height) 2) (/ lines 2)))))
+		;; otherwise (the entry is too large for the window),
+		;; display from the start
+		(t
+		 (goto-char start)
+		 (recenter 0)))))
 	)
-(vc-registration-error buffer-file-name)))
+(vc-registration-error buffer-file-name)
+)
+)
 ;;;###autoload
 (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
 the file on the branch you are editing."
 (interactive)
 (if vc-dired-mode
 (find-file-other-window (dired-get-filename)))
 (while vc-parent-buffer
 (pop-to-buffer vc-parent-buffer))
 (let ((file buffer-file-name)
+	;; This operation should always ask for confirmation.
+	(vc-suppress-confirm nil)
 	(obuf (current-buffer)) (changed (vc-diff nil t)))
-(if (and changed (or vc-suppress-confirm
+(if (and changed (not (yes-or-no-p "Discard changes? ")))
-			 (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)
-))
+)
+)
 ;;;###autoload
 (defun vc-cancel-version (norevert)
 "Get rid of most recently checked in version of this file.
 A prefix argument means do not revert the buffer afterwards."
 (interactive "P")
 (if vc-dired-mode
 (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))))
+(cond
-	 (yours (concat (vc-your-latest-version (buffer-file-name))))
+((not (vc-registered (buffer-file-name)))
-	 (prompt (if (string-equal yours target)
+(vc-registration-error (buffer-file-name)))
-		     "Remove your version %s from master? "
+((eq (vc-backend (buffer-file-name)) 'CVS)
-		   "Version %s was not your change.  Remove it anyway? ")))
+(error "Unchecking files under CVS is dangerous and not supported in VC"))
-(if (null (yes-or-no-p (format prompt target)))
+((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)))
+(recent (if (vc-trunk-p target) "" (vc-branch-part target)))
+(config (current-window-configuration)) done)
+(if (null (yes-or-no-p (format "Remove version %s from master? " target)))
 	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
+;; Check out the most recent remaining version.  If it fails, because
-	      (not (yes-or-no-p "Revert buffer to most recent remaining version? ")))
+;; the whole branch got deleted, do a double-take and check out the
-	  (vc-mode-line (buffer-file-name))
+;; version where the branch started.
-	(vc-checkout (buffer-file-name) nil)))
+(while (not done)
-))
+(condition-case err
+(progn
+(if norevert
+;; Check out locked, but only to disc, and keep
+;; modifications in the buffer.
+(vc-backend-checkout (buffer-file-name) t recent)
+;; Check out unlocked, and revert buffer.
+(vc-checkout (buffer-file-name) nil recent))
+(setq done t))
+;; If the checkout fails, vc-do-command signals an error.
+;; We catch this error, check the reason, correct the
+;; version number, and try a second time.
+(error (set-buffer "*vc*")
+(goto-char (point-min))
+(if (search-forward "no side branches present for" nil t)
+(progn (setq recent (vc-branch-part recent))
+;; vc-do-command popped up a window with
+;; the error message.  Get rid of it, by
+;; restoring the old window configuration.
+(set-window-configuration config))
+;; No, it was some other error: re-signal it.
+(signal (car err) (cdr err))))))
+;; If norevert, clear version headers and mark the buffer modified.
+(if norevert
+(progn
+(set-visited-file-name (buffer-file-name))
+(if (not vc-make-backup-files)
+;; inhibit backup for this buffer
+(progn (make-local-variable 'backup-inhibited)
+(setq backup-inhibited t)))
+(if (eq (vc-backend (buffer-file-name)) 'RCS)
+(progn (setq buffer-read-only nil)
+(vc-clear-headers)))
+(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: ")
 ;; 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-deduce old) 'CVS)
+(if (eq (vc-backend old) 'CVS)
-(error "Renaming files under CVS is dangerous and not supported in VC."))
+(error "Renaming files under CVS is dangerous and not supported in VC"))
-(if (eq (vc-backend-deduce old) 'CC)
-(error "VC's ClearCase support cannot rename files."))
 (let ((oldbuf (get-file-buffer old)))
 (if (and oldbuf (buffer-modified-p oldbuf))
 	(error "Please save files before moving them"))
 (if (get-file-buffer new)
 	(error "Already editing new file name"))
 (if (file-exists-p new)
 	(error "New file already exists"))
 (let ((oldmaster (vc-name old)))
 (if oldmaster
 	  (progn
-(if (vc-locking-user old)
+	    (if (vc-locking-user old)
 		(error "Please check in files before moving them"))
 	    (if (or (file-symlink-p oldmaster)
 		    ;; This had FILE, I changed it to OLD. -- rms.
 		    (file-symlink-p (vc-backend-subdirectory-name old)))
-(error "This is not a safe thing to do in the presence of symbolic links"))
+		(error "This is not a safe thing to do in the presence of symbolic links"))
 	    (rename-file
-oldmaster
+	     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
 		 (mapcar
-(function
+		  (function
 		   (lambda (s)
 		     (if (eq backend (cdr s))
 			 (let* ((newmaster (format (car s) newdir newbase))
 				(newmasterdir (file-name-directory newmaster)))
 			   (if (or (not newmasterdir)
 			       (throw 'found newmaster))))))
 		  vc-master-templates)
 		 (error "New file lacks a version control directory"))))))
 (if (or (not oldmaster) (file-exists-p old))
 	  (rename-file old new)))
-;; ?? Renaming a file might change its contents due to keyword expansion.
+; ?? Renaming a file might change its contents due to keyword expansion.
-;; We should really check out a new copy if the old copy was precisely equal
+; We should really check out a new copy if the old copy was precisely equal
-;; to some checked in version.  However, testing for this is tricky....
+; to some checked in version.  However, testing for this is tricky....
 (if oldbuf
-(save-excursion
+	(save-excursion
 	  (set-buffer oldbuf)
-	  (set-visited-file-name new)
+	  (let ((buffer-read-only buffer-read-only))
+	    (set-visited-file-name new))
+	  (vc-backend new)
+	  (vc-mode-line new)
 	  (set-buffer-modified-p nil))))
 ;; This had FILE, I changed it to OLD. -- rms.
 (vc-backend-dispatch old
-(vc-record-rename old new)		;SCCS
+		       (vc-record-rename old new) ;SCCS
-;; #### - This CAN kinda be done for both rcs and
+		       nil		;RCS
-;; cvs.  It needs to be implemented. -- Stig
+		       nil		;CVS
-nil					;RCS
+		       )
-nil					;CVS
-nil					;CC
-)
 )
-;;;###autoload
-(defun vc-rename-this-file (new)
-(interactive "FVC rename file to: ")
-(vc-rename-file buffer-file-name new))
 ;;;###autoload
 (defun vc-update-change-log (&rest args)
-"Find change log file and add entries from recent RCS logs.
+"Find change log file and add entries from recent RCS/CVS logs.
+Normally, find log entries for all registered files in the default
+directory using `rcs2log', which finds CVS logs preferentially.
 The mark is left at the end of the text prepended to the change log.
 With prefix arg of C-u, only find log entries for the current buffer's file.
-With any numeric prefix arg, find log entries for all files currently visited.
-Otherwise, find log entries for all registered files in the default directory.
+With any numeric prefix arg, find log entries for all currently visited
-From a program, any arguments are passed to the `rcs2log' script."
+files that are under version control.  This puts all the entries in the
+log for the default directory, which may not be appropriate.
+From a program, any arguments are assumed to be filenames and are
+passed to the `rcs2log' script after massaging to be relative to the
+default directory."
 (interactive
 (cond ((consp current-prefix-arg)	;C-u
 	  (list buffer-file-name))
-	 (current-prefix-arg            ;Numeric argument.
+	 (current-prefix-arg		;Numeric argument.
 	  (let ((files nil)
 		(buffers (buffer-list))
 		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 files (cons file files)))
 	      (setq buffers (cdr buffers)))
 	    files))
 	 (t
-	  (let ((RCS (concat default-directory "RCS")))
+	  ;; `rcs2log' will find the relevant RCS or CVS files
-	    (and (file-directory-p RCS)
+	  ;; relative to the curent directory if none supplied.
-		 (mapcar (function
+	  nil)))
-			  (lambda (f)
+(let ((odefault default-directory)
-			    (if (string-match "\\(.*\\),v$" f)
+	(full-name (or add-log-full-name
-				(substring f 0 (match-end 1))
+		       (user-full-name)
-			      f)))
+		       (user-login-name)
-			 (directory-files RCS nil "...\\|^[^.]\\|^.[^.]")))))))
+		       (format "uid%d" (number-to-string (user-uid)))))
-(let ((odefault default-directory))
+	(mailing-address (or add-log-mailing-address
+			     user-mail-address)))
 (find-file-other-window (find-change-log))
 (barf-if-buffer-read-only)
 (vc-buffer-sync)
 (undo-boundary)
 (goto-char (point-min))
 (push-mark)
 (message "Computing change log entries...")
 (message "Computing change log entries... %s"
-	     (if (or (null args)
+	     (if (eq 0 (apply 'call-process "rcs2log" nil '(t nil) nil
-(eq 0 (apply 'call-process "rcs2log" nil t nil
+			      "-u"
-				  "-n"
+			      (concat (vc-user-login-name)
-				  (user-login-name)
+				      "\t"
-				  (user-full-name)
+				      full-name
-				  user-mail-address
+				      "\t"
-				  (mapcar (function
+				      mailing-address)
-					   (lambda (f)
+			      (mapcar (function
-					     (file-relative-name
+				       (lambda (f)
-(if (file-name-absolute-p f)
+					 (file-relative-name
-						  f
+					  (if (file-name-absolute-p f)
-						(concat odefault f)))))
+					      f
-					  args))))
+					    (concat odefault f)))))
+				      args)))
 		 "done" "failed"))))
-;; Functions for querying the master and lock files.
-;; XEmacs - use match-string instead...
-;; (defun vc-match-substring (bn)
-;;   (buffer-substring (match-beginning bn) (match-end bn)))
-(defun vc-parse-buffer (patterns &optional file properties)
-;; Each pattern is of the form:
-;;    regex                ; subex is 1, and date-subex is 2 (or nil)
-;;    (regex subex date-subex)
-;;
-;; Use PATTERNS to parse information out of the current buffer by matching
-;; each REGEX in the list and the returning the string matched by SUBEX.
-;; If a DATE-SUBEX is present, then the SUBEX from the match with the
-;; highest value for DATE-SUBEX (string comparison is used) will be
-;; returned.
-;;
-;; 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.
-;;
-(let (pattern regex subex date-subex latest-date val values date)
-(while (setq pattern (car patterns))
-(if (stringp pattern)
-	  (setq regex pattern
-		subex 1
-		date-subex (and (string-match "\\\\(.*\\\\(" regex) 2))
-	(setq regex (car pattern)
-	      subex (nth 1 pattern)
-	      date-subex (nth 2 pattern)))
-(goto-char (point-min))
-(if date-subex
-	  (progn
-	    (setq latest-date "" val nil)
-	    (while (re-search-forward regex nil t)
-	      (setq date (match-string date-subex))
-	      (if (string< latest-date date)
-		  (setq latest-date date
-			val (match-string subex))))
-	    val)
-	;; no date subex, so just take the first match...
-	(setq val (and (re-search-forward regex nil t) (match-string subex))))
-(if file (vc-file-setprop file (car properties) val))
-(setq values (cons val values)
-	    patterns (cdr patterns)
-	    properties (cdr properties)))
-values
-))
-(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)
-	(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 last flags patterns &optional properties)
-;; Search for information in log program output
-(if (and file (file-exists-p file))
-(save-excursion
-	(set-buffer (get-buffer-create "*vc*"))
-	(apply 'vc-do-command 0 command file last flags)
-(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.
-Under CVS, a file is considered locked if it has been modified since it
-was checked out...even though it may well be writable by you."
-(setq file (expand-file-name file))	; use full pathname
-(cond ((eq (vc-backend-deduce file) 'CVS)
-	 (if (vc-workfile-unchanged-p file t)
-	     nil
-	   ;; XEmacs - ahead of the pack...
-	   (user-login-name (nth 2 (file-attributes file)))))
-	(t
-	 ;; #### - this can probably be cleaned up as a result of the changes to
-	 ;; user-login-name...
-	 (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)))) ; #### - this looks recursive!!!
-	   ))))
-(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.
-(put 'vc-backend-dispatch 'lisp-indent-function 'defun)
-(defmacro vc-backend-dispatch (f s r c a)
-"Execute FORM1, FORM2 or FORM3 depending whether we're using SCCS, RCS, CVS
-or ClearCase.
-If FORM3 is RCS, use FORM2 even if we are using CVS.  (CVS shares some code
-with 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
-	      (list (list 'eq 'type (quote 'CVS)) ; CVS
-		    (if (eq c 'RCS) r c))
-	      (list (list 'eq 'type (quote 'CC)) a) ; CC
-	      )))
-(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-cvs-status (cvs only)
-;;   vc-cc-predecessor (ClearCase only)
-(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 'MASTER nil
-		 (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))
-;; CVS
-;; Don't fetch vc-locking-user and vc-locked-version here, since they
-;; should always be nil anyhow.  Don't fetch vc-your-latest-version, since
-;; that is done in vc-find-cvs-master.
-(vc-log-info
-"cvs" file 'WORKFILE '("status")
-;; CVS 1.3 says "RCS Version:", other releases "RCS Revision:",
-;; and CVS 1.4a1 says "Repository revision:".  The regexp below
-;; matches much more, but because of the way vc-log-info is
-;; implemented it is impossible to use additional groups.
-'(("\\(RCS Version\\|RCS Revision\\|Repository revision\\):[\t ]+\\([0-9.]+\\)" 2)
-"Status: \\(.*\\)")
-'(vc-latest-version
-vc-cvs-status))
-;; CC
-(vc-log-info "cleartool" file 'WORKFILE '("describe")
-		 (list
-		  "checked out .* by .* (\\([^ .]+\\)..*@.*)"
-		  "from \\([^ ]+\\) (reserved)"
-		  "version [^\"]*\".*@@\\([^ ]+\\)\""
-		  "version [^\"]*\".*@@\\([^ ]+\\)\""
-		  "predecessor version: \\([^ ]+\\)\n")
-		 '(vc-locking-user vc-locked-version
-				   vc-latest-version vc-your-latest-version
-				   vc-cc-predecessor))
-))
-(defun vc-backend-subdirectory-name (&optional file)
-;; Where the master and lock files for the current directory are kept
-(let ((backend
-	 (or
-	  (and file (vc-backend-deduce file))
-	  vc-default-back-end
-	  (setq vc-default-back-end (if (vc-find-binary "rcs") 'RCS 'SCCS)))))
-(cond
-((eq backend 'SCCS) "SCCS")
-((eq backend 'RCS)  "RCS")
-((eq backend 'CVS)  "CVS")
-((eq backend 'CC)   "@@"))
-))
 (defun vc-backend-admin (file &optional rev comment)
 ;; Register a file into the version-control system
 ;; Automatically retrieves a read-only version of the file with
 ;; keywords expanded if vc-keep-workfiles is non-nil, otherwise
 ;; it deletes the workfile.
 (vc-file-clearprops file)
 (or vc-default-back-end
 (setq vc-default-back-end (if (vc-find-binary "rcs") 'RCS 'SCCS)))
 (message "Registering %s..." file)
-(let ((backend
+(let ((switches
-(cond
+(if (stringp vc-register-switches)
+(list vc-register-switches)
+vc-register-switches))
+(backend
+	 (cond
 	  ((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)
+	  ((file-exists-p "CVS") 'CVS)
-	  ((file-exists-p "@@") 'CC)
 	  (t vc-default-back-end))))
 (cond ((eq backend 'SCCS)
-	   (vc-do-command 0 "admin" file 'MASTER ; SCCS
+	   (apply 'vc-do-command nil 0 "admin" file 'MASTER	;; SCCS
-			  (and rev (concat "-r" rev))
+(and rev (concat "-r" rev))
-			  "-fb"
+"-fb"
-			  (concat "-i" file)
+(concat "-i" file)
-			  (and comment (concat "-y" comment))
+(and comment (concat "-y" comment))
-			  (format
+(format
-			   (car (rassq 'SCCS vc-master-templates))
+(car (rassq 'SCCS vc-master-templates))
-			   (or (file-name-directory file) "")
+(or (file-name-directory file) "")
-			   (file-name-nondirectory file)))
+(file-name-nondirectory file))
+switches)
 	   (delete-file file)
 	   (if vc-keep-workfiles
-(vc-do-command 0 "get" file 'MASTER)))
+	       (vc-do-command nil 0 "get" file 'MASTER)))
 	  ((eq backend 'RCS)
-	   (vc-do-command 0 "ci" file 'MASTER ; RCS
+	   (apply 'vc-do-command nil 0 "ci" file 'WORKFILE	;; RCS
-			  (concat (if vc-keep-workfiles "-u" "-r") rev)
+;; if available, use the secure registering option
-			  (and comment (concat "-t-" comment))
+(and (vc-backend-release-p 'RCS "5.6.4") "-i")
-			  file))
+(concat (if vc-keep-workfiles "-u" "-r") rev)
-((eq backend 'CVS)
+(and comment (concat "-t-" comment))
-	   ;; #### - should maybe check to see if the master file is
+switches))
-	   ;; already in the repository...in which case we need to add the
+	  ((eq backend 'CVS)
-	   ;; appropriate branch tag and do  an update.
+	   (apply 'vc-do-command nil 0 "cvs" file 'WORKFILE ;; CVS
-	   ;; #### - note that adding a file is a 2 step process in CVS...
+"add"
-	   (vc-do-command 0 "cvs" file 'WORKFILE "add")
+(and comment (string-match "[^\t\n ]" comment)
-	   (vc-do-command 0 "cvs" file 'WORKFILE "commit"
+(concat "-m" comment))
-			  (and comment (not (string= comment ""))
+switches)
-			       (concat "-m" comment)))
-	   )
-	  ((eq backend 'CC)
-	   (vc-do-command 0 "cleartool" file 'WORKFILE ; CC
-			  "mkelem"
-			  (if (string-equal "" comment)
-			      "-nc")
-			  (if (not (string-equal "" comment))
-			      "-c")
-			  (if (not (string-equal "" comment))
-			      comment)
-			  )
-	   (vc-do-command 0 "cleartool" file 'WORKFILE
-			  "checkin" "-identical" "-nc"
-			  )
 	   )))
 (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))
+	switches)
 (message "Checking out %s..." filename)
 (save-excursion
-;; Change buffers to get local value of vc-checkin-switches.
+;; Change buffers to get local value of vc-checkout-switches.
-(set-buffer (or (get-file-buffer file) (current-buffer)))
+(if file-buffer (set-buffer file-buffer))
-(vc-backend-dispatch
+(setq switches (if (stringp vc-checkout-switches)
-	file
+			 (list vc-checkout-switches)
-	;; SCCS
+		       vc-checkout-switches))
-	(if workfile
+;; Save this buffer's default-directory
-	    ;; Some SCCS implementations allow checking out directly to a
+;; and use save-excursion to make sure it is restored
-	    ;; file using the -G option, but then some don't so use the
+;; in the same buffer it was saved in.
-	    ;; least common denominator approach and use the -p option
+(let ((default-directory default-directory))
-	    ;; ala RCS.
+	(save-excursion
-	    (let ((vc-modes (logior (file-modes (vc-name file))
+	  ;; Adjust the default-directory so that the check-out creates
-				    (if writable 128 0)))
+	  ;; the file in the right place.
-		  (failed t))
+	  (setq default-directory (file-name-directory filename))
-	      (unwind-protect
+	  (vc-backend-dispatch file
-		  (progn
+	    (progn  ;; SCCS
-		    (apply 'vc-do-command
+	      (and rev (string= rev "") (setq rev nil))
-			   0 "/bin/sh" file 'MASTER "-c"
+	      (if workfile
-			   ;; Some shells make the "" dummy argument into $0
+		  ;; Some SCCS implementations allow checking out directly to a
-			   ;; while others use the shell's name as $0 and
+		  ;; file using the -G option, but then some don't so use the
-			   ;; use the "" as $1.  The if-statement
+		  ;; least common denominator approach and use the -p option
-			   ;; converts the latter case to the former.
+		  ;; ala RCS.
-			   (format "if [ x\"$1\" = x ]; then shift; fi; \
+		  (let ((vc-modes (logior (file-modes (vc-name file))
-umask %o; exec >\"$1\" || exit; \
+					  (if writable 128 0)))
-shift; umask %o; exec get \"$@\""
+			(failed t))
-				   (logand 511 (lognot vc-modes))
+		    (unwind-protect
-				   (logand 511 (lognot (default-file-modes))))
+			(progn
-			   ""		; dummy argument for shell's $0
+			  (apply 'vc-do-command
-			   filename
+				 nil 0 "/bin/sh" file 'MASTER "-c"
-			   (if writable "-e")
+				 ;; Some shells make the "" dummy argument into $0
-			   "-p" (and rev
+				 ;; while others use the shell's name as $0 and
-				     (concat "-r" (vc-lookup-triple file rev)))
+				 ;; use the "" as $1.  The if-statement
-			   vc-checkout-switches)
+				 ;; converts the latter case to the former.
-		    (setq failed nil))
+				 (format "if [ x\"$1\" = x ]; then shift; fi; \
-		(and failed (file-exists-p filename) (delete-file filename))))
+			       umask %o; exec >\"$1\" || exit; \
-	  (apply 'vc-do-command 0 "get" file 'MASTER ; SCCS
+			       shift; umask %o; exec get \"$@\""
-		 (if writable "-e")
+				       (logand 511 (lognot vc-modes))
-		 (and rev (concat "-r" (vc-lookup-triple file rev)))
+				       (logand 511 (lognot (default-file-modes))))
-		 vc-checkout-switches))
+				 ""		; dummy argument for shell's $0
-	;; RCS
+				 filename
-	(if workfile
+				 (if writable "-e")
-	    ;; RCS doesn't let us check out into arbitrary file names directly.
+				 "-p"
-	    ;; Use `co -p' and make stdout point to the correct file.
+				 (and rev
-	    (let ((vc-modes (logior (file-modes (vc-name file))
+				      (concat "-r" (vc-lookup-triple file rev)))
-				    (if writable 128 0)))
+				 switches)
-		  (failed t))
+			  (setq failed nil))
-	      (unwind-protect
+		      (and failed (file-exists-p filename)
-		  (progn
+			   (delete-file filename))))
-		    (apply 'vc-do-command
+		(apply 'vc-do-command nil 0 "get" file 'MASTER   ;; SCCS
-			   0 "/bin/sh" file 'MASTER "-c"
+		       (if writable "-e")
-			   ;; See the SCCS case, above, regarding the
+		       (and rev (concat "-r" (vc-lookup-triple file rev)))
-			   ;; if-statement.
+		       switches)
-			   (format "if [ x\"$1\" = x ]; then shift; fi; \
+		(vc-file-setprop file 'vc-workfile-version nil)))
-umask %o; exec >\"$1\" || exit; \
+	    (if workfile  ;; RCS
-shift; umask %o; exec co \"$@\""
+		;; RCS doesn't let us check out into arbitrary file names directly.
-				   (logand 511 (lognot vc-modes))
+		;; Use `co -p' and make stdout point to the correct file.
-				   (logand 511 (lognot (default-file-modes))))
+		(let ((vc-modes (logior (file-modes (vc-name file))
-			   ""		; dummy argument for shell's $0
+					(if writable 128 0)))
-			   filename
+		      (failed t))
-			   (if writable "-l")
+		  (unwind-protect
-			   (concat "-p" rev)
+		      (progn
-			   vc-checkout-switches)
+			(apply 'vc-do-command
-		    (setq failed nil))
+			       nil 0 "/bin/sh" file 'MASTER "-c"
-		(and failed (file-exists-p filename) (delete-file filename))))
+			       ;; See the SCCS case, above, regarding the
-	  (apply 'vc-do-command 0 "co" file 'MASTER
+			       ;; if-statement.
-		 (if writable "-l")
+			       (format "if [ x\"$1\" = x ]; then shift; fi; \
-		 (and rev (concat "-r" rev))
+			       umask %o; exec >\"$1\" || exit; \
-		 vc-checkout-switches))
+			       shift; umask %o; exec co \"$@\""
-	;; CVS
+				       (logand 511 (lognot vc-modes))
-	(if workfile
+				       (logand 511 (lognot (default-file-modes))))
-	    ;; CVS is much like RCS
+			       ""		; dummy argument for shell's $0
-	    (let ((failed t))
+			       filename
-	      (unwind-protect
+			       (if writable "-l")
-		  (progn
+			       (concat "-p" rev)
-		    (apply 'vc-do-command
+			       switches)
-			   0 "/bin/sh" file 'WORKFILE "-c"
+			(setq failed nil))
-			   "exec >\"$1\" || exit; shift; exec cvs update \"$@\""
+		    (and failed (file-exists-p filename) (delete-file filename))))
-			   ""		; dummy argument for shell's $0
+	      (let (new-version)
-			   workfile
+		;; if we should go to the head of the trunk,
-			   (concat "-r" rev)
+		;; clear the default branch first
-			   "-p"
+		(and rev (string= rev "")
-			   vc-checkout-switches)
+		     (vc-do-command nil 0 "rcs" file 'MASTER "-b"))
-		    (setq failed nil))
+		;; now do the checkout
-		(and failed (file-exists-p filename) (delete-file filename))))
+		(apply 'vc-do-command
-	  (apply 'vc-do-command 0 "cvs" file 'WORKFILE
+		       nil 0 "co" file 'MASTER
-		 "update"
+		       ;; If locking is not strict, force to overwrite
-		 (and rev (concat "-r" rev))
+		       ;; the writable workfile.
-		 file
+		       (if (eq (vc-checkout-model file) 'implicit) "-f")
-		 vc-checkout-switches))
+		       (if writable "-l")
-	;; CC
+		       (if rev (concat "-r" rev)
-	(if (or rev workfile)
+			 ;; if no explicit revision was specified,
-	    (error "VC's ClearCase support currently checks out /main/LATEST.")
+			 ;; check out that of the working file
-	  (apply 'vc-do-command 0 "cleartool" file 'WORKFILE
+			 (let ((workrev (vc-workfile-version file)))
-		 "checkout" "-nc"
+			   (if workrev (concat "-r" workrev)
-		 vc-checkout-switches))
+			     nil)))
-	))
+		       switches)
-(or workfile
+		;; determine the new workfile version
-	(vc-file-setprop file
+		(save-excursion
-			 'vc-checkout-time (nth 5 (file-attributes file))))
+		  (set-buffer "*vc*")
-(message "Checking out %s...done" filename))
+		  (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"
+			       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))
+			 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))))
+	  (cond
+	   ((not workfile)
+	    (vc-file-clear-masterprops file)
+	    (if writable
+		(vc-file-setprop file 'vc-locking-user (vc-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
-(if (>= (buffer-size) 512)		; SCCS
+(if (>= (buffer-size) 512)	;; SCCS
-	(progn
+(progn
-	  (goto-char 512)
+	 (goto-char 512)
-	  (error
+	 (error
-	   "Log must be less than 512 characters; point is now at pos 512")))
+	  "Log must be less than 512 characters; point is now at pos 512")))
-nil					; RCS
+nil    ;; RCS
-nil					; CVS
+nil)   ;; CVS
-nil)				; CC
 )
 (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.
+;;   Adaptation 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)))
-(vc-backend-dispatch file
+(let ((switches
-(progn
+	   (if (stringp vc-checkin-switches)
-	(apply 'vc-do-command 0 "delta" file 'MASTER
+	       (list vc-checkin-switches)
-	       (if rev (concat "-r" rev))
+	     vc-checkin-switches)))
-	       (concat "-y" comment)
+;; Clear the master-properties.  Do that here, not at the
-	       vc-checkin-switches)
+;; end, because if the check-in fails we want them to get
-	(if vc-keep-workfiles
+;; re-computed before the next try.
-	    (vc-do-command 0 "get" file 'MASTER))
+(vc-file-clear-masterprops file)
-	)
+(vc-backend-dispatch file
-(apply 'vc-do-command 0 "ci" file 'MASTER
+	;; SCCS
-	     (concat (if vc-keep-workfiles "-u" "-r") rev)
+	(progn
-	     (if (not (string-equal "" comment))
+	  (apply 'vc-do-command nil 0 "delta" file 'MASTER
-		 (concat "-m" comment))
+		 (if rev (concat "-r" rev))
-	     vc-checkin-switches)
+		 (concat "-y" comment)
-(progn
+		 switches)
-	(apply 'vc-do-command 0 "cvs" file 'WORKFILE
+	  (vc-file-setprop file 'vc-locking-user 'none)
-	       "ci"
+	  (vc-file-setprop file 'vc-workfile-version nil)
-	       (if (not (string-equal "" comment))
+	  (if vc-keep-workfiles
-		   (concat "-m" comment))
+	      (vc-do-command nil 0 "get" file 'MASTER))
-	       vc-checkin-switches)
+	  )
-	(vc-file-setprop file 'vc-checkout-time
+	;; RCS
-			 (nth 5 (file-attributes file))))
+	(let ((old-version (vc-workfile-version file)) new-version)
-(progn
+	  (apply 'vc-do-command nil 0 "ci" file 'MASTER
-	(apply 'vc-do-command 0 "cleartool" file 'WORKFILE
+		 ;; if available, use the secure check-in option
-	       "checkin" "-identical"
+		 (and (vc-backend-release-p 'RCS "5.6.4") "-j")
-	       (if (string-equal "" comment)
+		 (concat (if vc-keep-workfiles "-u" "-r") rev)
-		   "-nc")
+		 (concat "-m" comment)
-	       (if (not (string-equal "" comment))
+		 switches)
-		   "-c")
+	  (vc-file-setprop file 'vc-locking-user 'none)
-	       (if (not (string-equal "" comment))
+	  (vc-file-setprop file 'vc-workfile-version nil)
-		   comment)
-	       vc-checkin-switches)
+	  ;; determine the new workfile version
-	(vc-file-setprop file 'vc-checkout-time
+	  (set-buffer "*vc*")
-			 (nth 5 (file-attributes file))))
+	  (goto-char (point-min))
-))
+	  (if (or (re-search-forward
-(vc-file-setprop file 'vc-locking-user nil)
+		   "new revision: \\([0-9.]+\\);" nil t)
-(message "Checking in %s...done" file)
+		  (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"
+			   switches))
+		(apply 'vc-do-command nil 0 "cvs" file 'WORKFILE
+		       "ci" (if rev (concat "-r" rev))
+		       (concat "-m" comment)
+		       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
+;; SCCS
-(vc-do-command 0 "unget" file 'MASTER nil)
+(progn
-(vc-do-command 0 "get" file 'MASTER nil))
+(vc-do-command nil 0 "unget" file 'MASTER nil)
-(vc-do-command 0 "co" file 'MASTER	; RCS.  This deletes the work file.
+(vc-do-command nil 0 "get" file 'MASTER nil))
-		   "-f" "-u")
+;; RCS
-(progn				; CVS
+(vc-do-command nil 0 "co" file 'MASTER
-(delete-file file)
+		  "-f" (concat "-u" (vc-workfile-version file)))
-(vc-do-command 0 "cvs" file 'WORKFILE "update"))
+;; CVS
-(vc-do-command 0 "cleartool" file 'WORKFILE ; CC
+(progn
-		   "unco" "-rm")
+(delete-file file)
-)
+(vc-do-command nil 0 "cvs" file 'WORKFILE "update")))
-(vc-file-setprop file 'vc-locking-user nil)
+(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)
 )
 (defun vc-backend-steal (file &optional rev)
 ;; 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				; SCCS
+(progn				;SCCS
-(vc-do-command 0 "unget" file 'MASTER "-n" (if rev (concat "-r" rev)))
+(vc-do-command nil 0 "unget" file 'MASTER "-n" (if rev (concat "-r" rev)))
-(vc-do-command 0 "get" file 'MASTER "-g" (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 'MASTER ; RCS
+(vc-do-command nil 0 "rcs" file 'MASTER	;RCS
-		   "-M" (concat "-u" rev) (concat "-l" rev))
+		  "-M" (concat "-u" rev) (concat "-l" rev))
-(error "You cannot steal a CVS lock; there are no CVS locks to steal.") ; CVS
+(error "You cannot steal a CVS lock; there are no CVS locks to steal") ;CVS
-(error "VC's ClearCase support cannot steal locks.") ; CC
+)
-)
+(vc-file-setprop file 'vc-locking-user (vc-user-login-name))
-(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
+;; Undo the latest checkin.
-;; smarter when we support multiple branches.
 (message "Removing last change from %s..." file)
 (vc-backend-dispatch file
-(vc-do-command 0 "rmdel" file 'MASTER (concat "-r" target))
+(vc-do-command nil 0 "rmdel" file 'MASTER (concat "-r" target))
-(vc-do-command 0 "rcs" file 'MASTER (concat "-o" target))
+(vc-do-command nil 0 "rcs" file 'MASTER (concat "-o" target))
-(error "Unchecking files under CVS is dangerous and not supported in VC.")
+nil  ;; this is never reached under CVS
-(error "VC's ClearCase support cannot cancel checkins.")
+)
-)
 (message "Removing last change from %s...done" file)
 )
 (defun vc-backend-print-log (file)
-;; Print change log associated with FILE to buffer *vc*.
+;; Get change log associated with FILE.
 (vc-backend-dispatch
 file
-(vc-do-command 0 "prs" file 'MASTER)
+(vc-do-command nil 0 "prs" file 'MASTER)
-(vc-do-command 0 "rlog" file 'MASTER)
+(vc-do-command nil 0 "rlog" file 'MASTER)
-(vc-do-command 0 "cvs" file 'WORKFILE "log")
+(vc-do-command nil 0 "cvs" file 'WORKFILE "log")))
-(vc-do-command 0 "cleartool" file 'WORKFILE "lshistory")))
 (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-add-triple name file (vc-latest-version file))              ;; SCCS
-(vc-do-command 0 "rcs" file 'MASTER (concat "-n" name ":")) ; RCS
+(vc-do-command nil 0 "rcs" file 'MASTER (concat "-n" name ":")) ;; RCS
-(vc-do-command 0 "cvs" file 'WORKFILE "tag" name) ; CVS
+(vc-do-command nil 0 "cvs" file 'WORKFILE "tag" name)	   ;; CVS
-(vc-do-command 0 "cleartool" file 'WORKFILE ; CC
+)
-		   "mklabel" "-replace" "-nc" name)
-)
 )
 (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.
-(let ((backend (vc-backend-deduce file)))
+(let ((backend (vc-backend file)) options status
+(diff-switches-list (if (listp diff-switches)
+diff-switches
+(list diff-switches))))
 (cond
 ((eq backend 'SCCS)
 (setq oldvers (vc-lookup-triple file oldvers))
-(setq newvers (vc-lookup-triple file newvers))))
+(setq newvers (vc-lookup-triple file newvers))
-(cond
+(setq options (append (list (and cmp "--brief") "-q"
-;; SCCS and RCS shares a lot of code.
+(and oldvers (concat "-r" oldvers))
-((or (eq backend 'SCCS) (eq backend 'RCS))
+(and newvers (concat "-r" newvers)))
-(let* ((command (if (eq backend 'SCCS)
+(and (not cmp) diff-switches-list)))
-			  "vcdiff"
+(apply 'vc-do-command "*vc-diff*" 1 "vcdiff" file 'MASTER options))
-			"rcsdiff"))
+((eq backend 'RCS)
-	     (mode (if (eq backend 'RCS) 'WORKFILE 'MASTER))
+(if (not oldvers) (setq oldvers (vc-workfile-version file)))
-	     (options (append (list (and cmp "--brief")
+;; If we know that --brief is not supported, don't try it.
-				    "-q"
+(setq cmp (and cmp (not (eq vc-rcsdiff-knows-brief 'no))))
-(and oldvers (concat "-r" oldvers))
+(setq options (append (list (and cmp "--brief") "-q"
-				    (and newvers (concat "-r" newvers)))
+(concat "-r" oldvers)
-(and (not cmp)
+(and newvers (concat "-r" newvers)))
-				   (if (listp diff-switches)
+(and (not cmp) diff-switches-list)))
-				       diff-switches
+(setq status (apply 'vc-do-command "*vc-diff*" 2
-				     (list diff-switches)))))
+"rcsdiff" file 'WORKFILE options))
-	     (status (apply 'vc-do-command 2 command file mode options)))
+;; If --brief didn't work, do a double-take and remember it
-	;; Some RCS versions don't understand "--brief"; work around this.
+;; for the future.
-	(if (eq status 2)
+(if (eq status 2)
-	    (apply 'vc-do-command 1 command file 'WORKFILE
+(prog1
-		   (if cmp (cdr options) options))
+(apply 'vc-do-command "*vc-diff*" 1 "rcsdiff" file 'WORKFILE
-	  status)))
+(if cmp (cdr options) options))
+(if cmp (setq vc-rcsdiff-knows-brief 'no)))
+;; If --brief DID work, remember that, too.
+(and cmp (not vc-rcsdiff-knows-brief)
+(setq vc-rcsdiff-knows-brief 'yes))
+status))
 ;; CVS is different.
-;; cmp is not yet implemented -- we always do a full diff.
 ((eq backend 'CVS)
-(if (string= (vc-file-getprop file 'vc-your-latest-version) "0") ; CVS
+(if (string= (vc-workfile-version file) "0")
 	  ;; This file is added but not yet committed; there is no master file.
-	  ;; diff it against /dev/null.
 	  (if (or oldvers newvers)
-	      (error "No revisions of %s exists" file)
+	      (error "No revisions of %s exist" file)
-	    (apply 'vc-do-command
+	    (if cmp 1 ;; file is added but not committed,
-		   1 "diff" file 'WORKFILE "/dev/null"
+	              ;; we regard this as "changed".
-		   (if (listp diff-switches)
+	      ;; diff it against /dev/null.
-		       diff-switches
+	      (apply 'vc-do-command
-		     (list diff-switches))))
+		     "*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
-	       1 "cvs" file 'WORKFILE "diff"
+	       "*vc-diff*" 1 "cvs" file 'WORKFILE "diff"
 	       (and oldvers (concat "-r" oldvers))
 	       (and newvers (concat "-r" newvers))
 	       (if (listp diff-switches)
-diff-switches
+		   diff-switches
-(list diff-switches)))))
+		 (list diff-switches)))))
-;; ClearCase is completely different.
-((eq backend 'CC)
-(apply 'vc-do-command 2 "cleardiff" file nil
-	     (if cmp "-status_only")
-	     (concat file "@@"
-		     (or oldvers
-			 (vc-file-getprop file 'vc-cc-predecessor)))
-	     (if newvers
-		 (concat file "@@" newvers)
-	       file)
-	     nil))
 (t
 (vc-registration-error file)))))
 (defun vc-backend-merge-news (file)
 ;; Merge in any new changes made to FILE.
-(vc-backend-dispatch
+(message "Merging changes into %s..." file)
-file
+(prog1
-(error "vc-backend-merge-news not meaningful for SCCS files") ; SCCS
+(vc-backend-dispatch
-(error "vc-backend-merge-news not meaningful for RCS files") ; RCS
+file
-(vc-do-command 1 "cvs" file 'WORKFILE "update") ; CVS
+(error "vc-backend-merge-news not meaningful for SCCS files") ;SCCS
-(error "vc-backend-merge-news not meaningful for ClearCase files") ; CC
+(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."
 (interactive)
 (save-excursion
 (goto-char (point-min))
 (vc-backend-dispatch buffer-file-name
-(re-search-forward  "%[MIRLBSDHTEGUYFPQCZWA]%" nil t) ; SCCS
+(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
+(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.
+'RCS				;; CVS works like RCS in this regard.
-nil ; ClearCase does not recognise headers.
+)
-)
 ))
 ;; Back-end-dependent stuff ends here.
 ;; Set up key bindings for use while editing log messages
-(defun vc-log-mode ()
+(defun vc-log-mode (&optional file)
 "Minor mode for driving version-control tools.
 These bindings are added to the global keymap when you enter this mode:
-\\[vc-next-action]          perform next logical version-control operation on current file
+\\[vc-next-action]		perform next logical version-control operation on current file
-\\[vc-register]                   register current file
+\\[vc-register]			register current file
-\\[vc-toggle-read-only]            like next-action, but won't register files
+\\[vc-toggle-read-only]		like next-action, but won't register files
-\\[vc-insert-headers]         insert version-control headers in current file
+\\[vc-insert-headers]		insert version-control headers in current file
-\\[vc-print-log]          display change history of current file
+\\[vc-print-log]		display change history of current file
-\\[vc-revert-buffer]              revert buffer to latest version
+\\[vc-revert-buffer]		revert buffer to latest version
-\\[vc-cancel-version]            undo latest checkin
+\\[vc-cancel-version]		undo latest checkin
-\\[vc-diff]          show diffs between file versions
+\\[vc-diff]		show diffs between file versions
-\\[vc-version-other-window]             visit old version in another window
+\\[vc-version-other-window]		visit old version in another window
-\\[vc-directory]             show all files locked by any user in or below .
+\\[vc-directory]		show all files locked by any user in or below .
-\\[vc-update-change-log]         add change log entry from recent checkins
+\\[vc-update-change-log]		add change log entry from recent checkins
 While you are entering a change log message for a version, the following
 additional bindings will be in effect.
-\\[vc-finish-logentry]   proceed with check in, ending log message entry
+\\[vc-finish-logentry]	proceed with check in, ending log message entry
 Whenever you do a checkin, your log comment is added to a ring of
 saved comments.  These can be recalled as follows:
-\\[vc-next-comment]   replace region with next message in comment ring
+\\[vc-next-comment]	replace region with next message in comment ring
-\\[vc-previous-comment] replace region with previous message in comment ring
+\\[vc-previous-comment]	replace region with previous message in comment ring
-\\[vc-comment-search-reverse]       search backward for regexp in the comment ring
+\\[vc-comment-search-reverse]	search backward for regexp in the comment ring
-\\[vc-comment-search-forward]     search backward for regexp in the comment ring
+\\[vc-comment-search-forward]	search backward for regexp in the comment ring
 Entry to the change-log submode calls the value of text-mode-hook, then
 the value of vc-log-mode-hook.
 Global user options:
-vc-initial-comment      If non-nil, require user to enter a change
+	vc-initial-comment	If non-nil, require user to enter a change
-			 comment upon first checkin of the file.
+				comment upon first checkin of the file.
-vc-keep-workfiles       Non-nil value prevents workfiles from being
+	vc-keep-workfiles	Non-nil value prevents workfiles from being
-			 deleted when changes are checked in
+				deleted when changes are checked in
 vc-suppress-confirm     Suppresses some confirmation prompts,
-			 notably for reversions.
+				notably for reversions.
-vc-header-alist         Which keywords to insert when adding headers
+	vc-header-alist		Which keywords to insert when adding headers
-			 with \\[vc-insert-headers].  Defaults to
+				with \\[vc-insert-headers].  Defaults to
-			 '(\"\%\W\%\") under SCCS, '(\"\$Id\$\") under
+				'(\"\%\W\%\") under SCCS, '(\"\$Id\$\") under
-RCS and CVS.
+				RCS and CVS.
-vc-static-header-alist  By default, version headers inserted in C files
+	vc-static-header-alist	By default, version headers inserted in C files
-get stuffed in a static string area so that
+				get stuffed in a static string area so that
-			 ident(RCS/CVS) or what(SCCS) can see them in
+				ident(RCS/CVS) or what(SCCS) can see them in
-			 the compiled object code.  You can override
+				the compiled object code.  You can override
-			 this by setting this variable to nil, or change
+				this by setting this variable to nil, or change
-the header template by changing it.
+				the header template by changing it.
-vc-command-messages     if non-nil, display run messages from the
+	vc-command-messages	if non-nil, display run messages from the
-			 actual version-control utilities (this is
+				actual version-control utilities (this is
-			 intended primarily for people hacking vc
+				intended primarily for people hacking vc
-			 itself).
+				itself).
 "
 (interactive)
 (set-syntax-table text-mode-syntax-table)
 (use-local-map vc-log-entry-mode)
 (setq local-abbrev-table text-mode-abbrev-table)
 (setq major-mode 'vc-log-mode)
 (setq mode-name "VC-Log")
 (make-local-variable 'vc-log-file)
+(setq vc-log-file file)
 (make-local-variable 'vc-log-version)
 (make-local-variable 'vc-comment-ring-index)
 (set-buffer-modified-p nil)
 (setq buffer-file-name nil)
 (run-hooks 'text-mode-hook 'vc-log-mode-hook)
 )
 ;; Initialization code, to be done just once at load-time
 (if vc-log-entry-mode
 nil
 (setq vc-log-entry-mode (make-sparse-keymap))
-(set-keymap-name vc-log-entry-mode 'vc-log-entry-mode) ; XEmacs
 (define-key vc-log-entry-mode "\M-n" 'vc-next-comment)
 (define-key vc-log-entry-mode "\M-p" 'vc-previous-comment)
 (define-key vc-log-entry-mode "\M-r" 'vc-comment-search-reverse)
 (define-key vc-log-entry-mode "\M-s" 'vc-comment-search-forward)
 (define-key vc-log-entry-mode "\C-c\C-c" 'vc-finish-logentry)
 )
 ;;; These things should probably be generally available
-(defun vc-file-tree-walk (func &rest args)
+(defun vc-file-tree-walk (dirname func &rest args)
-"Walk recursively through default directory.
+"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)
+(vc-file-tree-walk-internal (expand-file-name dirname) func args)
-(message "Traversing directory %s...done" default-directory))
+(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
+			(or
-			(file-symlink-p dirf) ; Avoid possible loops
+			 (file-symlink-p dirf) ;; Avoid possible loops
-			(vc-file-tree-walk-internal dirf func args))))))
+			 (vc-file-tree-walk-internal dirf func args))))))
 (directory-files dir)))))
-(defun vc-dir-all-files (func &rest args)
-"Invoke FUNC f ARGS on each regular file f in default directory."
-(let ((dir default-directory))
-(message "Scanning directory %s..." dir)
-(mapcar (function (lambda (f)
-			(let ((dirf (expand-file-name f dir)))
-			  (if (not (file-directory-p dirf))
-			      (apply func dirf args)))))
-(directory-files dir))
-(message "Scanning directory %s...done" dir)))
 (provide 'vc)
 ;;; 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
 ;;; the actions that change it.  This is a window open to lossage in a
 ;;; multi-user environment; someone else could nip in and change the state
 ;;;
 ;;; The race condition implies that we have to either (a) lock the master
 ;;; during the entire execution of vc-next-action, or (b) detect and
 ;;; recover from errors resulting from dispatch on an out-of-date state.
 ;;;
-;;; Alternative (a) appears to be unfeasible.  The problem is that we can't
+;;; Alternative (a) appears to be infeasible.  The problem is that we can't
 ;;; guarantee that the lock will ever be removed.  Suppose a user starts a
 ;;; checkin, the change message buffer pops up, and the user, having wandered
 ;;; off to do something else, simply forgets about it?
 ;;;
 ;;; Alternative (b), on the other hand, works well with a cheap way to speed up
 ;;;    A  B  C  D  E
 ;;;  A .  1  2  3  4   ci -u -t-          admin -fb -i<file>      initial admin
 ;;;  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).
 ;;;
 ;;; In the discussion below, a "self-race" is a pathological situation in
 ;;; which VC operations are being attempted simultaneously by two or more
 ;;; 1. File looked unregistered but is actually registered and not locked.
 ;;;
 ;;;    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.
 ;;;
 ;;; 2. File looked unregistered but is actually locked by caller, unchanged.
 ;;;
 ;;;    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.
 ;;;
 ;;; 3. File looked unregistered but is actually locked by caller, changed.
 ;;;
 ;;;    Potential cause: self-race during window P.
 ;;;
-;;;    RCS: will register the caller's workfile as a delta with a
+;;;    RCS: Prior to version 5.6.4, VC registers the caller's workfile as
-;;; null change comment (the -t- switch will be ignored).
+;;;         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.
 ;;;
 ;;; Apparent state B ---
 ;;; 13. File looks like it's locked by the calling user and changed, but it's
 ;;; actually unregistered.
 ;;;
 ;;;    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
+;;;    This case is kind of nasty.  Under RCS prior to version 5.6.4,
-;;; loss of previous version information.
+;;; 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.
 ;;;
 ;;;    Potential cause: self-race in window V, or the checkin happening
 ;;;
 ;;; PROBLEM CASES:
 ;;;
 ;;;    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
 ;;; only the information in the current workfile.  This can only happen
 ;;; if the master file gets nuked in window P.

Mercurial > hg > xemacs-beta

comparison lisp/packages/vc.el @ 151:59463afc5666 r20-3b2