;;; vc.el --- drive a version-control system from within Emacs
-;; Copyright (C) 1992,93,94,95,96,97,98,2000,01,2003
+;; Copyright (C) 1992,93,94,95,96,97,98,2000,01,2003,2004
;; Free Software Foundation, Inc.
;; Author: FSF (see below for full credits)
;; Maintainer: Andre Spiegel <spiegel@gnu.org>
;; Keywords: tools
-;; $Id: vc.el,v 1.365 2004/01/23 11:20:55 uid65624 Exp $
+;; $Id: vc.el,v 1.376 2004/04/16 10:21:24 spiegel Exp $
;; This file is part of GNU Emacs.
;;
;; HISTORY FUNCTIONS
;;
-;; * print-log (file)
+;; * print-log (file &optional buffer)
;;
-;; Insert the revision log of FILE into the *vc* buffer.
+;; Insert the revision log of FILE into BUFFER, or the *vc* buffer
+;; if BUFFER is nil.
;;
;; - show-log-entry (version)
;;
;; default implementation runs rcs2log, which handles RCS- and
;; CVS-style logs.
;;
-;; * diff (file &optional rev1 rev2)
+;; * diff (file &optional rev1 rev2 buffer)
;;
-;; Insert the diff for FILE into the *vc-diff* buffer. If REV1 and
-;; REV2 are non-nil, report differences from REV1 to REV2. If REV1
-;; is nil, use the current workfile version (as found in the
-;; repository) as the older version; if REV2 is nil, use the current
-;; workfile contents as the newer version. This function should
-;; pass the value of (vc-switches BACKEND 'diff) to the backend
-;; command. It should return a status of either 0 (no differences
-;; found), or 1 (either non-empty diff or the diff is run
-;; asynchronously).
+;; Insert the diff for FILE into BUFFER, or the *vc-diff* buffer if
+;; BUFFER is nil. If REV1 and REV2 are non-nil, report differences
+;; from REV1 to REV2. If REV1 is nil, use the current workfile
+;; version (as found in the repository) as the older version; if
+;; REV2 is nil, use the current workfile contents as the newer
+;; version. This function should pass the value of (vc-switches
+;; BACKEND 'diff) to the backend command. It should return a status
+;; of either 0 (no differences found), or 1 (either non-empty diff
+;; or the diff is run asynchronously).
;;
;; - diff-tree (dir &optional rev1 rev2)
;;
;; repository. If this function is not provided, the renaming
;; will be done by (vc-delete-file old) and (vc-register new).
;;
+;; - find-file-hook ()
+;;
+;; Operation called in current buffer when opening a file. This can
+;; be used by the backend to setup some local variables it might need.
+;
+;; - find-file-not-found-hook ()
+;;
+;; Operation called in current buffer when opening a non-existing file.
+;; By default, this asks the user if she wants to check out the file.
;;; Code:
(let ((filevar (make-symbol "file")))
`(let ((,filevar (expand-file-name ,file)))
(or (vc-backend ,filevar)
- (error (format "File not under version control: `%s'" file)))
+ (error "File not under version control: `%s'" file))
(unless (vc-editable-p ,filevar)
(let ((state (vc-state ,filevar)))
(if (stringp state)
- (error (format "`%s' is locking `%s'" state ,filevar))
+ (error "`%s' is locking `%s'" state ,filevar)
(vc-checkout ,filevar t))))
(save-excursion
,@body)
(message "No changes to %s since latest version" file)
(vc-version-diff file nil nil)))))
-(defun vc-version-diff (file rel1 rel2)
- "List the differences between FILE's versions REL1 and REL2.
-If REL1 is empty or nil it means to use the current workfile version;
-REL2 empty or nil means the current file contents. FILE may also be
+(defun vc-version-diff (file rev1 rev2)
+ "List the differences between FILE's versions REV1 and REV2.
+If REV1 is empty or nil it means to use the current workfile version;
+REV2 empty or nil means the current file contents. FILE may also be
a directory, in that case, generate diffs between the correponding
versions of all registered files in or below it."
(interactive
"File or dir to diff: (default visited file) "
"File or dir to diff: ")
default-directory buffer-file-name t)))
- (rel1-default nil) (rel2-default nil))
+ (rev1-default nil) (rev2-default nil))
;; compute default versions based on the file state
(cond
;; if it's a directory, don't supply any version default
nil)
;; if the file is not up-to-date, use current version as older version
((not (vc-up-to-date-p file))
- (setq rel1-default (vc-workfile-version file)))
+ (setq rev1-default (vc-workfile-version file)))
;; if the file is not locked, use last and previous version as default
(t
- (setq rel1-default (vc-call previous-version file
+ (setq rev1-default (vc-call previous-version file
(vc-workfile-version file)))
- (if (string= rel1-default "") (setq rel1-default nil))
- (setq rel2-default (vc-workfile-version file))))
+ (if (string= rev1-default "") (setq rev1-default nil))
+ (setq rev2-default (vc-workfile-version file))))
;; construct argument list
(list file
- (read-string (if rel1-default
+ (read-string (if rev1-default
(concat "Older version: (default "
- rel1-default ") ")
+ rev1-default ") ")
"Older version: ")
- nil nil rel1-default)
- (read-string (if rel2-default
+ nil nil rev1-default)
+ (read-string (if rev2-default
(concat "Newer version: (default "
- rel2-default ") ")
+ rev2-default ") ")
"Newer version (default: current source): ")
- nil nil rel2-default))))
+ nil nil rev2-default))))
(if (file-directory-p file)
;; recursive directory diff
(progn
(vc-setup-buffer "*vc-diff*")
- (if (string-equal rel1 "") (setq rel1 nil))
- (if (string-equal rel2 "") (setq rel2 nil))
+ (if (string-equal rev1 "") (setq rev1 nil))
+ (if (string-equal rev2 "") (setq rev2 nil))
(let ((inhibit-read-only t))
(insert "Diffs between "
- (or rel1 "last version checked in")
+ (or rev1 "last version checked in")
" and "
- (or rel2 "current workfile(s)")
+ (or rev2 "current workfile(s)")
":\n\n"))
(let ((dir (file-name-as-directory file)))
(vc-call-backend (vc-responsible-backend dir)
- 'diff-tree dir rel1 rel2))
+ 'diff-tree dir rev1 rev2))
(vc-exec-after `(let ((inhibit-read-only t))
(insert "\nEnd of diffs.\n"))))
- ;; single file diff
- (vc-diff-internal file rel1 rel2))
+ ;; Single file diff. It is important that the vc-controlled buffer
+ ;; is still current at this time, because any local settings in that
+ ;; buffer should affect the diff command.
+ (vc-diff-internal file rev1 rev2))
(set-buffer "*vc-diff*")
(if (and (zerop (buffer-size))
(not (get-buffer-process (current-buffer))))
(progn
- (if rel1
- (if rel2
- (message "No changes to %s between %s and %s" file rel1 rel2)
- (message "No changes to %s since %s" file rel1))
+ (if rev1
+ (if rev2
+ (message "No changes to %s between %s and %s" file rev1 rev2)
+ (message "No changes to %s since %s" file rev1))
(message "No changes to %s since latest version" file))
nil)
(pop-to-buffer (current-buffer))
(shrink-window-if-larger-than-buffer)))
t))
-(defun vc-diff-internal (file rel1 rel2)
- "Run diff to compare FILE's revisions REL1 and REL2.
-Output goes to the current buffer, which is assumed properly set up.
-The exit status of the diff command is returned.
+(defun vc-diff-label (file file-rev rev)
+ (concat (file-relative-name file)
+ (format-time-string "\t%d %b %Y %T %z\t"
+ (nth 5 (file-attributes file-rev)))
+ rev))
+
+(defun vc-diff-internal (file rev1 rev2)
+ "Run diff to compare FILE's revisions REV1 and REV2.
+Diff output goes to the *vc-diff* buffer. The exit status of the diff
+command is returned.
This function takes care to set up a proper coding system for diff output.
If both revisions are available as local files, then it also does not
actually call the backend, but performs a local diff."
- (if (or (not rel1) (string-equal rel1 ""))
- (setq rel1 (vc-workfile-version file)))
- (if (string-equal rel2 "")
- (setq rel2 nil))
- (let ((file-rel1 (vc-version-backup-file file rel1))
- (file-rel2 (if (not rel2)
+ (if (or (not rev1) (string-equal rev1 ""))
+ (setq rev1 (vc-workfile-version file)))
+ (if (string-equal rev2 "")
+ (setq rev2 nil))
+ (let ((file-rev1 (vc-version-backup-file file rev1))
+ (file-rev2 (if (not rev2)
file
- (vc-version-backup-file file rel2)))
+ (vc-version-backup-file file rev2)))
(coding-system-for-read (vc-coding-system-for-diff file)))
- (if (and file-rel1 file-rel2)
+ (if (and file-rev1 file-rev2)
(apply 'vc-do-command "*vc-diff*" 1 "diff" nil
(append (vc-switches nil 'diff)
- (list (file-relative-name file-rel1)
- (file-relative-name file-rel2))))
- (vc-call diff file rel1 rel2))))
+ ;; Provide explicit labels like RCS or CVS would do
+ ;; so diff-mode refers to `file' rather than to
+ ;; `file-rev1' when trying to find/apply/undo hunks.
+ (list "-L" (vc-diff-label file file-rev1 rev1)
+ "-L" (vc-diff-label file file-rev2 rev2)
+ (file-relative-name file-rev1)
+ (file-relative-name file-rev2))))
+ (vc-call diff file rev1 rev2))))
(defun vc-switches (backend op)
(defmacro vc-diff-switches-list (backend) `(vc-switches ',backend 'diff))
(make-obsolete 'vc-diff-switches-list 'vc-switches "21.4")
-(defun vc-default-diff-tree (backend dir rel1 rel2)
+(defun vc-default-diff-tree (backend dir rev1 rev2)
"List differences for all registered files at and below DIR.
-The meaning of REL1 and REL2 is the same as for `vc-version-diff'."
+The meaning of REV1 and REV2 is the same as for `vc-version-diff'."
;; This implementation does an explicit tree walk, and calls
;; vc-BACKEND-diff directly for each file. An optimization
;; would be to use `vc-diff-internal', so that diffs can be local,
`(let ((coding-system-for-read (vc-coding-system-for-diff ',f)))
(message "Looking at %s" ',f)
(vc-call-backend ',(vc-backend f)
- 'diff ',f ',rel1 ',rel2))))))
+ 'diff ',f ',rev1 ',rev2))))))
(defun vc-coding-system-for-diff (file)
"Return the coding system for reading diff output for FILE."
(vc-resynch-buffer file t (not (buffer-modified-p)))
(if (zerop status) (message "Merge successful")
(smerge-mode 1)
- (if (y-or-n-p "Conflicts detected. Resolve them now? ")
- (vc-resolve-conflicts name-A name-B)
- (message "File contains conflict markers"))))
+ (message "File contains conflicts.")))
;;;###autoload
(defalias 'vc-resolve-conflicts 'smerge-ediff)
;;;###autoload
(defun vc-print-log (&optional focus-rev)
- "List the change log of the current buffer in a window. If
-FOCUS-REV is non-nil, leave the point at that revision."
+ "List the change log of the current buffer in a window.
+If FOCUS-REV is non-nil, leave the point at that revision."
(interactive)
(vc-ensure-vc-buffer)
(let ((file buffer-file-name))
(or focus-rev (setq focus-rev (vc-workfile-version file)))
- (vc-call print-log file)
- (set-buffer "*vc*")
+ ;; Don't switch to the output buffer before running the command,
+ ;; so that any buffer-local settings in the vc-controlled
+ ;; buffer can be accessed by the command.
+ (condition-case err
+ (progn
+ (vc-call print-log file "*vc-change-log*")
+ (set-buffer "*vc-change-log*"))
+ (wrong-number-of-arguments
+ ;; If this error came from the above call to print-log, try again
+ ;; 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)
+ 'print-log))))
+ (not (eq (caddr err) 2)))
+ (signal (car err) (cdr err))
+ ;; for backward compatibility
+ (vc-call print-log file)
+ (set-buffer "*vc*"))))
(pop-to-buffer (current-buffer))
(log-view-mode)
(vc-exec-after
((not (vc-call latest-on-branch-p file))
(error "This is not the latest version; VC cannot cancel it"))
((not (vc-up-to-date-p file))
- (error (substitute-command-keys "File is not up to date; use \\[vc-revert-buffer] to discard changes"))))
+ (error "%s" (substitute-command-keys "File is not up to date; use \\[vc-revert-buffer] to discard changes"))))
(if (null (yes-or-no-p (format "Remove version %s from master? " target)))
(error "Aborted")
(setq norevert (or norevert (not
(set (make-local-variable 'vc-annotate-parent-rev) vc-annotate-version)
(set (make-local-variable 'vc-annotate-parent-display-mode)
vc-annotate-display-mode))
-
+
;; Don't use the temp-buffer-name until the buffer is created
;; (only after `with-output-to-temp-buffer'.)
(setq vc-annotate-buffers
(vc-annotate-warp-version rev-at-line))))))
(defun vc-annotate-revision-previous-to-line ()
- "Visit the annotation of the version before the version at line."
+ "Visit the annotation of the version before the version at line."
(interactive)
(if (not (equal major-mode 'vc-annotate-mode))
(message "Cannot be invoked outside of a vc annotate buffer")