emacs: lisp/vc.el comparison

comparison lisp/vc.el @ 54618:7cd50dab9d3d

(vc-version-diff, vc-default-diff-tree): Change `rel' -> `rev'. (vc-diff-label): New fun. (vc-diff-internal): Use it.

author	Stefan Monnier <monnier@iro.umontreal.ca>
date	Sun, 28 Mar 2004 22:00:19 +0000
parents	c3043c1faed3
children	494d96bf5f98 7f60e040ccfc

comparison

equal deleted inserted replaced

-:9049edac1117
+:7cd50dab9d3d
 ;; Author:     FSF (see below for full credits)
 ;; Maintainer: Andre Spiegel <spiegel@gnu.org>
 ;; Keywords: tools
-;; $Id: vc.el,v 1.372 2004/03/26 06:07:55 spiegel Exp $
+;; $Id: vc.el,v 1.373 2004/03/26 16:17:12 monnier Exp $
 ;; This file is part of GNU Emacs.
 ;; GNU Emacs is free software; you can redistribute it and/or modify
 ;; it under the terms of the GNU General Public License as published by
 (vc-buffer-sync not-urgent)
 (if (vc-workfile-unchanged-p buffer-file-name)
 	  (message "No changes to %s since latest version" file)
 	(vc-version-diff file nil nil)))))
-(defun vc-version-diff (file rel1 rel2)
+(defun vc-version-diff (file rev1 rev2)
-"List the differences between FILE's versions REL1 and REL2.
+"List the differences between FILE's versions REV1 and REV2.
-If REL1 is empty or nil it means to use the current workfile version;
+If REV1 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
+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
 (let ((file (expand-file-name
 (read-file-name (if buffer-file-name
 "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
 ((file-directory-p file)
 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))
+(if (string= rev1-default "") (setq rev1-default nil))
-(setq rel2-default (vc-workfile-version file))))
+(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)
+			nil nil rev1-default)
-(read-string (if rel2-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 rev1 "") (setq rev1 nil))
-	(if (string-equal rel2 "") (setq rel2 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.  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 rel1 rel2))
+(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 rev1
-	    (if rel2
+	    (if rev2
-		(message "No changes to %s between %s and %s" file rel1 rel2)
+		(message "No changes to %s between %s and %s" file rev1 rev2)
-	      (message "No changes to %s since %s" file rel1))
+	      (message "No changes to %s since %s" file rev1))
 	  (message "No changes to %s since latest version" file))
 	nil)
 (pop-to-buffer (current-buffer))
 ;; Gnus-5.8.5 sets up an autoload for diff-mode, even if it's
 ;; not available.  Work around that.
 			  (insert "No differences found.\n"))
 		      (goto-char (point-min))
 		      (shrink-window-if-larger-than-buffer)))
 t))
-(defun vc-diff-internal (file rel1 rel2)
+(defun vc-diff-label (file file-rev rev)
-"Run diff to compare FILE's revisions REL1 and REL2.
+(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 ""))
+(if (or (not rev1) (string-equal rev1 ""))
-(setq rel1 (vc-workfile-version file)))
+(setq rev1 (vc-workfile-version file)))
-(if (string-equal rel2 "")
+(if (string-equal rev2 "")
-(setq rel2 nil))
+(setq rev2 nil))
-(let ((file-rel1 (vc-version-backup-file file rel1))
+(let ((file-rev1 (vc-version-backup-file file rev1))
-(file-rel2 (if (not rel2)
+(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)
+		       ;; Provide explicit labels like RCS or CVS would do
-			     (file-relative-name file-rel2))))
+		       ;; so diff-mode refers to `file' rather than to
-(vc-call diff file rel1 rel2))))
+		       ;; `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)
 (let ((switches
 	 (or (if backend
 ;; 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")
-(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,
 ;; and to call it only for files that are actually changed.
 ;; However, this is expensive for some backends, and so it is left
 (lambda (f)
 (vc-exec-after
 `(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."
 (or coding-system-for-read
 ;; if we already have this file open,

Mercurial > emacs

comparison lisp/vc.el @ 54618:7cd50dab9d3d