;;; 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,98,99,2000,2001,02,2003 Free Software Foundation, Inc.
;; Author: FSF (see vc.el for full credits)
;; Maintainer: Andre Spiegel <spiegel@gnu.org>
-;; $Id: vc-cvs.el,v 1.59 2003/05/08 20:44:50 monnier Exp $
+;; $Id: vc-cvs.el,v 1.67 2004/01/20 17:41:18 uid65624 Exp $
;; This file is part of GNU Emacs.
(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.
"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
`vc-register-switches' and `vc-cvs-register-switches' are passed to
the CVS command (in that order)."
+ (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)
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'."
'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"))
-(defun vc-cvs-rename-file (old new)
- ;; CVS doesn't know how to move files, so we just remove&add.
- (condition-case nil
- (add-name-to-file old new)
- (error (rename-file old new)))
- (vc-cvs-delete-file old)
- (with-current-buffer (find-file-noselect new)
- (vc-register)))
-
(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."
(if (string= (vc-workfile-version file) "0")
;; This file is added but not yet committed; there is no master file.
;; We regard this as "changed".
;; Diff it against /dev/null.
;; Note: this is NOT a "cvs diff".
- (apply 'vc-do-command "*vc-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 (vc-cvs-stay-local-p file) (fboundp 'start-process)))
- (status (apply 'vc-cvs-command "*vc-diff*"
+ (let* ((async (and (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))
"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
(beginning-of-line nil)
(vc-cvs-annotate-time))))))
+(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'."
- (when 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)
- (vc-file-setprop
- dirname 'vc-cvs-stay-local-p
- (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))
- (let* ((cvs-root-members
- (vc-cvs-parse-root
- (buffer-substring (point)
- (line-end-position))))
- (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)
- vc-cvs-stay-local)
- ;; vc-cvs-stay-local: '( [except] rx ... )
- ((consp vc-cvs-stay-local)
- (mapconcat
- 'identity
- (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))))
+(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.
"\\(.*\\)")) ;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