(defvar vc-suppress-confirm nil
"*If non-nil, treat user as expert; suppress yes-no prompts on some things.")
(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-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
+to the checkout program by \\[vc-checkout].")
(defvar vc-directory-exclusion-list '("SCCS" "RCS" "CVS")
- "*Directory names ignored by functions that recursively walk file trees.")
+ "*A list of directory names ignored by functions that recursively
+walk file trees.")
(defconst vc-maximum-comment-ring-size 32
"Maximum number of saved comments in the comment ring.")
(defvar vc-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"))
If nil, VC itself computes this value when it is first needed.")
(defvar vc-cvs-release nil
- "*The release number of your SCCS installation, as a string.
+ "*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.
(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-workfile-version nil)
(vc-file-setprop file 'vc-master-locks nil))
(progn
(vc-file-setprop file 'vc-cvs-status nil))))
(kill-buffer (get-buffer "*vc-info*")))
(string= tip-version workfile-version))))
;; CVS
- (or (string= (vc-workfile-version file) "0") ;; added but not committed.
- (string= (vc-workfile-version file) (vc-latest-version file)))))
+ t))
(defun vc-registration-error (file)
(if file
(interactive "P")
(widen)
(let ((context (vc-buffer-context)))
- (revert-buffer arg no-confirm)
+ ;; 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)))
;;; If comment is specified, it will be used as an admin or checkin comment.
(let ((vc-file (vc-name file))
(vc-type (vc-backend file))
- owner version)
+ owner version buffer)
(cond
;; if there is no master file corresponding, create one
((and (eq vc-type 'CVS)
(or (eq (vc-cvs-status file) 'needs-checkout)
(eq (vc-cvs-status file) 'needs-merge)))
- (vc-buffer-sync)
- (if (yes-or-no-p (format "%s is not up-to-date. Merge in changes now? "
- (buffer-name)))
+ (if (or vc-dired-mode
+ (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
- "Buffer %s modified; merge file on disc anyhow? "
- (buffer-name))))
+ (format
+ "Buffer %s modified; merge file on disc anyhow? "
+ (buffer-name buffer)))))
(error "Merge aborted"))
(if (not (zerop (vc-backend-merge-news file)))
;; Overlaps detected - what now? Should use some
;; 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))))
;; if there is no lock on the file, assert one and get it
(progn (vc-backend-steal file)
(vc-mode-line file))
(if (not (yes-or-no-p "Revert to checked-in version, instead? "))
- (error "Checkout aborted.")
+ (error "Checkout aborted")
(vc-revert-buffer1 t t)
(vc-checkout-writable-buffer file))
)
(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."))
+ (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
(vc-checkout-writable-buffer file)
(if (yes-or-no-p "Lock the latest version instead? ")
(vc-checkout-writable-buffer file
- (vc-branch-part (vc-workfile-version file))))))
+ (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
(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))
+ (error "File is locked by %s" owner))
(vc-steal-lock
file
(if verbose (read-string "Version to steal: ")
;; Do a vc-next-action-on-file on all the marked files, possibly
;; passing on the log comment we've just entered.
(let ((configuration (current-window-configuration))
- (dired-buffer (current-buffer)))
+ (dired-buffer (current-buffer))
+ (dired-dir default-directory))
(dired-map-over-marks
(let ((file (dired-get-filename)) p)
(message "Processing %s..." file)
+ ;; Adjust the default directory so that checkouts
+ ;; go to the right place.
+ (setq default-directory (file-name-directory file))
(vc-next-action-on-file file nil comment)
(set-buffer dired-buffer)
+ (setq default-directory dired-dir)
(vc-dired-update-line file)
(set-window-configuration configuration)
(message "Processing %s...done" file))
(catch 'nogo
(if vc-dired-mode
(let ((files (dired-get-marked-files)))
- (if (= (length files) 1)
- (find-file-other-window (car files))
- (if (string= ""
- (mapconcat
+ (if (string= ""
+ (mapconcat
(function (lambda (f)
(if (eq (vc-backend f) 'CVS)
- (if (eq (vc-cvs-status f) 'locally-modified)
+ (if (or (eq (vc-cvs-status f) 'locally-modified)
+ (eq (vc-cvs-status f) 'locally-added))
"@" "")
(if (vc-locking-user f) "@" ""))))
files ""))
(vc-start-entry nil nil nil
"Enter a change comment for the marked files."
'vc-next-action-dired))
- (throw 'nogo nil))))
+ (throw 'nogo nil)))
(while vc-parent-buffer
(pop-to-buffer vc-parent-buffer))
(if buffer-file-name
(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
;; 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-diff*")
+ (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))))
(set-buffer (get-buffer-create "*vc-diff*"))
(cd file)
(vc-file-tree-walk
+ default-directory
(function (lambda (f)
(message "Looking at %s" f)
(and
(replace-match "$\\1$"))
(vc-restore-buffer-context context)))
-;; The VC directory submode. Coopt Dired for this.
+;; The VC directory major mode. Coopt Dired for this.
;; All VC commands get mapped into logical equivalents.
-(defvar vc-dired-prefix-map (make-sparse-keymap))
-(define-key vc-dired-prefix-map "\C-xv" vc-prefix-map)
-(define-key vc-dired-prefix-map "g" 'vc-directory)
-(define-key vc-dired-prefix-map "=" 'vc-diff)
-
-(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.
+(define-derived-mode vc-dired-mode dired-mode "Dired under VC"
+ "The major mode used in VC directory buffers. It is derived from Dired.
All Dired commands operate normally. Users currently locking listed files
are listed in place of the file's owner and group.
Keystrokes bound to VC commands will execute as though they had been called
on a buffer attached to the file named in the current Dired buffer line."
- (setq vc-dired-mode t)
- (setq vc-mode " under VC"))
+ (setq vc-dired-mode t))
+
+(define-key vc-dired-mode-map "\C-xv" vc-prefix-map)
+(define-key vc-dired-mode-map "g" 'vc-dired-update)
+(define-key vc-dired-mode-map "=" 'vc-diff)
(defun vc-dired-state-info (file)
;; Return the string that indicates the version control status
;; (insert (concat x "\t")))
;;
;; This code, like dired, assumes UNIX -l format.
- (cond
- ((re-search-forward
- "\\([drwx-]+ \\) *[0-9]+ \\([^ ]+\\) +[0-9]+\\( .*\\)"
- nil 0)
- (if (numberp x) (setq x (match-string 2)))
+ (let ((pos (point)) limit perm owner date-and-file)
+ (end-of-line)
+ (setq limit (point))
+ (goto-char pos)
+ (cond
+ ((or
+ (re-search-forward ;; owner and group
+"\\([drwxlts-]+ \\) *[0-9]+ \\([^ ]+\\) +[^ ]+ +[0-9]+\\( [^ 0-9]+ [0-9 ][0-9] .*\\)"
+ limit t)
+ (re-search-forward ;; only owner displayed
+"\\([drwxlts-]+ \\) *[0-9]+ \\([^ ]+\\) +[0-9]+\\( [^ 0-9]+ [0-9 ][0-9] .*\\)"
+ limit t))
+ (setq perm (match-string 1)
+ owner (match-string 2)
+ date-and-file (match-string 3)))
+ ((re-search-forward ;; OS/2 -l format, no links, owner, group
+"\\([drwxlts-]+ \\) *[0-9]+\\( [^ 0-9]+ [0-9 ][0-9] .*\\)"
+ limit t)
+ (setq perm (match-string 1)
+ date-and-file (match-string 2))))
+ (if (numberp x) (setq x (or owner (number-to-string x))))
(if x (setq x (concat "(" x ")")))
(let ((rep (substring (concat x " ") 0 10)))
- (replace-match (concat "\\1" rep "\\3"))))))
-
+ (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.
- (dired-do-redisplay 1)
- (dired-previous-line 1)
+ ;; that point is already on this line. Don't use dired-do-redisplay
+ ;; for this, because it cannot handle the way vc-dired deals with
+ ;; subdirectories.
(beginning-of-line)
+ (forward-char 2)
+ (let ((start (point)))
+ (forward-line 1)
+ (beginning-of-line)
+ (delete-region start (point))
+ (insert-directory file dired-listing-switches)
+ (forward-line -1)
+ (end-of-line)
+ (delete-char (- (length file)))
+ (insert (substring file (length (expand-file-name default-directory))))
+ (goto-char start))
(vc-dired-reformat-line (vc-dired-state-info file)))
+(defun vc-dired-update (verbose)
+ (interactive "P")
+ (vc-directory default-directory verbose))
+
;;; Note in Emacs 18 the following defun gets overridden
;;; with the symbol 'vc-directory-18. See below.
;;;###autoload
-(defun vc-directory (verbose)
+(defun vc-directory (dirname verbose)
"Show version-control status of the current directory and subdirectories.
Normally it creates a Dired buffer that lists only the locked files
in all these directories. With a prefix argument, it lists all files."
- (interactive "P")
+ (interactive "DDired under VC (directory): \nP")
+ (require 'dired)
+ (setq dirname (expand-file-name dirname))
+ ;; force a trailing slash
+ (if (not (eq (elt dirname (1- (length dirname))) ?/))
+ (setq dirname (concat dirname "/")))
(let (nonempty
- (dl (length (expand-file-name default-directory)))
+ (dl (length dirname))
(filelist nil) (statelist nil)
+ (old-dir default-directory)
dired-buf
dired-buf-mod-count)
(vc-file-tree-walk
+ dirname
(function
(lambda (f)
(if (vc-registered f)
(setq statelist (cons state statelist))))))))
(save-window-excursion
(save-excursion
- ;; First, kill any existing vc-dired buffers of this directory.
- ;; (Code much like dired-find-buffer-nocreate.)
- (let ((buffers (buffer-list))
- (dir (expand-file-name default-directory)))
- (while buffers
- (if (buffer-name (car buffers))
- (progn (set-buffer (car buffers))
- (if (and (eq major-mode 'dired-mode)
- (string= dir
- (expand-file-name default-directory))
- vc-dired-mode)
- (kill-buffer (car buffers)))))
- (setq buffers (cdr buffers)))
- ;; This uses a semi-documented feature of dired; giving a switch
- ;; argument forces the buffer to refresh each time.
- (dired
- (cons dir (nreverse filelist))
- dired-listing-switches)
- (setq dired-buf (current-buffer))
- (setq nonempty (not (eq 2 (count-lines (point-min)
- (point-max))))))))
+ ;; 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
- (switch-to-buffer dired-buf)
- (vc-dired-mode)
- ;; Make a few aesthetical modifications to the header
- (setq buffer-read-only nil)
- (goto-char (point-min))
- (insert "\n") ;; Insert a blank line
- (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)
- ;; Now plug the version information into the individual lines
+ ;; Plug the version information into the individual lines
(mapcar
(function
(lambda (x)
(nreverse statelist))
(setq buffer-read-only t)
(goto-char (point-min))
- (dired-next-line 3)
+ (dired-next-line 2)
)
- (kill-buffer dired-buf)
+ (dired-next-line 1)
+ (insert " ")
+ (setq buffer-read-only t)
(message "No files are currently %s under %s"
- (if verbose "registered" "locked") default-directory))
+ (if verbose "registered" "locked") dirname))
))
;; Emacs 18 version
(erase-buffer)
(cd dir)
(vc-file-tree-walk
+ default-directory
(function (lambda (f)
(if (vc-registered f)
(let ((user (vc-locking-user f)))
"%s %s\n"
(concat user) f))))))))
(setq nonempty (not (zerop (buffer-size)))))
+
(if nonempty
(progn
(pop-to-buffer "*vc-status*" t)
(let ((status nil))
(catch 'vc-locked-example
(vc-file-tree-walk
+ default-directory
(function (lambda (f)
(and (vc-registered f)
(if (vc-locking-user f) (throw 'vc-locked-example f)
(if (stringp result)
(error "File %s is locked" result)
(vc-file-tree-walk
+ default-directory
(function (lambda (f) (and
(vc-name f)
(vc-backend-assign-name f name)))))
(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
(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
- (not (yes-or-no-p "Discard changes? "))))
+ (if (and changed (not (yes-or-no-p "Discard changes? ")))
(progn
(if (and (window-dedicated-p (selected-window))
(one-window-p t 'selected-frame))
(while vc-parent-buffer
(pop-to-buffer vc-parent-buffer))
(cond
- ((eq (vc-backend (buffer-file-name)) 'CVS)
+ ((not (vc-registered (buffer-file-name)))
+ (vc-registration-error (buffer-file-name))
+ (eq (vc-backend (buffer-file-name)) 'CVS)
(error "Unchecking files under CVS is dangerous and not supported in VC"))
((vc-locking-user (buffer-file-name))
- (error "This version is locked. Use vc-revert-buffer to discard changes."))
+ (error "This version is locked; use vc-revert-buffer to discard changes"))
((not (vc-latest-on-branch-p (buffer-file-name)))
- (error "This is not the latest version. VC cannot cancel it.")))
- (let ((target (vc-workfile-version (buffer-file-name))))
- (if (null (yes-or-no-p "Remove this version from master? "))
+ (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 (not norevert)
- (vc-checkout (buffer-file-name) nil)
- ;; If norevert, lock the most recent remaining version,
- ;; and mark the buffer modified.
- (if (eq (vc-backend (buffer-file-name)) 'RCS)
- (progn (setq buffer-read-only nil)
- (vc-clear-headers)))
- (vc-backend-checkout (buffer-file-name) t (vc-branch-part target))
- (set-visited-file-name (buffer-file-name))
- (vc-mode-line (buffer-file-name)))
- (message "Version %s has been removed from the master." target)
+ ;; Check out the most recent remaining version. If it fails, because
+ ;; the whole branch got deleted, do a double-take and check out the
+ ;; version where the branch started.
+ (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))
+ (error (set-buffer "*vc*")
+ (goto-char (point-min))
+ (if (re-search-forward "no side branches present for" nil t)
+ (progn (setq recent (vc-branch-part recent))
+ (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
;; implemented things might change for the better. This is unlikely to occur
;; until CVS 2.0 is released. --ceder 1994-01-23 21:27:51
(if (eq (vc-backend old) 'CVS)
- (error "Renaming files under CVS is dangerous and not supported in VC."))
+ (error "Renaming files under CVS is dangerous and not supported in VC"))
(let ((oldbuf (get-file-buffer old)))
(if (and oldbuf (buffer-modified-p oldbuf))
(error "Please save files before moving them"))
;; Retrieve a copy of a saved version into a workfile
(let ((filename (or workfile file))
(file-buffer (get-file-buffer file))
- (old-default-dir default-directory))
+ (old-default-dir default-directory)
+ 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.
(if file-buffer (set-buffer file-buffer))
+ (setq switches (if (stringp vc-checkout-switches)
+ (list vc-checkout-switches)
+ vc-checkout-switches))
;; Adjust the default-directory so that the check-out creates
;; the file in the right place. The old value is restored below.
(setq default-directory (file-name-directory filename))
(vc-backend-dispatch file
- (if workfile;; SCCS
- ;; Some SCCS implementations allow checking out directly to a
- ;; file using the -G option, but then some don't so use the
- ;; least common denominator approach and use the -p option
- ;; ala RCS.
- (let ((vc-modes (logior (file-modes (vc-name file))
- (if writable 128 0)))
- (failed t))
- (unwind-protect
- (progn
- (apply 'vc-do-command
- nil 0 "/bin/sh" file 'MASTER "-c"
- ;; Some shells make the "" dummy argument into $0
- ;; while others use the shell's name as $0 and
- ;; use the "" as $1. The if-statement
- ;; converts the latter case to the former.
- (format "if [ x\"$1\" = x ]; then shift; fi; \
+ (progn ;; SCCS
+ (and rev (string= rev "") (setq rev nil))
+ (if workfile
+ ;; Some SCCS implementations allow checking out directly to a
+ ;; file using the -G option, but then some don't so use the
+ ;; least common denominator approach and use the -p option
+ ;; ala RCS.
+ (let ((vc-modes (logior (file-modes (vc-name file))
+ (if writable 128 0)))
+ (failed t))
+ (unwind-protect
+ (progn
+ (apply 'vc-do-command
+ nil 0 "/bin/sh" file 'MASTER "-c"
+ ;; Some shells make the "" dummy argument into $0
+ ;; while others use the shell's name as $0 and
+ ;; use the "" as $1. The if-statement
+ ;; converts the latter case to the former.
+ (format "if [ x\"$1\" = x ]; then shift; fi; \
umask %o; exec >\"$1\" || exit; \
shift; umask %o; exec get \"$@\""
(logand 511 (lognot vc-modes))
(logand 511 (lognot (default-file-modes))))
- "" ; dummy argument for shell's $0
- filename
- (if writable "-e")
- "-p" (and rev
- (concat "-r" (vc-lookup-triple file rev)))
- vc-checkout-switches)
- (setq failed nil))
- (and failed (file-exists-p filename) (delete-file filename))))
- (apply 'vc-do-command nil 0 "get" file 'MASTER ;; SCCS
- (if writable "-e")
- (and rev (concat "-r" (vc-lookup-triple file rev)))
- vc-checkout-switches)
- (vc-file-setprop file 'vc-workfile-version nil))
- (if workfile ;; RCS
+ "" ; dummy argument for shell's $0
+ filename
+ (if writable "-e")
+ "-p"
+ (and rev
+ (concat "-r" (vc-lookup-triple file rev)))
+ switches)
+ (setq failed nil))
+ (and failed (file-exists-p filename)
+ (delete-file filename))))
+ (apply 'vc-do-command nil 0 "get" file 'MASTER ;; SCCS
+ (if writable "-e")
+ (and rev (concat "-r" (vc-lookup-triple file rev)))
+ switches)
+ (vc-file-setprop file 'vc-workfile-version nil)))
+ (if workfile ;; RCS
;; RCS doesn't let us check out into arbitrary file names directly.
;; Use `co -p' and make stdout point to the correct file.
(let ((vc-modes (logior (file-modes (vc-name file))
filename
(if writable "-l")
(concat "-p" rev)
- vc-checkout-switches)
+ switches)
(setq failed nil))
(and failed (file-exists-p filename) (delete-file filename))))
- (let (new-version)
- ;; if we should go to the head of the trunk,
- ;; clear the default branch first
- (and rev (string= rev "")
- (vc-do-command nil 0 "rcs" file 'MASTER "-b"))
- ;; now do the checkout
- (apply 'vc-do-command
- nil 0 "co" file 'MASTER
- ;; If locking is not strict, force to overwrite
- ;; the writable workfile.
- (if (eq (vc-checkout-model file) 'implicit) "-f")
- (if writable "-l")
- (if rev (concat "-r" rev)
- ;; if no explicit revision was specified,
- ;; check out that of the working file
- (let ((workrev (vc-workfile-version file)))
- (if workrev (concat "-r" workrev)
- nil)))
- vc-checkout-switches)
- ;; determine the new workfile version
- (save-excursion
- (set-buffer "*vc*")
- (goto-char (point-min))
- (setq new-version
- (if (re-search-forward "^revision \\([0-9.]+\\).*\n" nil t)
- (buffer-substring (match-beginning 1) (match-end 1)))))
- (vc-file-setprop file 'vc-workfile-version new-version)
- ;; if necessary, adjust the default branch
- (and rev (not (string= rev ""))
- (vc-do-command nil 0 "rcs" file 'MASTER
- (concat "-b" (if (vc-latest-on-branch-p file)
- (if (vc-trunk-p new-version) nil
- (vc-branch-part new-version))
- new-version))))))
+ (let (new-version)
+ ;; if we should go to the head of the trunk,
+ ;; clear the default branch first
+ (and rev (string= rev "")
+ (vc-do-command nil 0 "rcs" file 'MASTER "-b"))
+ ;; now do the checkout
+ (apply 'vc-do-command
+ nil 0 "co" file 'MASTER
+ ;; If locking is not strict, force to overwrite
+ ;; the writable workfile.
+ (if (eq (vc-checkout-model file) 'implicit) "-f")
+ (if writable "-l")
+ (if rev (concat "-r" rev)
+ ;; if no explicit revision was specified,
+ ;; check out that of the working file
+ (let ((workrev (vc-workfile-version file)))
+ (if workrev (concat "-r" workrev)
+ nil)))
+ switches)
+ ;; determine the new workfile version
+ (save-excursion
+ (set-buffer "*vc*")
+ (goto-char (point-min))
+ (setq new-version
+ (if (re-search-forward "^revision \\([0-9.]+\\).*\n" nil t)
+ (buffer-substring (match-beginning 1) (match-end 1)))))
+ (vc-file-setprop file 'vc-workfile-version new-version)
+ ;; if necessary, adjust the default branch
+ (and rev (not (string= rev ""))
+ (vc-do-command nil 0 "rcs" file 'MASTER
+ (concat "-b" (if (vc-latest-on-branch-p file)
+ (if (vc-trunk-p new-version) nil
+ (vc-branch-part new-version))
+ new-version))))))
(if workfile ;; CVS
;; CVS is much like RCS
(let ((failed t))
workfile
(concat "-r" rev)
"-p"
- vc-checkout-switches)
+ 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 go to the head of the trunk
+ ;; 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.
"update"
(and rev (not (string= rev ""))
(concat "-r" rev))
- vc-checkout-switches)
+ switches)
;; If no revision was specified, simply make the file writable.
(and writable
(or (eq (vc-checkout-model file) 'manual)
(save-excursion
;; Change buffers to get local value of vc-checkin-switches.
(set-buffer (or (get-file-buffer file) (current-buffer)))
- ;; Clear the master-properties. Do that here, not at the
- ;; end, because if the check-in fails we want them to get
- ;; re-computed before the next try.
- (vc-file-clear-masterprops file)
- (vc-backend-dispatch file
- ;; SCCS
- (progn
- (apply 'vc-do-command nil 0 "delta" file 'MASTER
- (if rev (concat "-r" rev))
- (concat "-y" comment)
- vc-checkin-switches)
- (vc-file-setprop file 'vc-locking-user 'none)
- (vc-file-setprop file 'vc-workfile-version nil)
- (if vc-keep-workfiles
- (vc-do-command nil 0 "get" file 'MASTER))
- )
- ;; RCS
- (let ((old-version (vc-workfile-version file)) new-version)
- (apply 'vc-do-command nil 0 "ci" file 'MASTER
- ;; if available, use the secure check-in option
- (and (vc-backend-release-p 'RCS "5.6.4") "-j")
- (concat (if vc-keep-workfiles "-u" "-r") rev)
- (concat "-m" comment)
- vc-checkin-switches)
- (vc-file-setprop file 'vc-locking-user 'none)
- (vc-file-setprop file 'vc-workfile-version nil)
-
- ;; determine the new workfile version
- (set-buffer "*vc*")
- (goto-char (point-min))
- (if (or (re-search-forward
- "new revision: \\([0-9.]+\\);" nil t)
- (re-search-forward
- "reverting to previous revision \\([0-9.]+\\)" nil t))
- (progn (setq new-version (buffer-substring (match-beginning 1)
- (match-end 1)))
- (vc-file-setprop file 'vc-workfile-version new-version)))
-
- ;; if we got to a different branch, adjust the default
- ;; branch accordingly
- (cond
- ((and old-version new-version
- (not (string= (vc-branch-part old-version)
- (vc-branch-part new-version))))
- (vc-do-command nil 0 "rcs" file 'MASTER
- (if (vc-trunk-p new-version) "-b"
- (concat "-b" (vc-branch-part new-version))))
- ;; If this is an old RCS release, we might have
- ;; to remove a remaining lock.
- (if (not (vc-backend-release-p 'RCS "5.6.2"))
- ;; exit status of 1 is also accepted.
- ;; It means that the lock was removed before.
- (vc-do-command nil 1 "rcs" file 'MASTER
- (concat "-u" old-version))))))
- ;; CVS
- (progn
- ;; explicit check-in to the trunk requires a
- ;; double check-in (first unexplicit) (CVS-1.3)
- (condition-case nil
- (progn
- (if (and rev (vc-trunk-p rev))
- (apply 'vc-do-command nil 0 "cvs" file 'WORKFILE
- "ci" "-m" "intermediate"
- vc-checkin-switches))
- (apply 'vc-do-command nil 0 "cvs" file 'WORKFILE
- "ci" (if rev (concat "-r" rev))
- (concat "-m" comment)
- vc-checkin-switches))
- (error (if (eq (vc-cvs-status file) 'needs-merge)
- ;; The CVS output will be on top of this message.
- (error "Type C-x 0 C-x C-q to merge in changes.")
- (error "Check in FAILED."))))
- ;; determine and store the new workfile version
- (set-buffer "*vc*")
- (goto-char (point-min))
- (if (re-search-forward
- "^\\(new\\|initial\\) revision: \\([0-9.]+\\)" nil t)
- (vc-file-setprop file 'vc-workfile-version
- (buffer-substring (match-beginning 2)
- (match-end 2)))
- (vc-file-setprop file 'vc-workfile-version nil))
- ;; if this was an explicit check-in, remove the sticky tag
- (if rev
- (vc-do-command nil 0 "cvs" file 'WORKFILE "update" "-A"))
- (vc-file-setprop file 'vc-locking-user 'none)
- (vc-file-setprop file 'vc-checkout-time
- (nth 5 (file-attributes file))))))
+ (let ((switches
+ (if (stringp vc-checkin-switches)
+ (list vc-checkin-switches)
+ vc-checkin-switches)))
+ ;; Clear the master-properties. Do that here, not at the
+ ;; end, because if the check-in fails we want them to get
+ ;; re-computed before the next try.
+ (vc-file-clear-masterprops file)
+ (vc-backend-dispatch file
+ ;; SCCS
+ (progn
+ (apply 'vc-do-command nil 0 "delta" file 'MASTER
+ (if rev (concat "-r" rev))
+ (concat "-y" comment)
+ switches)
+ (vc-file-setprop file 'vc-locking-user 'none)
+ (vc-file-setprop file 'vc-workfile-version nil)
+ (if vc-keep-workfiles
+ (vc-do-command nil 0 "get" file 'MASTER))
+ )
+ ;; RCS
+ (let ((old-version (vc-workfile-version file)) new-version)
+ (apply 'vc-do-command nil 0 "ci" file 'MASTER
+ ;; if available, use the secure check-in option
+ (and (vc-backend-release-p 'RCS "5.6.4") "-j")
+ (concat (if vc-keep-workfiles "-u" "-r") rev)
+ (concat "-m" comment)
+ switches)
+ (vc-file-setprop file 'vc-locking-user 'none)
+ (vc-file-setprop file 'vc-workfile-version nil)
+
+ ;; determine the new workfile version
+ (set-buffer "*vc*")
+ (goto-char (point-min))
+ (if (or (re-search-forward
+ "new revision: \\([0-9.]+\\);" nil t)
+ (re-search-forward
+ "reverting to previous revision \\([0-9.]+\\)" nil t))
+ (progn (setq new-version (buffer-substring (match-beginning 1)
+ (match-end 1)))
+ (vc-file-setprop file 'vc-workfile-version new-version)))
+
+ ;; if we got to a different branch, adjust the default
+ ;; branch accordingly
+ (cond
+ ((and old-version new-version
+ (not (string= (vc-branch-part old-version)
+ (vc-branch-part new-version))))
+ (vc-do-command nil 0 "rcs" file 'MASTER
+ (if (vc-trunk-p new-version) "-b"
+ (concat "-b" (vc-branch-part new-version))))
+ ;; If this is an old RCS release, we might have
+ ;; to remove a remaining lock.
+ (if (not (vc-backend-release-p 'RCS "5.6.2"))
+ ;; exit status of 1 is also accepted.
+ ;; It means that the lock was removed before.
+ (vc-do-command nil 1 "rcs" file 'MASTER
+ (concat "-u" old-version))))))
+ ;; CVS
+ (progn
+ ;; explicit check-in to the trunk requires a
+ ;; double check-in (first unexplicit) (CVS-1.3)
+ (condition-case nil
+ (progn
+ (if (and rev (vc-trunk-p rev))
+ (apply 'vc-do-command nil 0 "cvs" file 'WORKFILE
+ "ci" "-m" "intermediate"
+ 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)
)
(vc-do-command nil 0 "rcs" file 'MASTER ;RCS
"-M" (concat "-u" rev) (concat "-l" rev))
- (error "You cannot steal a CVS lock; there are no CVS locks to steal.") ;CVS
+ (error "You cannot steal a CVS lock; there are no CVS locks to steal") ;CVS
)
(vc-file-setprop file 'vc-locking-user (user-login-name))
(message "Stealing lock on %s...done" file)
(setq oldvers (vc-lookup-triple file oldvers))
(setq newvers (vc-lookup-triple file newvers)))
((eq backend 'RCS)
- (if (not oldvers) (setq oldvers (vc-workfile-version file)))))
+ (if (not oldvers) (setq oldvers (vc-workfile-version file)))
+ ;; If we know that --brief is not supported, don't try it.
+ (setq cmp (and cmp (not (eq vc-rcsdiff-knows-brief 'no))))))
;; SCCS and RCS shares a lot of code.
(cond
((or (eq backend 'SCCS) (eq backend 'RCS))
- (let* ((command (if (eq backend 'SCCS)
- "vcdiff"
- "rcsdiff"))
+ (let* ((command (if (eq backend 'SCCS) "vcdiff" "rcsdiff"))
(mode (if (eq backend 'RCS) 'WORKFILE 'MASTER))
(options (append (list (and cmp "--brief")
"-q"
(list diff-switches)))))
(status (apply 'vc-do-command "*vc-diff*" 2
command file mode options)))
- ;; Some RCS versions don't understand "--brief"; work around this.
+ ;; If --brief didn't work, do a double-take and remember it
+ ;; for the future.
(if (eq status 2)
- (apply 'vc-do-command "*vc-diff*" 1 command file 'WORKFILE
- (if cmp (cdr options) options))
- status)))
+ (prog1
+ (apply 'vc-do-command "*vc-diff*" 1 command file 'WORKFILE
+ (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.
((eq backend 'CVS)
(if (string= (vc-workfile-version file) "0") ;CVS
;;; These things should probably be generally available
-(defun vc-file-tree-walk (func &rest args)
- "Walk recursively through default directory.
+(defun vc-file-tree-walk (dirname func &rest args)
+ "Walk recursively through DIRNAME.
Invoke FUNC f ARGS on each non-directory file f underneath it."
- (vc-file-tree-walk-internal (expand-file-name default-directory) func args)
- (message "Traversing directory %s...done" default-directory))
+ (vc-file-tree-walk-internal (expand-file-name dirname) func args)
+ (message "Traversing directory %s...done" dirname))
(defun vc-file-tree-walk-internal (file func args)
(if (not (file-directory-p file))