X-Git-Url: https://code.delx.au/gnu-emacs/blobdiff_plain/bee48f254bfb43ca0f520f53c46c7d29bcdcc28e..03da5d089a8ed035cec443a27259e7d21487a22e:/lisp/vc-cvs.el diff --git a/lisp/vc-cvs.el b/lisp/vc-cvs.el index fbe6b9a2b3..cf661f6276 100644 --- a/lisp/vc-cvs.el +++ b/lisp/vc-cvs.el @@ -1,11 +1,12 @@ ;;; vc-cvs.el --- non-resident support for CVS version-control -;; Copyright (C) 1995,98,99,2000 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 -;; $Id: vc-cvs.el,v 1.6 2000/10/22 15:31:11 spiegel Exp $ +;; $Id$ ;; This file is part of GNU Emacs. @@ -21,13 +22,30 @@ ;; 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: ;;; Code: +(eval-when-compile + (require 'vc)) + +;;; +;;; Customization options +;;; + +(defcustom vc-cvs-global-switches nil + "*Global switches to pass to any CVS command." + :type '(choice (const :tag "None" nil) + (string :tag "Argument String") + (repeat :tag "Argument List" + :value ("") + string)) + :version "22.1" + :group 'vc) + (defcustom vc-cvs-register-switches nil "*Extra switches for registering a file into CVS. A string or list of strings passed to the checkin program by @@ -40,10 +58,20 @@ A string or list of strings passed to the checkin program by :version "21.1" :group 'vc) +(defcustom vc-cvs-diff-switches nil + "*A string or list of strings specifying extra switches for cvs diff under VC." + :type '(choice (const :tag "None" nil) + (string :tag "Argument String") + (repeat :tag "Argument List" + :value ("") + string)) + :version "21.1" + :group 'vc) + (defcustom vc-cvs-header (or (cdr (assoc 'CVS vc-header-alist)) '("\$Id\$")) "*Header keywords to be inserted by `vc-insert-headers'." :version "21.1" - :type 'string + :type '(repeat string) :group 'vc) (defcustom vc-cvs-use-edit t @@ -56,21 +84,84 @@ This is only meaningful if you don't use the implicit checkout model (defcustom vc-cvs-stay-local t "*Non-nil means use local operations when possible for remote repositories. -This avoids slow queries over the network. Turning this option on -will instruct VC to use only heuristics and past information to -determine the current status of a file. The value can also be a -regular expression to match against the host name of a repository; -then VC only stays local for hosts that match it." +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. 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) - (string :tag "Host regexp") - (const :tag "Don't stay local" nil)) + (const :tag "Don't stay local" nil) + (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")))) :version "21.1" :group 'vc) +(defcustom vc-cvs-sticky-date-format-string "%c" + "*Format string for mode-line display of sticky date. +Format is according to `format-time-string'. Only used if +`vc-cvs-sticky-tag-display' is t." + :type '(string) + :version "22.1" + :group 'vc) + +(defcustom vc-cvs-sticky-tag-display t + "*Specify the mode-line display of sticky tags. +Value t means default display, nil means no display at all. If the +value is a function or macro, it is called with the sticky tag and +its' type as parameters, in that order. TYPE can have three different +values: `symbolic-name' (TAG is a string), `revision-number' (TAG is a +string) and `date' (TAG is a date as returned by `encode-time'). The +return value of the function or macro will be displayed as a string. + +Here's an example that will display the formatted date for sticky +dates and the word \"Sticky\" for sticky tag names and revisions. + + (lambda (tag type) + (cond ((eq type 'date) (format-time-string + vc-cvs-sticky-date-format-string tag)) + ((eq type 'revision-number) \"Sticky\") + ((eq type 'symbolic-name) \"Sticky\"))) + +Here's an example that will abbreviate to the first character only, +any text before the first occurrence of `-' for sticky symbolic tags. +If the sticky tag is a revision number, the word \"Sticky\" is +displayed. Date and time is displayed for sticky dates. + + (lambda (tag type) + (cond ((eq type 'date) (format-time-string \"%Y%m%d %H:%M\" tag)) + ((eq type 'revision-number) \"Sticky\") + ((eq type 'symbolic-name) + (condition-case nil + (progn + (string-match \"\\\\([^-]*\\\\)\\\\(.*\\\\)\" tag) + (concat (substring (match-string 1 tag) 0 1) \":\" + (substring (match-string 2 tag) 1 nil))) + (error tag))))) ; Fall-back to given tag name. + +See also variable `vc-cvs-sticky-date-format-string'." + :type '(choice boolean function) + :version "22.1" + :group 'vc) + +;;; +;;; Internal variables +;;; + + +;;; +;;; State-querying functions +;;; + ;;;###autoload (defun vc-cvs-registered (f) ;;;###autoload (when (file-readable-p (expand-file-name ;;;###autoload "CVS/Entries" (file-name-directory f))) -;;;###autoload (require 'vc-cvs) +;;;###autoload (load "vc-cvs") ;;;###autoload (vc-cvs-registered f))) (defun vc-cvs-registered (file) @@ -81,120 +172,30 @@ then VC only stays local for hosts that match it." (case-fold-search nil)) (if (file-readable-p (expand-file-name "CVS/Entries" dirname)) (with-temp-buffer - (vc-insert-file (expand-file-name "CVS/Entries" dirname)) + (vc-cvs-get-entries dirname) (goto-char (point-min)) (cond ((re-search-forward - (concat "^/" (regexp-quote basename) "/") nil t) + ;; CVS-removed files are not taken under VC control. + (concat "^/" (regexp-quote basename) "/[^/-]") nil t) (beginning-of-line) (vc-cvs-parse-entry file) t) (t nil))) nil))) -(defun vc-cvs-stay-local-p (file) - "Return non-nil if VC should stay local when handling FILE." - (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)) - (if (looking-at "\\([^:]*\\):") - (if (not (stringp vc-cvs-stay-local)) - 'yes - (let ((hostname (match-string 1))) - (if (string-match vc-cvs-stay-local hostname) - 'yes - 'no))) - 'no)))))))) - (if (eq prop 'yes) t nil)))) - -(defun vc-cvs-workfile-version (file) - "CVS-specific version of `vc-workfile-version'." - ;; There is no need to consult RCS headers under CVS, because we - ;; get the workfile version for free when we recognize that a file - ;; is registered in CVS. - (vc-cvs-registered file) - (vc-file-getprop file 'vc-workfile-version)) - -(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)))) - 'announce - 'implicit)) - -;; VC Dired functions - -(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 ")")))) - -(defun vc-cvs-parse-status (&optional full) - "Parse output of \"cvs status\" command in the current buffer. -Set file properties accordingly. Unless FULL is t, parse only -essential information." - (let (file status) - (goto-char (point-min)) - (if (re-search-forward "^File: " nil t) - (cond - ((looking-at "no file") nil) - ((re-search-forward "\\=\\([^ \t]+\\)" nil t) - (setq file (expand-file-name (match-string 1))) - (vc-file-setprop file 'vc-backend 'CVS) - (if (not (re-search-forward "\\=[ \t]+Status: \\(.*\\)" nil t)) - (setq status "Unknown") - (setq status (match-string 1))) - (if (and full - (re-search-forward - "\\(RCS Version\\|RCS Revision\\|Repository revision\\):\ -\[\t ]+\\([0-9.]+\\)" - nil t)) - (vc-file-setprop file 'vc-latest-version (match-string 2))) - (cond - ((string-match "Up-to-date" status) - (vc-file-setprop file 'vc-checkout-time - (nth 5 (file-attributes file))) - 'up-to-date) - ((string-match "Locally Modified" status) 'edited) - ((string-match "Needs Merge" status) 'needs-merge) - ((string-match "Needs \\(Checkout\\|Patch\\)" status) 'needs-patch) - (t 'edited))))))) - (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 (cd (file-name-directory file)) - (vc-do-command t 0 "cvs" file "status") + (vc-cvs-command t 0 file "status") (vc-cvs-parse-status t)))) (defun vc-cvs-state-heuristic (file) @@ -207,318 +208,126 @@ essential information." 'up-to-date 'edited))) -(defun vc-cvs-mode-line-string (file) - "Return string for placement into the modeline for FILE. -Compared to the default implementation, this function handles the -special case of a CVS file that is added but not yet comitted." - (let ((state (vc-state file)) - (rev (vc-workfile-version file))) - (cond ((string= rev "0") - ;; A file that is added but not yet comitted. - "CVS @@") - ((or (eq state 'up-to-date) - (eq state 'needs-patch)) - (concat "CVS-" rev)) - ((stringp state) - (concat "CVS:" state ":" rev)) - (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))))) - (defun vc-cvs-dir-state (dir) "Find the CVS state of all files in DIR." - (if (vc-cvs-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 - ;; enough. Otherwise it might fail with remote repositories. - (with-temp-buffer - (vc-do-command t 0 "cvs" nil "status" "-l") - (goto-char (point-min)) - (while (re-search-forward "^=+\n\\([^=\n].*\n\\|\n\\)+" nil t) - (narrow-to-region (match-beginning 0) (match-end 0)) - (vc-cvs-parse-status) - (goto-char (point-max)) - (widen)))))) + ;; if DIR is not under CVS control, don't do anything. + (when (file-readable-p (expand-file-name "CVS/Entries" 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 + ;; enough. Otherwise it might fail with remote repositories. + (with-temp-buffer + (vc-cvs-command t 0 nil "status" "-l") + (goto-char (point-min)) + (while (re-search-forward "^=+\n\\([^=\n].*\n\\|\n\\)+" nil t) + (narrow-to-region (match-beginning 0) (match-end 0)) + (vc-cvs-parse-status) + (goto-char (point-max)) + (widen))))))) -(defun vc-cvs-dir-state-heuristic (dir) - "Find the CVS state of all files in DIR, using only local information." - (with-temp-buffer - (vc-insert-file (expand-file-name "CVS/Entries" dir)) - (goto-char (point-min)) - (while (not (eobp)) - (when (looking-at "/\\([^/]*\\)/") - (let ((file (expand-file-name (match-string 1) dir))) - (unless (vc-file-getprop file 'vc-state) - (vc-cvs-parse-entry file t)))) - (forward-line 1)))) +(defun vc-cvs-workfile-version (file) + "CVS-specific version of `vc-workfile-version'." + ;; There is no need to consult RCS headers under CVS, because we + ;; get the workfile version for free when we recognize that a file + ;; is registered in CVS. + (vc-cvs-registered file) + (vc-file-getprop file 'vc-workfile-version)) -(defun vc-cvs-parse-entry (file &optional set-state) - "Parse a line from CVS/Entries. -Compare modification time to that of the FILE, set file properties -accordingly. However, `vc-state' is set only if optional arg SET-STATE -is non-nil." - (cond - ;; entry for a "locally added" file (not yet committed) - ((looking-at "/[^/]+/0/") - (vc-file-setprop file 'vc-checkout-time 0) - (vc-file-setprop file 'vc-workfile-version "0") - (if set-state (vc-file-setprop file 'vc-state 'edited))) - ;; normal entry - ((looking-at - (concat "/[^/]+" - ;; revision - "/\\([^/]*\\)" - ;; timestamp - "/[A-Z][a-z][a-z]" ;; week day (irrelevant) - " \\([A-Z][a-z][a-z]\\)" ;; month name - " *\\([0-9]*\\)" ;; day of month - " \\([0-9]*\\):\\([0-9]*\\):\\([0-9]*\\)" ;; hms - " \\([0-9]*\\)" ;; year - ;; optional conflict field - "\\(+[^/]*\\)?/")) - (vc-file-setprop file 'vc-workfile-version (match-string 1)) - ;; compare checkout time and modification time - (let ((second (string-to-number (match-string 6))) - (minute (string-to-number (match-string 5))) - (hour (string-to-number (match-string 4))) - (day (string-to-number (match-string 3))) - (year (string-to-number (match-string 7))) - (month (/ (string-match - (match-string 2) - "xxxJanFebMarAprMayJunJulAugSepOctNovDec") - 3)) - (mtime (nth 5 (file-attributes file)))) - (cond ((equal mtime - (encode-time second minute hour day month year 0)) - (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)))))) - ;; entry with arbitrary text as timestamp - ;; (this means we should consider it modified) - ((looking-at - (concat "/[^/]+" - ;; revision - "/\\([^/]*\\)" - ;; timestamp (arbitrary text) - "/[^/]*" - ;; optional conflict field - "\\(+[^/]*\\)?/")) - (vc-file-setprop file 'vc-workfile-version (match-string 1)) - (vc-file-setprop file 'vc-checkout-time 0) - (if set-state (vc-file-setprop file 'vc-state 'edited))))) - -(defun vc-cvs-print-log (file) - "Get change log associated with FILE." - (vc-do-command t 'async "cvs" file "log")) - -(defun vc-cvs-show-log-entry (version) - (when (re-search-forward - ;; also match some context, for safety - (concat "----\nrevision " version - "\\(\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)))))) +(defun vc-cvs-checkout-model (file) + "CVS-specific version of `vc-checkout-model'." + (if (getenv "CVSREAD") + 'announce + (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-create-snapshot (dir name branchp) - "Assign to DIR's current version a given NAME. -If BRANCHP is non-nil, the name is created as a branch (and the current -workspace is immediately moved to that new branch)." - (vc-do-command nil 0 "cvs" dir "tag" "-c" (if branchp "-b") name) - (when branchp (vc-do-command nil 0 "cvs" dir "update" "-r" name))) +(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 ((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-retrieve-snapshot (dir name update) - "Retrieve a snapshot at and below DIR. -NAME is the name of the snapshot; if it is empty, do a `cvs update'. -If UPDATE is non-nil, then update (resynch) any affected buffers." - (with-current-buffer (get-buffer-create "*vc*") - (let ((default-directory dir)) - (erase-buffer) - (if (or (not name) (string= name "")) - (vc-do-command t 0 "cvs" nil "update") - (vc-do-command t 0 "cvs" nil "update" "-r" name)) - (when update - (goto-char (point-min)) - (while (not (eobp)) - (if (looking-at "\\([CMUP]\\) \\(.*\\)") - (let* ((file (expand-file-name (match-string 2) dir)) - (state (match-string 1)) - (buffer (find-buffer-visiting file))) - (when buffer - (cond - ((or (string= state "U") - (string= state "P")) - (vc-file-setprop file 'vc-state 'up-to-date) - (vc-file-setprop file 'vc-workfile-version nil) - (vc-file-setprop file 'vc-checkout-time - (nth 5 (file-attributes file)))) - ((or (string= state "M") - (string= state "C")) - (vc-file-setprop file 'vc-state 'edited) - (vc-file-setprop file 'vc-workfile-version nil) - (vc-file-setprop file 'vc-checkout-time 0))) - (vc-resynch-buffer file t t)))) - (forward-line 1)))))) +(defun vc-cvs-dired-state-info (file) + "CVS-specific version of `vc-dired-state-info'." + (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)")))) -(defun vc-cvs-merge (file first-version &optional second-version) - "Merge changes into current working copy of FILE. -The changes are between FIRST-VERSION and SECOND-VERSION." - (vc-do-command nil 0 "cvs" file - "update" "-kk" - (concat "-j" first-version) - (concat "-j" second-version)) - (vc-file-setprop file 'vc-state 'edited) - (save-excursion - (set-buffer (get-buffer "*vc*")) - (goto-char (point-min)) - (if (re-search-forward "conflicts during merge" nil t) - 1 ; signal error - 0))) ; signal success -(defun vc-cvs-merge-news (file) - "Merge in any new changes made to FILE." - (message "Merging changes into %s..." file) - (save-excursion - ;; (vc-file-setprop file 'vc-workfile-version nil) - (vc-file-setprop file 'vc-checkout-time 0) - (vc-do-command nil 0 "cvs" file "update") - ;; Analyze the merge result reported by CVS, and set - ;; file properties accordingly. - (set-buffer (get-buffer "*vc*")) - (goto-char (point-min)) - ;; get new workfile version - (if (re-search-forward (concat "^Merging differences between " - "[01234567890.]* and " - "\\([01234567890.]*\\) into") - nil t) - (vc-file-setprop file 'vc-workfile-version (match-string 1)) - (vc-file-setprop file 'vc-workfile-version nil)) - ;; get file status - (prog1 - (if (re-search-forward - (concat "^\\([CMUP] \\)?" - (regexp-quote (file-name-nondirectory file)) - "\\( already contains the differences between \\)?") - nil t) - (cond - ;; Merge successful, we are in sync with repository now - ((or (match-string 2) - (string= (match-string 1) "U ") - (string= (match-string 1) "P ")) - (vc-file-setprop file 'vc-state 'up-to-date) - (vc-file-setprop file 'vc-checkout-time - (nth 5 (file-attributes file))) - 0);; indicate success to the caller - ;; Merge successful, but our own changes are still in the file - ((string= (match-string 1) "M ") - (vc-file-setprop file 'vc-state 'edited) - 0);; indicate success to the caller - ;; Conflicts detected! - (t - (vc-file-setprop file 'vc-state 'edited) - 1);; signal the error to the caller - ) - (pop-to-buffer "*vc*") - (error "Couldn't analyze cvs update result")) - (message "Merging changes into %s...done" file)))) +;;; +;;; State-changing functions +;;; -(defun vc-cvs-check-headers () - "Check if the current file has any headers in it." - (save-excursion - (goto-char (point-min)) - (re-search-forward "\\$[A-Za-z\300-\326\330-\366\370-\377]+\ -\\(: [\t -#%-\176\240-\377]*\\)?\\$" nil t))) +(defun vc-cvs-register (file &optional rev comment) + "Register FILE into the CVS version-control system. +COMMENT can be used to provide an initial description of FILE. -(defun vc-cvs-steal (file &optional rev) - "Steal the lock on the current workfile for FILE and revision REV. -Inappropriate for CVS" - (error "You cannot steal a CVS lock; there are no CVS locks to steal")) +`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) + (concat "-m" comment)) + (vc-switches 'CVS 'register))) -;; vc-check `not reached' for CVS. +(defun vc-cvs-responsible-p (file) + "Return non-nil if CVS thinks it is responsible for FILE." + (file-directory-p (expand-file-name "CVS" + (if (file-directory-p file) + file + (file-name-directory file))))) -(defun vc-cvs-revert (file) - "Revert FILE to the version it was based on." - ;; Check out via standard output (caused by the final argument - ;; FILE below), so that no sticky tag is set. - (vc-cvs-checkout file nil (vc-workfile-version file) file) - ;; If "cvs edit" was used to make the file writable, - ;; call "cvs unedit" now to undo that. - (if (not (eq (vc-cvs-checkout-model file) 'implicit)) - (vc-do-command nil 0 "cvs" file "unedit"))) - -(defun vc-cvs-diff (file &optional oldvers newvers) - "Get a difference report using CVS between two versions of FILE." - (let (options status - (diff-switches-list (if (listp diff-switches) - diff-switches - (list diff-switches)))) - (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. - (apply 'vc-do-command t - 'async "diff" file - (append diff-switches-list '("/dev/null")))) - (apply 'vc-do-command t - 'async "cvs" file "diff" - (and oldvers (concat "-r" oldvers)) - (and newvers (concat "-r" newvers)) - diff-switches-list)) - ;; We can't know yet, so we assume there'll be a difference - 1)) - -(defun vc-cvs-latest-on-branch-p (file) - "Return t iff current workfile version of FILE is the latest on its branch." - ;; Since this is only used as a sanity check for vc-cancel-version, - ;; and that is not supported under CVS at all, we can safely return t here. - ;; TODO: Think of getting rid of this altogether. - t) +(defun vc-cvs-could-register (file) + "Return non-nil if FILE could be registered in CVS. +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) - ;; explicit check-in to the trunk requires a double check-in (first - ;; unexplicit) (CVS-1.3) - (if (and rev (vc-trunk-p rev)) - (apply 'vc-do-command nil 1 "cvs" file - "ci" "-m" "intermediate" - switches)) - (setq status (apply 'vc-do-command nil 1 "cvs" file - "ci" (if rev (concat "-r" rev)) - (concat "-m" comment) - switches)) + (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)) @@ -543,48 +352,25 @@ Inappropriate for CVS" ;; tell it from the permissions of the file (see ;; vc-cvs-checkout-model). (vc-file-setprop file 'vc-checkout-model nil) - ;; if this was an explicit check-in, remove the sticky tag - (if rev (vc-do-command t 0 "cvs" file "update" "-A")))) - -(defun vc-cvs-responsible-p (file) - "Return non-nil if CVS thinks it is responsible for FILE." - (file-directory-p (expand-file-name "CVS" - (if (file-directory-p file) - file - (file-name-directory file))))) - -(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." - (vc-cvs-responsible-p file)) - -(defun vc-cvs-make-version-backups-p (file) - "Return non-nil if version backups should be made for FILE." - (vc-cvs-stay-local-p file)) - -(defun vc-cvs-register (file &optional rev comment) - "Register FILE into the CVS version-control system. -COMMENT can be used to provide an initial description of FILE. -`vc-register-switches' and `vc-cvs-register-switches' are passed to -the CVS command (in that order)." - (let ((switches (list - (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-do-command nil 0 "cvs" file - "add" - (and comment (string-match "[^\t\n ]" comment) - (concat "-m" comment)) - switches))) - -(defun vc-cvs-checkout (file &optional writable rev workfile) + ;; if this was an explicit check-in (does not include creation of + ;; a branch), remove the sticky tag. + (if (and rev (not (vc-cvs-valid-symbolic-tag-name-p rev))) + (vc-cvs-command nil 0 file "update" "-A")))) + +(defun vc-cvs-find-version (file rev buffer) + (apply 'vc-cvs-command + buffer 0 file + "-Q" ; suppress diagnostic output + "update" + (and rev (not (string= rev "")) + (concat "-r" rev)) + "-p" + (vc-switches 'CVS 'checkout))) + +(defun vc-cvs-checkout (file &optional editable rev workfile) "Retrieve a revision of FILE into a WORKFILE. -WRITABLE non-nil means that the file should be writable. +EDITABLE non-nil means that the file should be writable. REV is the revision to check out into WORKFILE." (let ((filename (or workfile file)) (file-buffer (get-file-buffer file)) @@ -593,9 +379,7 @@ REV is the revision to check out into 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. @@ -605,86 +389,577 @@ REV is the revision to check out into WORKFILE." ;; the file in the right place. (setq default-directory (file-name-directory filename)) (if workfile - (let ((failed t)) + (let ((failed t) + (backup-name (if (string= file workfile) + (car (find-backup-file-name filename))))) + (when backup-name + (copy-file filename backup-name + 'ok-if-already-exists 'keep-date) + (unless (file-writable-p filename) + (set-file-modes filename + (logior (file-modes filename) 128)))) (unwind-protect (progn (let ((coding-system-for-read 'no-conversion) (coding-system-for-write 'no-conversion)) (with-temp-file filename - (apply 'vc-do-command - (current-buffer) 0 "cvs" file + (apply 'vc-cvs-command + (current-buffer) 0 file "-Q" ; suppress diagnostic output "update" - (and rev (not (string= rev "")) + (and (stringp rev) + (not (string= rev "")) (concat "-r" rev)) "-p" switches))) (setq failed nil)) - (and failed (file-exists-p filename) (delete-file filename)))) + (if failed + (if backup-name + (rename-file backup-name filename + 'ok-if-already-exists) + (if (file-exists-p filename) + (delete-file filename))) + (and backup-name + (not vc-make-backup-files) + (delete-file backup-name))))) (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 writable (not (eq (vc-cvs-checkout-model file) 'implicit)) - (if vc-cvs-use-edit - (vc-do-command nil 0 "cvs" file "edit") - (set-file-modes file (logior (file-modes file) 128)) - (if file-buffer (toggle-read-only -1)))) - ;; Check out a particular version (or recreate the file). - (vc-file-setprop file 'vc-workfile-version nil) - (apply 'vc-do-command nil 0 "cvs" file - (and writable - (or (not (file-exists-p file)) - (not (eq (vc-cvs-checkout-model file) - '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) (string= rev "")) - "-A" - (concat "-r" rev)) - switches)))) + (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)) + (if file-buffer (toggle-read-only -1)))) + ;; Check out a particular version (or recreate the file). + (vc-file-setprop file 'vc-workfile-version nil) + (apply 'vc-cvs-command nil 0 file + (and editable + (or (not (file-exists-p file)) + (not (eq (vc-cvs-checkout-model file) + 'implicit))) + "-w") + "update" + (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-annotate-command (file buffer) - "Execute \"cvs annotate\" on FILE. -Use `call-process' and insert the contents in BUFFER." - (call-process "cvs" nil buffer nil "annotate" file)) - -(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.") - -(defun vc-cvs-annotate-difference (point) - "Return the difference between the time of the line and the current time. -Return values are as defined for `current-time'." - ;; We need a list of months and their corresponding numbers. - (if (looking-at "^\\S-+\\s-+\\S-+\\s-+\\([0-9]+\\)-\\(\\sw+\\)-\\([0-9]+\\)): ") - (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 - (- (car (current-time)) - (car (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. +(defun vc-cvs-delete-file (file) + (vc-cvs-command nil 0 file "remove" "-f")) + +(defun vc-cvs-revert (file &optional contents-done) + "Revert FILE to the version it was based on." + (unless contents-done + ;; Check out via standard output (caused by the final argument + ;; FILE below), so that no sticky tag is set. + (vc-cvs-checkout file nil (vc-workfile-version file) file)) + (unless (eq (vc-checkout-model file) 'implicit) + (if vc-cvs-use-edit + (vc-cvs-command nil 0 file "unedit") + ;; Make the file read-only by switching off all w-bits + (set-file-modes file (logand (file-modes file) 3950))))) + +(defun vc-cvs-merge (file first-version &optional second-version) + "Merge changes into current working copy of FILE. +The changes are between FIRST-VERSION and SECOND-VERSION." + (vc-cvs-command nil 0 file + "update" "-kk" + (concat "-j" first-version) + (concat "-j" second-version)) + (vc-file-setprop file 'vc-state 'edited) + (with-current-buffer (get-buffer "*vc*") + (goto-char (point-min)) + (if (re-search-forward "conflicts during merge" nil t) + 1 ; signal error + 0))) ; signal success + +(defun vc-cvs-merge-news (file) + "Merge in any new changes made to FILE." + (message "Merging changes into %s..." file) + ;; (vc-file-setprop file 'vc-workfile-version nil) + (vc-file-setprop file 'vc-checkout-time 0) + (vc-cvs-command nil 0 file "update") + ;; Analyze the merge result reported by CVS, and set + ;; file properties accordingly. + (with-current-buffer (get-buffer "*vc*") + (goto-char (point-min)) + ;; get new workfile version (if (re-search-forward - "^\\S-+\\s-+\\S-+\\s-+\\([0-9]+\\)-\\(\\sw+\\)-\\([0-9]+\\)): " nil t) + "^Merging differences between [0-9.]* and \\([0-9.]*\\) into" nil t) + (vc-file-setprop file 'vc-workfile-version (match-string 1)) + (vc-file-setprop file 'vc-workfile-version nil)) + ;; get file status + (prog1 + (if (eq (buffer-size) 0) + 0 ;; there were no news; indicate success + (if (re-search-forward + (concat "^\\([CMUP] \\)?" + (regexp-quote (file-name-nondirectory file)) + "\\( already contains the differences between \\)?") + nil t) + (cond + ;; Merge successful, we are in sync with repository now + ((or (match-string 2) + (string= (match-string 1) "U ") + (string= (match-string 1) "P ")) + (vc-file-setprop file 'vc-state 'up-to-date) + (vc-file-setprop file 'vc-checkout-time + (nth 5 (file-attributes file))) + 0);; indicate success to the caller + ;; Merge successful, but our own changes are still in the file + ((string= (match-string 1) "M ") + (vc-file-setprop file 'vc-state 'edited) + 0);; indicate success to the caller + ;; Conflicts detected! + (t + (vc-file-setprop file 'vc-state 'edited) + 1);; signal the error to the caller + ) + (pop-to-buffer "*vc*") + (error "Couldn't analyze cvs update result"))) + (message "Merging changes into %s...done" file)))) + + +;;; +;;; History functions +;;; + +(defun vc-cvs-print-log (file &optional buffer) + "Get change log associated with FILE." + (vc-cvs-command + buffer + (if (and (vc-stay-local-p file) (fboundp 'start-process)) 'async 0) + file "log")) + +(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. + (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-stay-local-p dir) + ;; local diff: do it filewise, and only for files that are modified + (vc-file-tree-walk + dir + (lambda (f) + (vc-exec-after + `(let ((coding-system-for-read (vc-coding-system-for-diff ',f))) + ;; possible optimization: fetch the state of all files + ;; in the tree via vc-cvs-dir-state-heuristic + (unless (vc-up-to-date-p ',f) + (message "Looking at %s" ',f) + (vc-diff-internal ',f ',rev1 ',rev2)))))) + ;; cvs diff: use a single call for the entire tree + (let ((coding-system-for-read + (or coding-system-for-read 'undecided))) + (apply 'vc-cvs-command "*vc-diff*" 1 nil "diff" + (and rev1 (concat "-r" rev1)) + (and rev2 (concat "-r" rev2)) + (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))) + (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 +encoded as fractional days." + (vc-annotate-convert-time + (apply 'encode-time 0 0 0 (nthcdr 3 (decode-time (current-time)))))) + +(defun vc-cvs-annotate-time () + "Return the time of the next annotation (as fraction of days) +systime, or nil if there is none." + (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 +;;; + +(defun vc-cvs-create-snapshot (dir name branchp) + "Assign to DIR's current version a given NAME. +If BRANCHP is non-nil, the name is created as a branch (and the current +workspace is immediately moved to that new branch)." + (vc-cvs-command nil 0 dir "tag" "-c" (if branchp "-b") name) + (when branchp (vc-cvs-command nil 0 dir "update" "-r" name))) + +(defun vc-cvs-retrieve-snapshot (dir name update) + "Retrieve a snapshot at and below DIR. +NAME is the name of the snapshot; if it is empty, do a `cvs update'. +If UPDATE is non-nil, then update (resynch) any affected buffers." + (with-current-buffer (get-buffer-create "*vc*") + (let ((default-directory dir) + (sticky-tag)) + (erase-buffer) + (if (or (not name) (string= name "")) + (vc-cvs-command t 0 nil "update") + (vc-cvs-command t 0 nil "update" "-r" name) + (setq sticky-tag name)) + (when update + (goto-char (point-min)) + (while (not (eobp)) + (if (looking-at "\\([CMUP]\\) \\(.*\\)") + (let* ((file (expand-file-name (match-string 2) dir)) + (state (match-string 1)) + (buffer (find-buffer-visiting file))) + (when buffer + (cond + ((or (string= state "U") + (string= state "P")) + (vc-file-setprop file 'vc-state 'up-to-date) + (vc-file-setprop file 'vc-workfile-version nil) + (vc-file-setprop file 'vc-checkout-time + (nth 5 (file-attributes file)))) + ((or (string= state "M") + (string= state "C")) + (vc-file-setprop file 'vc-state 'edited) + (vc-file-setprop file 'vc-workfile-version nil) + (vc-file-setprop file 'vc-checkout-time 0))) + (vc-file-setprop file 'vc-cvs-sticky-tag sticky-tag) + (vc-resynch-buffer file t t)))) + (forward-line 1)))))) + + +;;; +;;; Miscellaneous +;;; + +(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 () + "Check if the current file has any headers in it." + (save-excursion + (goto-char (point-min)) + (re-search-forward "\\$[A-Za-z\300-\326\330-\366\370-\377]+\ +\\(: [\t -#%-\176\240-\377]*\\)?\\$" nil t))) + + +;;; +;;; Internal functions +;;; + +(defun vc-cvs-command (buffer okstatus file &rest flags) + "A wrapper around `vc-do-command' for use in vc-cvs.el. +The difference to vc-do-command is that this function always invokes `cvs', +and that it passes `vc-cvs-global-switches' to it before FLAGS." + (apply 'vc-do-command buffer okstatus "cvs" file + (if (stringp vc-cvs-global-switches) + (cons vc-cvs-global-switches flags) + (append vc-cvs-global-switches + flags)))) + +(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 +is converted to a normalized record with the following structure: + \(METHOD USER HOSTNAME CVS-ROOT). +The default METHOD for a CVS root of the form + /path/to/repository +is `local'. +The default METHOD for a CVS root of the form + [USER@]HOSTNAME:/path/to/repository +is `ext'. +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* ((root-list (cdr (split-string (concat "x:" root) ":"))) + (len (length root-list)) + ;; All syntactic varieties will get a proper METHOD. + (root-list + (cond + ((= len 0) + ;; Invalid CVS root + nil) + ((= len 1) + ;; Simple PATH => method `local' + (cons "local" + (cons nil root-list))) + ((= len 2) + ;; [USER@]HOST:PATH => method `ext' + (and (not (equal (car root-list) "")) + (cons "ext" root-list))) + ((= len 3) + ;; :METHOD:PATH + (cons (cadr root-list) + (cons nil (cddr root-list)))) + (t + ;; :METHOD:[USER@]HOST:PATH + (cdr root-list))))) + (if root-list + (let ((method (car root-list)) + (uhost (or (cadr root-list) "")) + (root (nth 2 root-list)) + user host) + ;; Split USER@HOST + (if (string-match "\\(.*\\)@\\(.*\\)" uhost) + (setq user (match-string 1 uhost) + host (match-string 2 uhost)) + (setq host uhost)) + ;; Remove empty HOST + (and (equal host "") + (setq host)) + ;; Fix windows style CVS root `:local:C:\\project\\cvs\\some\\dir' + (and host + (equal method "local") + (setq root (concat host ":" root) host)) + ;; Normalize CVS root record + (list method user host root))))) + +(defun vc-cvs-parse-status (&optional full) + "Parse output of \"cvs status\" command in the current buffer. +Set file properties accordingly. Unless FULL is t, parse only +essential information." + (let (file status) + (goto-char (point-min)) + (if (re-search-forward "^File: " nil t) + (cond + ((looking-at "no file") nil) + ((re-search-forward "\\=\\([^ \t]+\\)" nil t) + (setq file (expand-file-name (match-string 1))) + (vc-file-setprop file 'vc-backend 'CVS) + (if (not (re-search-forward "\\=[ \t]+Status: \\(.*\\)" nil t)) + (setq status "Unknown") + (setq status (match-string 1))) + (if (and full + (re-search-forward + "\\(RCS Version\\|RCS Revision\\|Repository revision\\):\ +\[\t ]+\\([0-9.]+\\)" + nil t)) + (vc-file-setprop file 'vc-latest-version (match-string 2))) + (vc-file-setprop + file 'vc-state + (cond + ((string-match "Up-to-date" status) + (vc-file-setprop file 'vc-checkout-time + (nth 5 (file-attributes file))) + 'up-to-date) + ((string-match "Locally Modified" status) 'edited) + ((string-match "Needs Merge" status) 'needs-merge) + ((string-match "Needs \\(Checkout\\|Patch\\)" status) 'needs-patch) + (t 'edited)))))))) + +(defun vc-cvs-dir-state-heuristic (dir) + "Find the CVS state of all files in DIR, using only local information." + (with-temp-buffer + (vc-cvs-get-entries dir) + (goto-char (point-min)) + (while (not (eobp)) + ;; CVS-removed files are not taken under VC control. + (when (looking-at "/\\([^/]*\\)/[^/-]") + (let ((file (expand-file-name (match-string 1) dir))) + (unless (vc-file-getprop file 'vc-state) + (vc-cvs-parse-entry file t)))) + (forward-line 1)))) + +(defun vc-cvs-get-entries (dir) + "Insert the CVS/Entries file from below DIR into the current buffer. +This function ensures that the correct coding system is used for that, +which may not be the one that is used for the files' contents. +CVS/Entries should only be accessed through this function." + (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 + ;; an uppercase or lowercase letter and can contain uppercase and + ;; lowercase letters, digits, `-', and `_'. + (and (string-match "^[a-zA-Z]" tag) + (not (string-match "[^a-z0-9A-Z-_]" tag)))) + +(defun vc-cvs-valid-version-number-p (tag) + "Return non-nil if TAG is a valid version number." + (and (string-match "^[0-9]" tag) + (not (string-match "[^0-9.]" tag)))) + +(defun vc-cvs-parse-sticky-tag (match-type match-tag) + "Parse and return the sticky tag as a string. +`match-data' is protected." + (let ((data (match-data)) + (tag) + (type (cond ((string= match-type "D") 'date) + ((string= match-type "T") + (if (vc-cvs-valid-symbolic-tag-name-p match-tag) + 'symbolic-name + 'revision-number)) + (t nil)))) + (unwind-protect (progn - (beginning-of-line nil) - (vc-cvs-annotate-difference (point)))))) + (cond + ;; Sticky Date tag. Convert to a proper date value (`encode-time') + ((eq type 'date) + (string-match + "\\([0-9]+\\)\\.\\([0-9]+\\)\\.\\([0-9]+\\)\\.\\([0-9]+\\)\\.\\([0-9]+\\)\\.\\([0-9]+\\)" + match-tag) + (let* ((year-tmp (string-to-number (match-string 1 match-tag))) + (month (string-to-number (match-string 2 match-tag))) + (day (string-to-number (match-string 3 match-tag))) + (hour (string-to-number (match-string 4 match-tag))) + (min (string-to-number (match-string 5 match-tag))) + (sec (string-to-number (match-string 6 match-tag))) + ;; 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))) + (setq tag (encode-time sec min hour day month year)))) + ;; Sticky Tag name or revision number + ((eq type 'symbolic-name) (setq tag match-tag)) + ((eq type 'revision-number) (setq tag match-tag)) + ;; Default is no sticky tag at all + (t nil)) + (cond ((eq vc-cvs-sticky-tag-display nil) nil) + ((eq vc-cvs-sticky-tag-display t) + (cond ((eq type 'date) (format-time-string + vc-cvs-sticky-date-format-string + tag)) + ((eq type 'symbolic-name) tag) + ((eq type 'revision-number) tag) + (t nil))) + ((functionp vc-cvs-sticky-tag-display) + (funcall vc-cvs-sticky-tag-display tag type)) + (t nil))) + + (set-match-data data)))) + +(defun vc-cvs-parse-entry (file &optional set-state) + "Parse a line from CVS/Entries. +Compare modification time to that of the FILE, set file properties +accordingly. However, `vc-state' is set only if optional arg SET-STATE +is non-nil." + (cond + ;; entry for a "locally added" file (not yet committed) + ((looking-at "/[^/]+/0/") + (vc-file-setprop file 'vc-checkout-time 0) + (vc-file-setprop file 'vc-workfile-version "0") + (if set-state (vc-file-setprop file 'vc-state 'edited))) + ;; normal entry + ((looking-at + (concat "/[^/]+" + ;; revision + "/\\([^/]*\\)" + ;; timestamp and optional conflict field + "/\\([^/]*\\)/" + ;; options + "\\([^/]*\\)/" + ;; sticky tag + "\\(.\\|\\)" ;Sticky tag type (date or tag name, could be empty) + "\\(.*\\)")) ;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. + ;; 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