;;; vc-cvs.el --- non-resident support for CVS version-control
-;; Copyright (C) 1995,98,99,2000,2001,2002 Free Software Foundation, Inc.
+;; Copyright (C) 1995, 1998, 1999, 2000, 2001, 2002, 2003,
+;; 2004, 2005 Free Software Foundation, Inc.
;; Author: FSF (see vc.el for full credits)
;; Maintainer: Andre Spiegel <spiegel@gnu.org>
-;; $Id: vc-cvs.el,v 1.54 2003/04/19 22:40:18 monnier Exp $
+;; $Id$
;; This file is part of GNU Emacs.
;; You should have received a copy of the GNU General Public License
;; 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.
+;; Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+;; Boston, MA 02110-1301, USA.
;;; Commentary:
(repeat :tag "Argument List"
:value ("")
string))
- :version "21.4"
+ :version "22.1"
:group 'vc)
(defcustom vc-cvs-register-switches nil
:version "21.1"
:group 'vc)
-(defcustom vc-cvs-stay-local '(except "^\\(localhost\\)$")
+(defcustom vc-cvs-stay-local t
"*Non-nil means use local operations when possible for remote repositories.
This avoids slow queries over the network and instead uses heuristics
and past information to determine the current status of a file.
+
The value can also be a regular expression or list of regular
expressions to match against the host name of a repository; then VC
-only stays local for hosts that match it.
-This is useful in a setup, where most CVS servers should be contacted
-directly, and only a few CVS servers cannot be reached easily.
-For the opposite scenario, when only a few CVS servers are to be
-queried directly, a list of regular expressions can be specified,
-whose first element is the symbol `except'."
+only stays local for hosts that match it. Alternatively, the value
+can be a list of regular expressions where the first element is the
+symbol `except'; then VC always stays local except for hosts matched
+by these regular expressions."
:type '(choice (const :tag "Always stay local" t)
(const :tag "Don't stay local" nil)
- (list :format "\nExamine hostname and %v" :tag "Examine hostname ..."
+ (list :format "\nExamine hostname and %v" :tag "Examine hostname ..."
(set :format "%v" :inline t (const :format "%t" :tag "don't" except))
(regexp :format " stay local,\n%t: %v" :tag "if it matches")
(repeat :format "%v%i\n" :inline t (regexp :tag "or"))))
Format is according to `format-time-string'. Only used if
`vc-cvs-sticky-tag-display' is t."
:type '(string)
- :version "21.4"
+ :version "22.1"
:group 'vc)
(defcustom vc-cvs-sticky-tag-display t
See also variable `vc-cvs-sticky-date-format-string'."
:type '(choice boolean function)
- :version "21.4"
+ :version "22.1"
:group 'vc)
;;;
;;; Internal variables
;;;
-(defvar vc-cvs-local-month-numbers
- '(("Jan" . 1) ("Feb" . 2) ("Mar" . 3) ("Apr" . 4)
- ("May" . 5) ("Jun" . 6) ("Jul" . 7) ("Aug" . 8)
- ("Sep" . 9) ("Oct" . 10) ("Nov" . 11) ("Dec" . 12))
- "Local association list of month numbers.")
-
;;;
;;; State-querying functions
(defun vc-cvs-state (file)
"CVS-specific version of `vc-state'."
- (if (vc-cvs-stay-local-p file)
+ (if (vc-stay-local-p file)
(let ((state (vc-file-getprop file 'vc-state)))
;; If we should stay local, use the heuristic but only if
;; we don't have a more precise state already available.
- (if (memq state '(up-to-date edited))
+ (if (memq state '(up-to-date edited nil))
(vc-cvs-state-heuristic file)
state))
(with-temp-buffer
"Find the CVS state of all files in DIR."
;; if DIR is not under CVS control, don't do anything.
(when (file-readable-p (expand-file-name "CVS/Entries" dir))
- (if (vc-cvs-stay-local-p dir)
+ (if (vc-stay-local-p dir)
(vc-cvs-dir-state-heuristic dir)
(let ((default-directory dir))
;; Don't specify DIR in this command, the default-directory is
(defun vc-cvs-checkout-model (file)
"CVS-specific version of `vc-checkout-model'."
- (if (or (getenv "CVSREAD")
- ;; If the file is not writable (despite CVSREAD being
- ;; undefined), this is probably because the file is being
- ;; "watched" by other developers.
- ;; (If vc-mistrust-permissions was t, we actually shouldn't
- ;; trust this, but there is no other way to learn this from CVS
- ;; at the moment (version 1.9).)
- (string-match "r-..-..-." (nth 8 (file-attributes file))))
+ (if (getenv "CVSREAD")
'announce
- 'implicit))
+ (let ((attrib (file-attributes file)))
+ (if (and attrib ;; don't check further if FILE doesn't exist
+ ;; If the file is not writable (despite CVSREAD being
+ ;; undefined), this is probably because the file is being
+ ;; "watched" by other developers.
+ ;; (If vc-mistrust-permissions was t, we actually shouldn't
+ ;; trust this, but there is no other way to learn this from CVS
+ ;; at the moment (version 1.9).)
+ (string-match "r-..-..-." (nth 8 attrib)))
+ 'announce
+ 'implicit))))
(defun vc-cvs-mode-line-string (file)
"Return string for placement into the modeline for FILE.
Compared to the default implementation, this function does two things:
Handle the special case of a CVS file that is added but not yet
committed and support display of sticky tags."
- (let* ((state (vc-state file))
- (rev (vc-workfile-version file))
- (sticky-tag (vc-file-getprop file 'vc-cvs-sticky-tag))
- (sticky-tag-printable (and sticky-tag
- (not (string= sticky-tag ""))
- (concat "[" sticky-tag "]"))))
- (cond ((string= rev "0")
- ;; A file that is added but not yet committed.
- "CVS @@")
- ((or (eq state 'up-to-date)
- (eq state 'needs-patch))
- (concat "CVS-" rev sticky-tag-printable))
- ((stringp state)
- (concat "CVS:" state ":" rev sticky-tag-printable))
- (t
- ;; Not just for the 'edited state, but also a fallback
- ;; for all other states. Think about different symbols
- ;; for 'needs-patch and 'needs-merge.
- (concat "CVS:" rev sticky-tag-printable)))))
+ (let ((sticky-tag (vc-file-getprop file 'vc-cvs-sticky-tag))
+ (string (if (string= (vc-workfile-version file) "0")
+ ;; A file that is added but not yet committed.
+ "CVS @@"
+ (vc-default-mode-line-string 'CVS file))))
+ (if (zerop (length sticky-tag))
+ string
+ (concat string "[" sticky-tag "]"))))
(defun vc-cvs-dired-state-info (file)
"CVS-specific version of `vc-dired-state-info'."
- (let* ((cvs-state (vc-state file))
- (state (cond ((eq cvs-state 'edited) "modified")
- ((eq cvs-state 'needs-patch) "patch")
- ((eq cvs-state 'needs-merge) "merge")
- ;; FIXME: those two states cannot occur right now
- ((eq cvs-state 'unlocked-changes) "conflict")
- ((eq cvs-state 'locally-added) "added")
- )))
- (if state (concat "(" state ")"))))
+ (let ((cvs-state (vc-state file)))
+ (cond ((eq cvs-state 'edited)
+ (if (equal (vc-workfile-version file) "0")
+ "(added)" "(modified)"))
+ ((eq cvs-state 'needs-patch) "(patch)")
+ ((eq cvs-state 'needs-merge) "(merge)"))))
;;;
`vc-register-switches' and `vc-cvs-register-switches' are passed to
the CVS command (in that order)."
- (let ((switches (append
- (if (stringp vc-register-switches)
- (list vc-register-switches)
- vc-register-switches)
- (if (stringp vc-cvs-register-switches)
- (list vc-cvs-register-switches)
- vc-cvs-register-switches))))
-
- (apply 'vc-cvs-command nil 0 file
- "add"
- (and comment (string-match "[^\t\n ]" comment)
- (concat "-m" comment))
- switches)))
+ (when (and (not (vc-cvs-responsible-p file))
+ (vc-cvs-could-register file))
+ ;; Register the directory if needed.
+ (vc-cvs-register (directory-file-name (file-name-directory file))))
+ (apply 'vc-cvs-command nil 0 file
+ "add"
+ (and comment (string-match "[^\t\n ]" comment)
+ (concat "-m" comment))
+ (vc-switches 'CVS 'register)))
(defun vc-cvs-responsible-p (file)
"Return non-nil if CVS thinks it is responsible for FILE."
file
(file-name-directory file)))))
-(defalias 'vc-cvs-could-register 'vc-cvs-responsible-p
+(defun vc-cvs-could-register (file)
"Return non-nil if FILE could be registered in CVS.
-This is only possible if CVS is responsible for FILE's directory.")
+This is only possible if CVS is managing FILE's directory or one of
+its parents."
+ (let ((dir file))
+ (while (and (stringp dir)
+ (not (equal dir (setq dir (file-name-directory dir))))
+ dir)
+ (setq dir (if (file-directory-p
+ (expand-file-name "CVS/Entries" dir))
+ t (directory-file-name dir))))
+ (eq dir t)))
(defun vc-cvs-checkin (file rev comment)
"CVS-specific version of `vc-backend-checkin'."
- (let ((switches (if (stringp vc-checkin-switches)
- (list vc-checkin-switches)
- vc-checkin-switches))
- status)
- (if (or (not rev) (vc-cvs-valid-version-number-p rev))
- (setq status (apply 'vc-cvs-command nil 1 file
- "ci" (if rev (concat "-r" rev))
- (concat "-m" comment)
- switches))
- (if (not (vc-cvs-valid-symbolic-tag-name-p rev))
- (error "%s is not a valid symbolic tag name" rev)
- ;; If the input revison is a valid symbolic tag name, we create it
- ;; as a branch, commit and switch to it.
- (apply 'vc-cvs-command nil 0 file "tag" "-b" (list rev))
- (apply 'vc-cvs-command nil 0 file "update" "-r" (list rev))
- (setq status (apply 'vc-cvs-command nil 1 file
- "ci"
- (concat "-m" comment)
- switches))
- (vc-file-setprop file 'vc-cvs-sticky-tag rev)))
+ (unless (or (not rev) (vc-cvs-valid-version-number-p rev))
+ (if (not (vc-cvs-valid-symbolic-tag-name-p rev))
+ (error "%s is not a valid symbolic tag name" rev)
+ ;; If the input revison is a valid symbolic tag name, we create it
+ ;; as a branch, commit and switch to it.
+ (apply 'vc-cvs-command nil 0 file "tag" "-b" (list rev))
+ (apply 'vc-cvs-command nil 0 file "update" "-r" (list rev))
+ (vc-file-setprop file 'vc-cvs-sticky-tag rev)))
+ (let ((status (apply 'vc-cvs-command nil 1 file
+ "ci" (if rev (concat "-r" rev))
+ (concat "-m" comment)
+ (vc-switches 'CVS 'checkin))))
(set-buffer "*vc*")
(goto-char (point-min))
(when (not (zerop status))
(and rev (not (string= rev ""))
(concat "-r" rev))
"-p"
- (if (stringp vc-checkout-switches)
- (list vc-checkout-switches)
- vc-checkout-switches)))
+ (vc-switches 'CVS 'checkout)))
(defun vc-cvs-checkout (file &optional editable rev workfile)
"Retrieve a revision of FILE into a WORKFILE.
(save-excursion
;; Change buffers to get local value of vc-checkout-switches.
(if file-buffer (set-buffer file-buffer))
- (setq switches (if (stringp vc-checkout-switches)
- (list vc-checkout-switches)
- vc-checkout-switches))
+ (setq switches (vc-switches 'CVS 'checkout))
;; Save this buffer's default-directory
;; and use save-excursion to make sure it is restored
;; in the same buffer it was saved in.
(if (and (file-exists-p file) (not rev))
;; If no revision was specified, just make the file writable
;; if necessary (using `cvs-edit' if requested).
- (and editable (not (eq (vc-cvs-checkout-model file) 'implicit))
+ (and editable (not (eq (vc-cvs-checkout-model file) 'implicit))
(if vc-cvs-use-edit
(vc-cvs-command nil 0 file "edit")
(set-file-modes file (logior (file-modes file) 128))
'implicit)))
"-w")
"update"
- ;; default for verbose checkout: clear the sticky tag so
- ;; that the actual update will get the head of the trunk
- (if (or (not rev) (eq rev t) (string= rev ""))
- "-A"
- (concat "-r" rev))
+ (when rev
+ (unless (eq rev t)
+ ;; default for verbose checkout: clear the
+ ;; sticky tag so that the actual update will
+ ;; get the head of the trunk
+ (if (string= rev "")
+ "-A"
+ (concat "-r" rev))))
switches))))
(vc-mode-line file)
(message "Checking out %s...done" filename)))))
+(defun vc-cvs-delete-file (file)
+ (vc-cvs-command nil 0 file "remove" "-f")
+ (vc-cvs-command nil 0 file "commit" "-mRemoved."))
+
(defun vc-cvs-revert (file &optional contents-done)
"Revert FILE to the version it was based on."
(unless contents-done
;;; History functions
;;;
-(defun vc-cvs-print-log (file)
+(defun vc-cvs-print-log (file &optional buffer)
"Get change log associated with FILE."
(vc-cvs-command
- nil
- (if (and (vc-cvs-stay-local-p file) (fboundp 'start-process)) 'async 0)
+ buffer
+ (if (and (vc-stay-local-p file) (fboundp 'start-process)) 'async 0)
file "log"))
-(defun vc-cvs-diff (file &optional oldvers newvers)
+(defun vc-cvs-diff (file &optional oldvers newvers buffer)
"Get a difference report using CVS between two versions of FILE."
- (let (status (diff-switches-list (vc-diff-switches-list 'CVS)))
- (if (string= (vc-workfile-version file) "0")
- ;; This file is added but not yet committed; there is no master file.
- (if (or oldvers newvers)
- (error "No revisions of %s exist" file)
- ;; We regard this as "changed".
- ;; Diff it against /dev/null.
- ;; Note: this is NOT a "cvs diff".
- (apply 'vc-do-command "*vc-diff*"
- 1 "diff" file
- (append diff-switches-list '("/dev/null"))))
- (setq status
- (apply 'vc-cvs-command "*vc-diff*"
- (if (and (vc-cvs-stay-local-p file)
- (fboundp 'start-process))
- 'async
- 1)
- file "diff"
- (and oldvers (concat "-r" oldvers))
- (and newvers (concat "-r" newvers))
- diff-switches-list))
- (if (vc-cvs-stay-local-p file)
- 1 ;; async diff, pessimistic assumption
- status))))
+ (if (string= (vc-workfile-version file) "0")
+ ;; This file is added but not yet committed; there is no master file.
+ (if (or oldvers newvers)
+ (error "No revisions of %s exist" file)
+ ;; We regard this as "changed".
+ ;; Diff it against /dev/null.
+ ;; Note: this is NOT a "cvs diff".
+ (apply 'vc-do-command (or buffer "*vc-diff*")
+ 1 "diff" file
+ (append (vc-switches nil 'diff) '("/dev/null")))
+ ;; Even if it's empty, it's locally modified.
+ 1)
+ (let* ((async (and (not vc-disable-async-diff)
+ (vc-stay-local-p file)
+ (fboundp 'start-process)))
+ (status (apply 'vc-cvs-command (or buffer "*vc-diff*")
+ (if async 'async 1)
+ file "diff"
+ (and oldvers (concat "-r" oldvers))
+ (and newvers (concat "-r" newvers))
+ (vc-switches 'CVS 'diff))))
+ (if async 1 status)))) ; async diff, pessimistic assumption
(defun vc-cvs-diff-tree (dir &optional rev1 rev2)
"Diff all files at and below DIR."
(with-current-buffer "*vc-diff*"
(setq default-directory dir)
- (if (vc-cvs-stay-local-p dir)
+ (if (vc-stay-local-p dir)
;; local diff: do it filewise, and only for files that are modified
(vc-file-tree-walk
dir
(apply 'vc-cvs-command "*vc-diff*" 1 nil "diff"
(and rev1 (concat "-r" rev1))
(and rev2 (concat "-r" rev2))
- (vc-diff-switches-list 'CVS))))))
+ (vc-switches 'CVS 'diff))))))
(defun vc-cvs-annotate-command (file buffer &optional version)
"Execute \"cvs annotate\" on FILE, inserting the contents in BUFFER.
Optional arg VERSION is a version to annotate from."
- (vc-cvs-command buffer 0 file "annotate" (if version
- (concat "-r" version))))
+ (vc-cvs-command buffer 0 file "annotate" (if version (concat "-r" version)))
+ (with-current-buffer buffer
+ (goto-char (point-min))
+ (re-search-forward "^[0-9]")
+ (delete-region (point-min) (1- (point)))))
(defun vc-cvs-annotate-current-time ()
"Return the current time, based at midnight of the current day, and
(defun vc-cvs-annotate-time ()
"Return the time of the next annotation (as fraction of days)
systime, or nil if there is none."
- (let ((time-stamp
- "^\\S-+\\s-+\\S-+\\s-+\\([0-9]+\\)-\\(\\sw+\\)-\\([0-9]+\\)): "))
- (if (looking-at time-stamp)
- (progn
- (let* ((day (string-to-number (match-string 1)))
- (month (cdr (assoc (match-string 2)
- vc-cvs-local-month-numbers)))
- (year-tmp (string-to-number (match-string 3)))
- ;; Years 0..68 are 2000..2068.
- ;; Years 69..99 are 1969..1999.
- (year (+ (cond ((> 69 year-tmp) 2000)
- ((> 100 year-tmp) 1900)
- (t 0))
- year-tmp)))
- (goto-char (match-end 0)) ; Position at end makes for nicer overlay result
- (vc-annotate-convert-time (encode-time 0 0 0 day month year))))
- ;; If we did not look directly at an annotation, there might be
- ;; some further down. This is the case if we are positioned at
- ;; the very top of the buffer, for instance.
- (if (re-search-forward time-stamp nil t)
- (progn
- (beginning-of-line nil)
- (vc-cvs-annotate-time))))))
+ (let* ((bol (point))
+ (cache (get-text-property bol 'vc-cvs-annotate-time))
+ buffer-read-only)
+ (cond
+ (cache)
+ ((looking-at
+ "^\\S-+\\s-+\\S-+\\s-+\\([0-9]+\\)-\\(\\sw+\\)-\\([0-9]+\\)): ")
+ (let ((day (string-to-number (match-string 1)))
+ (month (cdr (assq (intern (match-string 2))
+ '((Jan . 1) (Feb . 2) (Mar . 3)
+ (Apr . 4) (May . 5) (Jun . 6)
+ (Jul . 7) (Aug . 8) (Sep . 9)
+ (Oct . 10) (Nov . 11) (Dec . 12)))))
+ (year (let ((tmp (string-to-number (match-string 3))))
+ ;; Years 0..68 are 2000..2068.
+ ;; Years 69..99 are 1969..1999.
+ (+ (cond ((> 69 tmp) 2000)
+ ((> 100 tmp) 1900)
+ (t 0))
+ tmp))))
+ (put-text-property
+ bol (1+ bol) 'vc-cvs-annotate-time
+ (setq cache (cons
+ ;; Position at end makes for nicer overlay result.
+ (match-end 0)
+ (vc-annotate-convert-time
+ (encode-time 0 0 0 day month year))))))))
+ (when cache
+ (goto-char (car cache)) ; fontify from here to eol
+ (cdr cache)))) ; days (float)
+
+(defun vc-cvs-annotate-extract-revision-at-line ()
+ (save-excursion
+ (beginning-of-line)
+ (if (re-search-forward "^\\([0-9]+\\.[0-9]+\\(\\.[0-9]+\\)*\\) +("
+ (line-end-position) t)
+ (match-string-no-properties 1)
+ nil)))
;;;
;;; Snapshot system
;;; Miscellaneous
;;;
-(defalias 'vc-cvs-make-version-backups-p 'vc-cvs-stay-local-p
+(defalias 'vc-cvs-make-version-backups-p 'vc-stay-local-p
"Return non-nil if version backups should be made for FILE.")
(defun vc-cvs-check-headers ()
(append vc-cvs-global-switches
flags))))
-(defun vc-cvs-stay-local-p (file)
- "Return non-nil if VC should stay local when handling FILE.
-See `vc-cvs-stay-local'."
- (if vc-cvs-stay-local
- (let* ((dirname (if (file-directory-p file)
- (directory-file-name file)
- (file-name-directory file)))
- (prop
- (or (vc-file-getprop dirname 'vc-cvs-stay-local-p)
- (let ((rootname (expand-file-name "CVS/Root" dirname)))
- (vc-file-setprop
- dirname 'vc-cvs-stay-local-p
- (when (file-readable-p rootname)
- (with-temp-buffer
- (vc-insert-file rootname)
- (goto-char (point-min))
- (looking-at "\\([^\n]*\\)")
- (let* ((cvs-root-members
- (vc-cvs-parse-root (match-string 1)))
- (hostname (nth 2 cvs-root-members)))
- (if (not hostname)
- 'no
- (let ((stay-local t) rx)
- (cond
- ;; vc-cvs-stay-local: rx
- ((stringp vc-cvs-stay-local)
- (setq rx vc-cvs-stay-local))
- ;; vc-cvs-stay-local: '( [except] rx ... )
- ((consp vc-cvs-stay-local)
- (setq rx (mapconcat
- (function
- (lambda (elt)
- elt))
- (if (not (eq (car vc-cvs-stay-local)
- 'except))
- vc-cvs-stay-local
- (setq stay-local nil)
- (cdr vc-cvs-stay-local))
- "\\|"))))
- (if (not rx)
- 'yes
- (if (not (string-match rx hostname))
- (setq stay-local (not stay-local)))
- (if stay-local
- 'yes
- 'no))))))))))))
- (if (eq prop 'yes) t nil))))
-
-(defun vc-cvs-parse-root ( root )
+(defalias 'vc-cvs-stay-local-p 'vc-stay-local-p) ;Back-compatibility.
+
+(defun vc-cvs-repository-hostname (dirname)
+ "Hostname of the CVS server associated to workarea DIRNAME."
+ (let ((rootname (expand-file-name "CVS/Root" dirname)))
+ (when (file-readable-p rootname)
+ (with-temp-buffer
+ (let ((coding-system-for-read
+ (or file-name-coding-system
+ default-file-name-coding-system)))
+ (vc-insert-file rootname))
+ (goto-char (point-min))
+ (nth 2 (vc-cvs-parse-root
+ (buffer-substring (point)
+ (line-end-position))))))))
+
+(defun vc-cvs-parse-root (root)
"Split CVS ROOT specification string into a list of fields.
A CVS root specification of the form
[:METHOD:][[USER@]HOSTNAME:]/path/to/repository
The default METHOD for a CVS root of the form
[USER@]HOSTNAME:/path/to/repository
is `ext'.
-For an empty string, nil is returned (illegal CVS root)."
+For an empty string, nil is returned (invalid CVS root)."
;; Split CVS root into colon separated fields (0-4).
;; The `x:' makes sure, that leading colons are not lost;
;; `HOST:/PATH' is then different from `:METHOD:/PATH'.
(let ((coding-system-for-read (or file-name-coding-system
default-file-name-coding-system)))
(vc-insert-file (expand-file-name "CVS/Entries" dir))))
-
+
(defun vc-cvs-valid-symbolic-tag-name-p (tag)
"Return non-nil if TAG is a valid symbolic tag name."
;; According to the CVS manual, a valid symbolic tag must start with
"\\(.*\\)")) ;Sticky tag
(vc-file-setprop file 'vc-workfile-version (match-string 1))
(vc-file-setprop file 'vc-cvs-sticky-tag
- (vc-cvs-parse-sticky-tag (match-string 4) (match-string 5)))
- ;; compare checkout time and modification time
- (let* ((mtime (nth 5 (file-attributes file)))
- (system-time-locale "C")
- (mtstr (format-time-string "%c" mtime 'utc)))
- ;; Solaris sometimes uses "Wed Sep 05" instead of "Wed Sep 5".
- ;; See "grep '[^a-z_]ctime' cvs/src/*.c" for reference.
- (if (= (aref mtstr 8) ?0)
- (setq mtstr (concat (substring mtstr 0 8) " " (substring mtstr 9))))
- (cond ((equal mtstr (match-string 2))
- (vc-file-setprop file 'vc-checkout-time mtime)
- (if set-state (vc-file-setprop file 'vc-state 'up-to-date)))
- (t
- (vc-file-setprop file 'vc-checkout-time 0)
- (if set-state (vc-file-setprop file 'vc-state 'edited))))))))
+ (vc-cvs-parse-sticky-tag (match-string 4)
+ (match-string 5)))
+ ;; Compare checkout time and modification time.
+ ;; This is intentionally different from the algorithm that CVS uses
+ ;; (which is based on textual comparison), because there can be problems
+ ;; generating a time string that looks exactly like the one from CVS.
+ (let ((mtime (nth 5 (file-attributes file))))
+ (require 'parse-time)
+ (let ((parsed-time
+ (parse-time-string (concat (match-string 2) " +0000"))))
+ (cond ((and (not (string-match "\\+" (match-string 2)))
+ (car parsed-time)
+ (equal mtime (apply 'encode-time parsed-time)))
+ (vc-file-setprop file 'vc-checkout-time mtime)
+ (if set-state (vc-file-setprop file 'vc-state 'up-to-date)))
+ (t
+ (vc-file-setprop file 'vc-checkout-time 0)
+ (if set-state (vc-file-setprop file 'vc-state 'edited)))))))))
(provide 'vc-cvs)
+;;; arch-tag: 60e1402a-aa53-4607-927a-cf74f144b432
;;; vc-cvs.el ends here