;;; vc.el --- drive a version-control system from within Emacs
-;; Copyright (C) 1992,93,94,95,96,97,98,2000,01,2003,2004
-;; Free Software Foundation, Inc.
+;; Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 2000,
+;; 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
;; Author: FSF (see below for full credits)
;; Maintainer: Andre Spiegel <spiegel@gnu.org>
;; Keywords: tools
-;; $Id: vc.el,v 1.375 2004/04/11 15:05:18 spiegel Exp $
+;; $Id$
;; This file is part of GNU Emacs.
;; You should have received a copy of the GNU General Public License
;; along with GNU Emacs; see the file COPYING. If not, write to the
-;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
-;; Boston, MA 02111-1307, USA.
+;; Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+;; Boston, MA 02110-1301, USA.
;;; Credits:
;; This mode is fully documented in the Emacs user's manual.
;;
-;; Supported version-control systems presently include SCCS, RCS, and CVS.
+;; Supported version-control systems presently include CVS, RCS, GNU Arch,
+;; Subversion, Meta-CVS, and SCCS (or its free replacement, CSSC).
;;
;; Some features will not work with old RCS versions. Where
;; appropriate, VC finds out which version you have, and allows or
;;
;; The vc code maintains some internal state in order to reduce expensive
;; version-control operations to a minimum. Some names are only computed
-;; once. If you perform version control operations with RCS/SCCS/CVS while
+;; once. If you perform version control operations with the backend while
;; vc's back is turned, or move/rename master files while vc is running,
;; vc may get seriously confused. Don't do these things!
;;
;; have such a brief-comparison feature, the default implementation of
;; this function can be used, which delegates to a full
;; vc-BACKEND-diff. (Note that vc-BACKEND-diff must not run
-;; asynchronously in this case.)
+;; asynchronously in this case, see variable `vc-disable-async-diff'.)
;;
;; - mode-line-string (file)
;;
;; vc-BACKEND-diff. The default implementation does an explicit tree
;; walk, calling vc-BACKEND-diff for each individual file.
;;
-;; - annotate-command (file buf rev)
+;; - annotate-command (file buf &optional rev)
;;
-;; If this function is provided, it should produce an annotated version
-;; of FILE in BUF, relative to version REV. This is currently only
-;; implemented for CVS, using the `cvs annotate' command.
+;; If this function is provided, it should produce an annotated display
+;; of FILE in BUF, relative to version REV. Annotation means each line
+;; of FILE displayed is prefixed with version information associated with
+;; its addition (deleted lines leave no history) and that the text of the
+;; file is fontified according to age.
;;
;; - annotate-time ()
;;
;; in the buffer. You can safely assume that point is placed at the
;; beginning of each line, starting at `point-min'. The buffer that
;; point is placed in is the Annotate output, as defined by the
-;; relevant backend.
+;; relevant backend. This function also affects how much of the line
+;; is fontified; where it leaves point is where fontification begins.
;;
;; - annotate-current-time ()
;;
;;
;; Return the hostname that the backend will have to contact
;; in order to operate on a file in DIRNAME. If the return value
-;; is nil, it is means that the repository is local.
+;; is nil, it means that the repository is local.
;; This function is used in `vc-stay-local-p' which backends can use
;; for their convenience.
;;
:group 'vc
:version "21.1")
+(defcustom vc-allow-async-revert nil
+ "*Specifies whether the diff during \\[vc-revert-buffer] may be asynchronous.
+Enabling this option means that you can confirm a revert operation even
+if the local changes in the file have not been found and displayed yet."
+ :type '(choice (const :tag "No" nil)
+ (const :tag "Yes" t))
+ :group 'vc
+ :version "22.1")
+
;;;###autoload
(defcustom vc-checkout-hook nil
"*Normal hook (list of functions) run after checking out a file.
;; Annotate customization
(defcustom vc-annotate-color-map
- '(( 20. . "#FF0000")
- ( 40. . "#FF3800")
- ( 60. . "#FF7000")
- ( 80. . "#FFA800")
- (100. . "#FFE000")
- (120. . "#E7FF00")
- (140. . "#AFFF00")
- (160. . "#77FF00")
- (180. . "#3FFF00")
- (200. . "#07FF00")
- (220. . "#00FF31")
- (240. . "#00FF69")
- (260. . "#00FFA1")
- (280. . "#00FFD9")
- (300. . "#00EEFF")
- (320. . "#00B6FF")
- (340. . "#007EFF"))
+ '(( 20. . "#FFCC00")
+ ( 40. . "#FF6666")
+ ( 60. . "#FF6600")
+ ( 80. . "#FF3300")
+ (100. . "#FF00FF")
+ (120. . "#FF0000")
+ (140. . "#CCCC00")
+ (160. . "#CC00CC")
+ (180. . "#BC8F8F")
+ (200. . "#99CC00")
+ (220. . "#999900")
+ (240. . "#7AC5CD")
+ (260. . "#66CC00")
+ (280. . "#33CC33")
+ (300. . "#00CCFF")
+ (320. . "#00CC99")
+ (340. . "#0099FF"))
"*Association list of age versus color, for \\[vc-annotate].
Ages are given in units of fractional days. Default is eighteen steps
using a twenty day increment."
:type '(repeat number)
:group 'vc)
-;; vc-annotate functionality (CVS only).
-(defvar vc-annotate-mode nil
- "Variable indicating if VC-Annotate mode is active.")
-
(defvar vc-annotate-mode-map
(let ((m (make-sparse-keymap)))
(define-key m [menu-bar] (make-sparse-keymap "VC-Annotate"))
(defvar vc-parent-buffer-name nil)
(put 'vc-parent-buffer-name 'permanent-local t)
+(defvar vc-disable-async-diff nil
+ "VC sets this to t locally to disable some async diff operations.
+Backends that offer asynchronous diffs should respect this variable
+in their implementation of vc-BACKEND-diff.")
+
(defvar vc-log-file)
(defvar vc-log-version)
;; functions that operate on RCS revision numbers. This code should
;; also be moved into the backends. It stays for now, however, since
;; it is used in code below.
+;;;###autoload
(defun vc-trunk-p (rev)
"Return t if REV is a revision on the trunk."
(not (eq nil (string-match "\\`[0-9]+\\.[0-9]+\\'" rev))))
(mapconcat 'identity vc-path path-separator))
process-environment))
(w32-quote-process-args t))
+ (if (and (eq okstatus 'async) (file-remote-p default-directory))
+ ;; start-process does not support remote execution
+ (setq okstatus nil))
(if (eq okstatus 'async)
- (let ((proc (apply 'start-process command (current-buffer) command
- squeezed)))
+ (let ((proc
+ (let ((process-connection-type nil))
+ (apply 'start-process command (current-buffer) command
+ squeezed))))
(unless (active-minibuffer-window)
(message "Running %s in the background..." command))
;;(set-process-sentinel proc (lambda (p msg) (delete-process p)))
(vc-exec-after
`(unless (active-minibuffer-window)
(message "Running %s in the background... done" ',command))))
- (setq status (apply 'call-process command nil t nil squeezed))
+ (setq status (apply 'process-file command nil t nil squeezed))
(when (or (not (integerp status)) (and okstatus (< okstatus status)))
(pop-to-buffer (current-buffer))
(goto-char (point-min))
(vc-position-context (mark-marker))))
;; Make the right thing happen in transient-mark-mode.
(mark-active nil)
- ;; We may want to reparse the compilation buffer after revert
- (reparse (and (boundp 'compilation-error-list) ;compile loaded
- ;; Construct a list; each elt is nil or a buffer
- ;; iff that buffer is a compilation output buffer
- ;; that contains markers into the current buffer.
- (save-current-buffer
- (mapcar (lambda (buffer)
- (set-buffer buffer)
- (let ((errors (or
- compilation-old-error-list
- compilation-error-list))
- (buffer-error-marked-p nil))
- (while (and (consp errors)
- (not buffer-error-marked-p))
- (and (markerp (cdr (car errors)))
- (eq buffer
- (marker-buffer
- (cdr (car errors))))
- (setq buffer-error-marked-p t))
- (setq errors (cdr errors)))
- (if buffer-error-marked-p buffer)))
- (buffer-list))))))
+ ;; The new compilation code does not use compilation-error-list any
+ ;; more, so the code below is now ineffective and might as well
+ ;; be disabled. -- Stef
+ ;; ;; We may want to reparse the compilation buffer after revert
+ ;; (reparse (and (boundp 'compilation-error-list) ;compile loaded
+ ;; ;; Construct a list; each elt is nil or a buffer
+ ;; ;; iff that buffer is a compilation output buffer
+ ;; ;; that contains markers into the current buffer.
+ ;; (save-current-buffer
+ ;; (mapcar (lambda (buffer)
+ ;; (set-buffer buffer)
+ ;; (let ((errors (or
+ ;; compilation-old-error-list
+ ;; compilation-error-list))
+ ;; (buffer-error-marked-p nil))
+ ;; (while (and (consp errors)
+ ;; (not buffer-error-marked-p))
+ ;; (and (markerp (cdr (car errors)))
+ ;; (eq buffer
+ ;; (marker-buffer
+ ;; (cdr (car errors))))
+ ;; (setq buffer-error-marked-p t))
+ ;; (setq errors (cdr errors)))
+ ;; (if buffer-error-marked-p buffer)))
+ ;; (buffer-list)))))
+ (reparse nil))
(list point-context mark-context reparse)))
(defun vc-restore-buffer-context (context)
(let ((point-context (nth 0 context))
(mark-context (nth 1 context))
(reparse (nth 2 context)))
- ;; Reparse affected compilation buffers.
- (while reparse
- (if (car reparse)
- (with-current-buffer (car reparse)
- (let ((compilation-last-buffer (current-buffer)) ;select buffer
- ;; Record the position in the compilation buffer of
- ;; the last error next-error went to.
- (error-pos (marker-position
- (car (car-safe compilation-error-list)))))
- ;; Reparse the error messages as far as they were parsed before.
- (compile-reinitialize-errors '(4) compilation-parsing-end)
- ;; Move the pointer up to find the error we were at before
- ;; reparsing. Now next-error should properly go to the next one.
- (while (and compilation-error-list
- (/= error-pos (car (car compilation-error-list))))
- (setq compilation-error-list (cdr compilation-error-list))))))
- (setq reparse (cdr reparse)))
+ ;; The new compilation code does not use compilation-error-list any
+ ;; more, so the code below is now ineffective and might as well
+ ;; be disabled. -- Stef
+ ;; ;; Reparse affected compilation buffers.
+ ;; (while reparse
+ ;; (if (car reparse)
+ ;; (with-current-buffer (car reparse)
+ ;; (let ((compilation-last-buffer (current-buffer)) ;select buffer
+ ;; ;; Record the position in the compilation buffer of
+ ;; ;; the last error next-error went to.
+ ;; (error-pos (marker-position
+ ;; (car (car-safe compilation-error-list)))))
+ ;; ;; Reparse the error messages as far as they were parsed before.
+ ;; (compile-reinitialize-errors '(4) compilation-parsing-end)
+ ;; ;; Move the pointer up to find the error we were at before
+ ;; ;; reparsing. Now next-error should properly go to the next one.
+ ;; (while (and compilation-error-list
+ ;; (/= error-pos (car (car compilation-error-list))))
+ ;; (setq compilation-error-list (cdr compilation-error-list))))))
+ ;; (setq reparse (cdr reparse)))
;; if necessary, restore point and mark
(if (not (vc-context-matches-p (point) point-context))
editing non-current versions is not supported by default."
t)
-(defun vc-recompute-state (file)
- "Force a recomputation of the version control state of FILE.
-The state is computed using the exact, and possibly expensive
-function `vc-BACKEND-state', not the heuristic."
- (vc-file-setprop file 'vc-state (vc-call state file)))
-
(defun vc-next-action-on-file (file verbose &optional comment)
"Do The Right Thing for a given FILE under version control.
If COMMENT is specified, it will be used as an admin or checkin comment.
;; Old def for compatibility with Emacs-21.[123].
(defmacro vc-diff-switches-list (backend) `(vc-switches ',backend 'diff))
-(make-obsolete 'vc-diff-switches-list 'vc-switches "21.4")
+(make-obsolete 'vc-diff-switches-list 'vc-switches "22.1")
(defun vc-default-diff-tree (backend dir rev1 rev2)
"List differences for all registered files at and below DIR.
;; without the optional buffer argument (for backward compatibility).
;; Otherwise, resignal.
(if (or (not (eq (cadr err)
- (indirect-function
- (vc-find-backend-function (vc-backend file)
+ (indirect-function
+ (vc-find-backend-function (vc-backend file)
'print-log))))
(not (eq (caddr err) 2)))
- (signal 'wrong-number-of-arguments err)
+ (signal (car err) (cdr err))
;; for backward compatibility
(vc-call print-log file)
(set-buffer "*vc*"))))
(unless (yes-or-no-p "File seems up-to-date. Revert anyway? ")
(error "Revert canceled")))
(unless (vc-workfile-unchanged-p file)
+ (message "Finding changes...")
;; vc-diff selects the new window, which is not what we want:
;; if the new window is on another frame, that'd require the user
;; moving her mouse to answer the yes-or-no-p question.
- (let ((win (save-selected-window
- (setq status (vc-diff nil t)) (selected-window))))
+ (let* ((vc-disable-async-diff (not vc-allow-async-revert))
+ (win (save-selected-window
+ (setq status (vc-diff nil t)) (selected-window))))
(vc-exec-after `(message nil))
(when status
(unwind-protect
(pop-to-buffer
(set-buffer (get-buffer-create "*vc*")))
(erase-buffer)
- (insert-file tempfile)
+ (insert-file-contents tempfile)
"failed"))
(setq default-directory (file-name-directory changelog))
(delete-file tempfile)))))
(message "Redisplaying annotation...done"))
(defun vc-annotate-display-autoscale (&optional full)
- "Highlight the output of \\[vc-annotate]] using an autoscaled color map.
+ "Highlight the output of \\[vc-annotate] using an autoscaled color map.
Autoscaling means that the map is scaled from the current time to the
-oldest annotation in the buffer, or, with argument FULL non-nil, to
+oldest annotation in the buffer, or, with prefix argument FULL, to
cover the range from the oldest annotation to the newest."
- (interactive)
+ (interactive "P")
(let ((newest 0.0)
(oldest 999999.) ;Any CVS users at the founding of Rome?
(current (vc-annotate-convert-time (current-time)))
;; Run through this file and find the oldest and newest dates annotated.
(save-excursion
(goto-char (point-min))
- (while (setq date (vc-call-backend vc-annotate-backend 'annotate-time))
+ (while (setq date (prog1 (vc-call-backend vc-annotate-backend
+ 'annotate-time)
+ (forward-line 1)))
(if (> date newest)
(setq newest date))
(if (< date oldest)
(when buffer
(set-buffer buffer)
(display-buffer buffer))
- (if (not vc-annotate-mode) ; Turn on vc-annotate-mode if not done
+ (if (not vc-annotate-parent-rev)
(vc-annotate-mode))
(cond ((null vc-annotate-display-mode)
(vc-annotate-display-default vc-annotate-ratio))
;;;###autoload
(defun vc-annotate (prefix &optional revision display-mode)
- "Display the edit history of the current file using colours.
+ "Display the edit history of the current file using colors.
This command creates a buffer that shows, for each line of the current
-file, when it was last edited and by whom. Additionally, colours are
+file, when it was last edited and by whom. Additionally, colors are
used to show the age of each line--blue means oldest, red means
-youngest, and intermediate colours indicate intermediate ages. By
+youngest, and intermediate colors indicate intermediate ages. By
default, the time scale stretches back one year into the past;
everything that is older than that is shown in blue.
;;
;; Thus, there is no explicit recovery code.
-;;; arch-tag: ca82c1de-3091-4e26-af92-460abc6213a6
+;; arch-tag: ca82c1de-3091-4e26-af92-460abc6213a6
;;; vc.el ends here