CVS update by scop packages/xemacs-packages/vc, package-info.in ...
xemacs-cvs at xemacs.org
xemacs-cvs at xemacs.org
Thu Aug 23 17:28:15 EDT 2007
User: scop
Date: 07/08/23 23:28:13
Modified: packages/xemacs-packages/vc ChangeLog Makefile
package-info.in vc-hooks.el vc.el
Added: packages/xemacs-packages/vc log-edit.el mercurial.el
vc-arch.el vc-cvs.el vc-git.el vc-mcvs.el vc-rcs.el
vc-sccs.el vc-svn.el vc-xemacs.el
Log:
Move new vc package from unsupported/scop/vc to main packages tree <200708181923.19296.scop at xemacs.org>
Revision Changes Path
1.46 +396 -0 XEmacs/packages/xemacs-packages/vc/ChangeLog
Index: ChangeLog
===================================================================
RCS file: /pack/xemacscvs/XEmacs/packages/xemacs-packages/vc/ChangeLog,v
retrieving revision 1.45
retrieving revision 1.46
diff -u -p -r1.45 -r1.46
--- ChangeLog 2005/06/05 17:22:08 1.45
+++ ChangeLog 2007/08/23 21:27:52 1.46
@@ -1,3 +1,399 @@
+2007-08-21 Ville Skyttä <scop at xemacs.org>
+
+ * vc-rcs.el (vc-rcs-annotate-command): Use `substring' if
+ `substring-no-properties' is not available, thanks to Adrian Aichner.
+
+2007-08-18 Ville Skyttä <scop at xemacs.org>
+
+ * Makefile (VERSION): 0.94.
+
+ * mercurial.el: Sync with upstream.
+
+2007-07-16 Ville Skyttä <scop at xemacs.org>
+
+ * mercurial.el: Sync with upstream.
+ * vc-git.el: Ditto.
+
+2007-07-08 Ville Skyttä <scop at xemacs.org>
+
+ * Makefile (VERSION): 0.93.
+
+ * Makefile (REQUIRES): Add gnus for `parse-time' in vc-cvs.el.
+
+ * vc.el (vc-dired-purge): Use `dired-do-kill-file-lines'
+ instead of `dired-do-kill-lines'.
+ (vc-directory): Don't try to load dired-aux.
+
+2007-07-07 Ville Skyttä <scop at xemacs.org>
+
+ * smerge-mode.el: Removed, requires too much porting work to be
+ feasible at the moment.
+ * Makefile (ELCS): Remove smerge-mode.elc.
+ * package-info.in (provides): Remove smerge-mode.
+
+ * vc.el: Bring back old `vc-resolve-conflicts'.
+ * vc-arch.el (vc-arch-find-file-hook): Make smerge-mode optional.
+
+ * Makefile (REQUIRES): Add elib and edebug (pulled in by ediff).
+
+ * vc-arch.el (vc-arch-add-tagline): Call `comment-normalize-vars'
+ only if it's available.
+
+ * vc-svn.el (vc-svn-repository-hostname): Adapt upstream fix
+ for finding out the URL from files created by Subversion >= 1.4.
+
+2007-06-24 Ville Skyttä <scop at xemacs.org>
+
+ * Makefile (VERSION): 0.92.
+
+ * vc.el, mercurial.el: Sync with upstream.
+
+ * mercurial.el, vc-hooks.el, vc-xemacs.el: Pull in mercurial.el
+ on demand only, like other vc-* modes.
+
+2007-06-16 Ville Skyttä <scop at xemacs.org>
+
+ * vc-arch.el: Sync with upstream.
+ * vc-svn.el: Ditto.
+ * vc.el: Ditto.
+
+2007-06-06 Ville Skyttä <scop at xemacs.org>
+
+ * vc-hooks.el: Sync with upstream.
+ * log-edit.el: Ditto.
+
+2007-05-21 Ville Skyttä <scop at xemacs.org>
+
+ * Makefile (VERSION): 0.91.
+
+ * mercurial.el: New, from Mercurial itself.
+ * Makefile (ELCS): Add mercurial.el.
+ * package-info.in (provides): Add mercurial.
+ * vc-hooks.el: Add `hg-find-file-hook' to `find-file-hook'.
+
+2007-05-14 Ville Skyttä <scop at xemacs.org>
+
+ * *.el: Sync with upstream.
+
+2007-02-25 Ville Skyttä <scop at xemacs.org>
+
+ * vc-svn.el: Sync with upstream.
+
+2007-02-11 Ville Skyttä <scop at xemacs.org>
+
+ * vc-svn.el: Sync with upstream.
+
+2007-02-03 Ville Skyttä <scop at xemacs.org>
+
+ * Makefile (VERSION): 0.90.
+
+ * vc-hooks.el (vc-registered): Call vc-BACKEND-registered-lite
+ if vc-BACKEND-registered is not bound to work around XEmacs 21.4
+ byte compiler or bytecode interpreter issues when the real
+ -registered defun is redefined and called by the fully autoloaded
+ version.
+
+ * vc-arch.el (vc-arch-registered-lite):
+ * vc-cvs.el (vc-cvs-registered-lite):
+ * vc-mcvs.el (vc-mcvs-registered-lite):
+ * vc-svn.el (vc-svn-registered-lite):
+ Rename fully autoloaded vc-BACKEND-registered to
+ vc-BACKEND-registered-lite.
+
+ * vc-git.el (vc-git-registered-lite): New, fully autoloaded version.
+
+ * log-edit.el: Sync with upstream.
+
+2007-01-28 Ville Skyttä <scop at xemacs.org>
+
+ * *.el: Sync with upstream.
+
+2007-01-18 Ville Skyttä <scop at xemacs.org>
+
+ * log-edit.el: Sync with upstream.
+ * vc-arch.el: Ditto.
+ * vc-git.el: Ditto.
+ * vc-hooks.el: Ditto.
+ * vc-svn.el: Ditto.
+
+2006-11-11 Ville Skyttä <scop at xemacs.org>
+
+ * vc-svn.el: Sync with upstream.
+
+2006-10-25 Ville Skyttä <scop at xemacs.org>
+
+ * vc.el: Sync with upstream.
+ * vc-svn.el: Ditto.
+
+2006-10-15 Ville Skyttä <scop at xemacs.org>
+
+ * vc-git.el: Sync with upstream.
+ * vc-hooks.el: Ditto.
+
+2006-08-29 Ville Skyttä <scop at xemacs.org>
+
+ * smerge-mode.el (smerge-mine): Comment out unsupported
+ min-colors properties, thanks to Stephen J. Turnbull for the catch.
+ (smerge-base): Ditto.
+
+2006-08-16 Ville Skyttä <scop at xemacs.org>
+
+ * smerge-mode.el: New from GNU Emacs CVS. Needs work.
+
+2006-08-15 Ville Skyttä <scop at xemacs.org>
+
+ * vc-git.el (vc-git-registered): Avoid failures if `git' is not
+ installed, thanks to Adrian Aichner for the catch.
+
+2006-08-05 Ville Skyttä <scop at xemacs.org>
+
+ * vc.el: Sync with upstream.
+
+ * vc-git.el: Changes applied upstream.
+
+2006-07-06 Ville Skyttä <scop at xemacs.org>
+
+ * vc.el: Sync with upstream.
+
+2006-07-04 Ville Skyttä <scop at xemacs.org>
+
+ * Makefile (VERSION): 0.05.
+
+ * vc-git.el: New, from git upstream.
+ (vc-git-print-log): Add optional BUFFER arg, use it.
+ (vc-git-diff): Ditto.
+ * vc-hooks.el (vc-handled-backends): Add GIT.
+ (vc-mode-line): Ditto.
+ * package-info.in (provides): Add vc-git.
+ * Makefile (ELCS): Add vc-git.elc.
+
+ * vc.el (vc-coding-system-for-diff): We don't have
+ `find-operation-coding-system'.
+
+ * vc.el (vc-revert-buffer): Don't try to delete the revert
+ confirmation diff window for now as it breaks for some
+ reason, and prevents the actual revert from happening.
+
+ * vc.el (vc-restore-buffer-context): Test for mark before using.
+
+ * vc-xemacs.el: Comment update.
+
+2006-06-28 Ville Skyttä <scop at xemacs.org>
+
+ * vc.el: Sync with upstream.
+
+2006-06-12 Ville Skyttä <scop at xemacs.org>
+
+ * Makefile (VERSION): 0.04.
+
+ * vc.el: Sync with upstream.
+
+2006-05-01 Ville Skyttä <scop at xemacs.org>
+
+ * vc.el (vc-default-show-log-entry): Workaround for (at least so
+ far) missing log-view stuff.
+
+2006-04-29 Ville Skyttä <scop at xemacs.org>
+
+ * vc.el (vc-annotate-warp-version): Use `forward-line' instead
+ of `previous-line'.
+
+2006-04-22 Ville Skyttä <scop at xemacs.org>
+
+ * Makefile (VERSION): 0.03.
+
+ * vc.el (vc-annotate): `goto-line' in XEmacs takes only 1 arg,
+ emulate GNU Emacs' 2-arg one.
+ (vc-annotate-warp-version): Ditto.
+
+ * vc-cvs.el (vc-cvs-parse-root): Fix :local: root parsing.
+
+2006-04-21 Ville Skyttä <scop at xemacs.org>
+
+ * Makefile (VERSION): 0.02.
+
+ * vc-hooks.el: Bind C-x C-q to `vc-toggle-read-only' like in the
+ old vc package, thanks to Vegard Vesterheim.
+
+2006-04-16 Ville Skyttä <scop at xemacs.org>
+
+ * vc.el: Sync with upstream.
+
+ * vc-xemacs.el (line-number-at-pos): Sync compat implementation
+ with XEmacs 21.5.
+
+2006-02-11 Ville Skyttä <scop at xemacs.org>
+
+ * *.el: Sync with upstream.
+ * Makefile (REQUIRES): Add tramp.
+
+2005-12-31 Ville Skyttä <scop at xemacs.org>
+
+ * vc.el: Sync with upstream.
+
+2005-12-26 Ville Skyttä <scop at xemacs.org>
+
+ * vc.el, vc-mcvs.el, vc-svn.el: Sync with upstream.
+
+2005-12-05 Ville Skyttä <scop at xemacs.org>
+
+ * log-edit.el: Sync with upstream.
+
+ * log-edit.el: Use pcl-cvs-util (already in the packages tree).
+ * Makefile (REQUIRES): Add pcl-cvs.
+ * Makefile (ELCS): Remove pcvs-util.elc.
+ * package-info-in (provides): Remove pcvs-util.
+ * pcvs-util.el: Remove.
+ * vc-xemacs.el (compare-strings): Remove, only used by pcvs-util.
+
+2005-11-28 Ville Skyttä <scop at xemacs.org>
+
+ * log-edit.el: Sync with upstream.
+
+2005-11-15 Ville Skyttä <scop at xemacs.org>
+
+ * vc-svn.el: Sync with upstream.
+
+ * vc-xemacs.el (compare-strings): New, borrowed from ECB.
+
+2005-11-10 Oscar Figueiredo <oscar at xemacs.org>
+
+ * vc-xemacs.el (subst-char-in-string): Do not use `replace-in-string'
+ because of the regexp semantic on its second parameter.
+
+2005-11-10 Ville Skyttä <scop at xemacs.org>
+
+ * vc-xemacs.el: Update FSF's address.
+
+2005-11-02 Ville Skyttä <scop at xemacs.org>
+
+ * vc.el, vc-cvs.el, vc-sccs.el: Sync with upstream.
+
+2005-10-08 Ville Skyttä <scop at xemacs.org>
+
+ * log-edit.el, vc.el, vc-mcvs.el: Sync with upstream.
+
+2005-09-11 Ville Skyttä <scop at xemacs.org>
+
+ * vc.el: Sync with upstream.
+
+2005-08-16 Ville Skyttä <scop at xemacs.org>
+
+ * *.el: Sync with upstream.
+
+2005-07-24 Ville Skyttä <scop at xemacs.org>
+
+ * *.el: Sync with upstream.
+
+2005-06-21 Ville Skyttä <scop at xemacs.org>
+
+ * log-edit.el, vc-arch.el, vc-cvs.el, vc.el: Sync with upstream.
+
+2005-04-30 Ville Skyttä <scop at xemacs.org>
+
+ * vc.el: Sync with upstream.
+
+2005-04-09 Ville Skyttä <scop at xemacs.org>
+
+ * pcvs-util.el, vc.el, vc-cvs.el, vc-hooks.el: Sync with upstream.
+
+2005-03-06 Ville Skyttä <scop at xemacs.org>
+
+ * vc.el: Sync with upstream.
+
+2005-02-11 Ville Skyttä <scop at xemacs.org>
+
+ * vc*.el: Sync with upstream.
+
+2005-01-19 Ville Skyttä <scop at xemacs.org>
+
+ * vc*.el: Sync with upstream.
+
+2005-01-06 Ville Skyttä <scop at xemacs.org>
+
+ * vc-arch.el, vc-rcs.el, vc-svn.el: Sync with upstream.
+
+2004-12-19 Ville Skyttä <scop at xemacs.org>
+
+ * vc-cvs.el: Port the `vc-cvs-program' defcustom from the old
+ XEmacs vc package, and use it. Originally by Christian Schmitt.
+
+2004-12-18 Ville Skyttä <scop at xemacs.org>
+
+ * vc.el: Sync with upstream.
+
+2004-12-15 Ville Skyttä <scop at xemacs.org>
+
+ * vc-svn.el: Sync with upstream. Adds svn annotate support,
+ and includes my repository-hostname fix.
+
+2004-12-13 Ville Skyttä <scop at xemacs.org>
+
+ * log-edit.el: New, from upstream CVS; temporarily (?) here so
+ that editing commit messages could actually work.
+ * pcvs-util.el: Ditto.
+
+2004-12-12 Ville Skyttä <scop at xemacs.org>
+
+ * vc-cvs.el (vc-cvs-parse-root): XEmacs wants 2+ args to `setq'.
+
+ * vc-svn.el (vc-svn-repository-hostname): Make it work also with
+ Subversion >= 0.33.0, simplify regexp.
+
+2004-12-06 Ville Skyttä <scop at xemacs.org>
+
+ * vc.el, vc-cvs.el, vc-hooks.el, vc-rcs.el: Sync with upstream.
+
+2004-11-10 Ville Skyttä <scop at xemacs.org>
+
+ * vc.el, vc-cvs.el, vc-mcvs.el: Sync with upstream.
+
+2004-11-01 Ville Skyttä <scop at xemacs.org>
+
+ * vc.el, vc-arch.el, vc-hooks.el: Sync with upstream.
+
+2004-10-13 Ville Skyttä <scop at xemacs.org>
+
+ * vc.el: Sync with upstream.
+
+2004-09-15 Ville Skyttä <scop at xemacs.org>
+
+ * vc*.el: Sync with upstream.
+
+2004-08-25 Ville Skyttä <scop at xemacs.org>
+
+ * vc-svn.el: Sync with upstream.
+
+2004-08-15 Ville Skyttä <scop at xemacs.org>
+
+ * *: Move most of the XEmacs compatibility stuff into vc-xemacs.el,
+ add some TODOs and fix a few incompatibilities.
+
+2004-07-30 Ville Skyttä <scop at xemacs.org>
+
+ * vc-arch.el: Use replace-in-string instead of subst-char-in-string
+ and replace-regexp-in-string.
+
+2004-07-03 Ville Skyttä <scop at xemacs.org>
+
+ * vc-arch.el, vc-rcs.el: Sync with upstream.
+
+2004-06-05 Ville Skyttä <scop at xemacs.org>
+
+ * vc-svn.el: Sync with upstream.
+
+2004-06-01 Ville Skyttä <scop at xemacs.org>
+
+ * vc-arch.el: Sync with upstream.
+
+2004-05-29 Ville Skyttä <scop at xemacs.org>
+
+ * vc-arch.el, vc-mcvs.el: Sync with upstream.
+
+2004-05-24 Ville Skyttä <scop at xemacs.org>
+
+ * Initial revision of vc port from GNU Emacs.
+
2005-06-05 Norbert Koch <viteno at xemacs.org>
* Makefile (VERSION): XEmacs package 1.41 released.
1.45 +6 -3 XEmacs/packages/xemacs-packages/vc/Makefile
Index: Makefile
===================================================================
RCS file: /pack/xemacscvs/XEmacs/packages/xemacs-packages/vc/Makefile,v
retrieving revision 1.44
retrieving revision 1.45
diff -u -p -r1.44 -r1.45
--- Makefile 2005/06/05 17:22:08 1.44
+++ Makefile 2007/08/23 21:27:52 1.45
@@ -1,4 +1,4 @@
-# Makefile for XEmacs base lisp code
+# Makefile for VC lisp code
# This file is part of XEmacs.
@@ -22,9 +22,12 @@ AUTHOR_VERSION =
MAINTAINER = XEmacs Development Team <xemacs-beta at xemacs.org>
PACKAGE = vc
PKG_TYPE = regular
-REQUIRES = dired xemacs-base vc mail-lib ediff
+REQUIRES = dired xemacs-base vc mail-lib ediff sh-script pcl-cvs tramp \
+ prog-modes elib edebug gnus
CATEGORY = standard
-ELCS = vc-hooks.elc vc.elc
+ELCS = vc-hooks.elc vc.elc vc-arch.elc vc-cvs.elc vc-git.elc vc-mcvs.elc \
+ vc-rcs.elc vc-sccs.elc vc-svn.elc mercurial.elc vc-xemacs.elc \
+ log-edit.elc
include ../../XEmacs.rules
1.6 +1 -1 XEmacs/packages/xemacs-packages/vc/package-info.in
Index: package-info.in
===================================================================
RCS file: /pack/xemacscvs/XEmacs/packages/xemacs-packages/vc/package-info.in,v
retrieving revision 1.5
retrieving revision 1.6
diff -u -p -r1.5 -r1.6
--- package-info.in 2002/05/25 01:58:18 1.5
+++ package-info.in 2007/08/23 21:27:53 1.6
@@ -13,7 +13,7 @@
filename FILENAME
md5sum MD5SUM
size SIZE
- provides (vc vc-hooks)
+ provides (vc vc-hooks vc-arch vc-cvs vc-git vc-mcvs vc-rcs vc-sccs vc-svn mercurial vc-xemacs log-edit)
requires (REQUIRES)
type regular
))
1.13 +779 -1159 XEmacs/packages/xemacs-packages/vc/vc-hooks.el
Index: vc-hooks.el
===================================================================
RCS file: /pack/xemacscvs/XEmacs/packages/xemacs-packages/vc/vc-hooks.el,v
retrieving revision 1.12
retrieving revision 1.13
diff -u -p -r1.12 -r1.13
--- vc-hooks.el 2003/10/27 15:09:55 1.12
+++ vc-hooks.el 2007/08/23 21:27:53 1.13
@@ -1,13 +1,13 @@
-;;; vc-hooks.el --- support for version-control, formerly resident
+;;; vc-hooks.el --- resident support for version-control
-;; Copyright (C) 1992, 1993, 1994, 1995, 1996, 1998 Free Software Foundation, Inc.
+;; Copyright (C) 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001,
+;; 2002, 2003, 2004, 2005, 2006, 2007 Free Software Foundation, Inc.
-;; Author: Eric S. Raymond <esr at snark.thyrsus.com>
-;; Andre Spiegel <spiegel at gnu.org>
-;; Maintainer: XEmacs Development Team <xemacs at xemacs.org>
-;; Maintainer: (ClearCase) Rod Whitby <rwhitby at geocities.com>
-;; XEmacs conversion: Steve Baur <steve at xemacs.org>
+;; Author: FSF (see vc.el for full credits)
+;; Maintainer: Andre Spiegel <spiegel at gnu.org>
+;; $Id: vc-hooks.el,v 1.13 2007/08/23 21:27:53 scop Exp $
+
;; This file is part of GNU Emacs.
;; GNU Emacs is free software; you can redistribute it and/or modify
@@ -22,40 +22,58 @@
;; 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:
-;; [[This is the always-loaded portion of VC.]] --Not in XEmacs.
-;; Instead, loaded from vc.
-;; It takes care VC-related activities that are done when you visit a file,
-;; so that vc.el itself is loaded only when you use a VC command.
-;; See the commentary of vc.el.
+;; This is the always-loaded portion of VC. It takes care of
+;; VC-related activities that are done when you visit a file, so that
+;; vc.el itself is loaded only when you use a VC command. See the
+;; commentary of vc.el.
-;; ClearCase support is being worked on in a parallel distribution of vc.
-;; This file used to be dumped with XEmacs.
;;; Code:
-;; Customization Variables (the rest is in vc.el)
+(require 'vc-xemacs) ; XEmacs compatiblity stuff
+(eval-when-compile
+ (require 'cl))
-(defcustom vc-default-back-end nil
- "*Back-end actually used by this interface; may be SCCS or RCS.
-The value is only computed when needed to avoid an expensive search."
-:type '(choice (const nil) (const RCS) (const SCCS))
-:group 'vc)
-
-(defcustom vc-handle-cvs t
- "*If non-nil, use VC for files managed with CVS.
-If it is nil, don't use VC for those files."
-:type 'boolean
-:group 'vc)
+;; Customization Variables (the rest is in vc.el)
-(defcustom vc-rcsdiff-knows-brief nil
- "*Indicates whether rcsdiff understands the --brief option.
-The value is either `yes', `no', or nil. If it is nil, VC tries
-to use --brief and sets this variable to remember whether it worked."
-:type '(choice (const nil) (const yes) (const no))
+(defvar vc-ignore-vc-files nil)
+(make-obsolete-variable 'vc-ignore-vc-files
+ "set `vc-handled-backends' to nil to disable VC.")
+
+(defvar vc-master-templates ())
+(make-obsolete-variable 'vc-master-templates
+ "to define master templates for a given BACKEND, use
+vc-BACKEND-master-templates. To enable or disable VC for a given
+BACKEND, use `vc-handled-backends'.")
+
+(defvar vc-header-alist ())
+(make-obsolete-variable 'vc-header-alist 'vc-BACKEND-header)
+
+(defcustom vc-ignore-dir-regexp
+ ;; Stop SMB, automounter, AFS, and DFS host lookups.
+ "\\`\\(?:[\\/][\\/]\\|/\\(?:net\\|afs\\|\\.\\\.\\.\\)/\\)\\'"
+ "Regexp matching directory names that are not under VC's control.
+The default regexp prevents fruitless and time-consuming attempts
+to determine the VC status in directories in which filenames are
+interpreted as hostnames."
+:type 'regexp
+:group 'vc)
+
+;; XEmacs change: add GIT
+(defcustom vc-handled-backends '(RCS CVS SVN SCCS Arch MCVS GIT)
+ ;; Arch and MCVS come last because they are per-tree rather than per-dir.
+ "*List of version control backends for which VC will be used.
+Entries in this list will be tried in order to determine whether a
+file is under that sort of version control.
+Removing an entry from the list prevents VC from being activated
+when visiting a file managed by that backend.
+An empty list disables VC altogether."
+:type '(repeat symbol)
+:version "21.1"
:group 'vc)
(defcustom vc-path
@@ -66,34 +84,25 @@ to use --brief and sets this variable to
:type '(repeat directory)
:group 'vc)
-(defcustom vc-master-templates
- '(("%sRCS/%s,v" . RCS) ("%s%s,v" . RCS) ("%sRCS/%s" . RCS)
- ("%sSCCS/s.%s" . SCCS) ("%ss.%s". SCCS)
- vc-find-cvs-master
- vc-search-sccs-project-dir)
- "*Where to look for version-control master files.
-The first pair corresponding to a given back end is used as a template
-when creating new masters.
-Setting this variable to nil turns off use of VC entirely."
-:type '(repeat sexp)
-:group 'vc)
-
(defcustom vc-make-backup-files nil
"*If non-nil, backups of registered files are made as with other files.
If nil (the default), files covered by version control don't get backups."
:type 'boolean
-:group 'vc)
+:group 'vc
+:group 'backup)
(defcustom vc-follow-symlinks 'ask
- "*Indicates what to do if you visit a symbolic link to a file
-that is under version control. Editing such a file through the
-link bypasses the version control system, which is dangerous and
-probably not what you want.
- If this variable is t, VC follows the link and visits the real file,
+ "*What to do if visiting a symbolic link to a file under version control.
+Editing such a file through the link bypasses the version control system,
+which is dangerous and probably not what you want.
+
+If this variable is t, VC follows the link and visits the real file,
telling you about it in the echo area. If it is `ask', VC asks for
confirmation whether it should follow the link. If nil, the link is
visited and a warning displayed."
-:type '(choice (const ask) (const nil) (const t))
+:type '(choice (const :tag "Ask for confirmation" ask)
+ (const :tag "Visit link and warn" nil)
+ (const :tag "Follow link" t))
:group 'vc)
(defcustom vc-display-status t
@@ -115,895 +124,589 @@ value of this flag."
:type 'boolean
:group 'vc)
-(defcustom vc-mistrust-permissions nil
- "*If non-nil, don't assume that permissions and ownership track
-version-control status. If nil, do rely on the permissions.
-See also variable `vc-consult-headers'."
-:type 'boolean
+;; XEmacs addition
+(defcustom vc-mode-face 'highlight
+ "*Face used to display vc mode line, or nil/default for none."
+:type 'face
:group 'vc)
-
-(defcustom vc-ignore-vc-files nil
- "*If non-nil don't look for version control information when finding files.
-It may be useful to set this if (say) you edit files in a directory
-containing corresponding RCS files but don't have RCS available;
-similarly for other version control systems."
+(defcustom vc-mistrust-permissions nil
+ "*If non-nil, don't assume permissions/ownership track version-control status.
+If nil, do rely on the permissions.
+See also variable `vc-consult-headers'."
:type 'boolean
:group 'vc)
-(defcustom vc-mode-face 'highlight
- "*Face used to display vc mode line, or nil/default for none"
-:type 'face
-:group 'vc)
-
(defun vc-mistrust-permissions (file)
- ;; Access function to the above.
+ "Internal access function to variable `vc-mistrust-permissions' for FILE."
(or (eq vc-mistrust-permissions 't)
(and vc-mistrust-permissions
- (funcall vc-mistrust-permissions
+ (funcall vc-mistrust-permissions
(vc-backend-subdirectory-name file)))))
-;; Tell Emacs about this new kind of minor mode
-;;(if (not (assoc 'vc-mode minor-mode-alist))
-;; (setq minor-mode-alist (cons '(vc-mode vc-mode)
-;; minor-mode-alist)))
+(defcustom vc-stay-local t
+ "*Non-nil means use local operations when possible for remote repositories.
+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)
+ (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 "22.1"
+:group 'vc)
+
+(defun vc-stay-local-p (file)
+ "Return non-nil if VC should stay local when handling FILE.
+This uses the `repository-hostname' backend operation."
+ (let* ((backend (vc-backend file))
+ (sym (vc-make-backend-sym backend 'stay-local))
+ (stay-local (if (boundp sym) (symbol-value sym) t)))
+ (if (eq stay-local t) (setq stay-local vc-stay-local))
+ (if (symbolp stay-local) stay-local
+ (let ((dirname (if (file-directory-p file)
+ (directory-file-name file)
+ (file-name-directory file))))
+ (eq 'yes
+ (or (vc-file-getprop dirname 'vc-stay-local-p)
+ (vc-file-setprop
+ dirname 'vc-stay-local-p
+ (let ((hostname (vc-call-backend
+ backend 'repository-hostname dirname)))
+ (if (not hostname)
+ 'no
+ (let ((default t))
+ (if (eq (car-safe stay-local) 'except)
+ (setq default nil stay-local (cdr stay-local)))
+ (when (consp stay-local)
+ (setq stay-local
+ (mapconcat 'identity stay-local "\\|")))
+ (if (if (string-match stay-local hostname)
+ default (not default))
+ 'yes 'no)))))))))))
-;; XEmacs:
+;;; This is handled specially now.
+;; Tell Emacs about this new kind of minor mode
+;; XEmacs change: add-to-list 'minor-mode-alist -> add-minor-mode
(add-minor-mode 'vc-mode 'vc-mode)
-(defvar vc-mode nil) ; used for modeline flag
-;; End XEmacs addition.
+;; XEmacs addition: used for modeline flag
+(defvar vc-mode nil)
(make-variable-buffer-local 'vc-mode)
(put 'vc-mode 'permanent-local t)
+(defun vc-mode (&optional arg)
+ ;; Dummy function for C-h m
+ "Version Control minor mode.
+This minor mode is automatically activated whenever you visit a file under
+control of one of the revision control systems in `vc-handled-backends'.
+VC commands are globally reachable under the prefix `\\[vc-prefix-map]':
+\\{vc-prefix-map}")
+
+(defmacro vc-error-occurred (&rest body)
+ `(condition-case nil (progn , at body nil) (error t)))
+
;; We need a notion of per-file properties because the version
;; control state of a file is expensive to derive --- we compute
-;; them when the file is initially found, keep them up to date
+;; them when the file is initially found, keep them up to date
;; during any subsequent VC operations, and forget them when
;; the buffer is killed.
-(defmacro vc-error-occurred (&rest body)
- (list 'condition-case nil (cons 'progn (append body '(nil))) '(error t)))
-
-(defvar vc-file-prop-obarray [0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0]
+(defvar vc-file-prop-obarray (make-vector 17 0)
"Obarray for per-file properties.")
-(defvar vc-buffer-backend t)
-(make-variable-buffer-local 'vc-buffer-backend)
+(defvar vc-touched-properties nil)
(defun vc-file-setprop (file property value)
- ;; set per-file property
+ "Set per-file VC PROPERTY for FILE to VALUE."
+ (if (and vc-touched-properties
+ (not (memq property vc-touched-properties)))
+ (setq vc-touched-properties (append (list property)
+ vc-touched-properties)))
(put (intern file vc-file-prop-obarray) property value))
(defun vc-file-getprop (file property)
- ;; get per-file property
+ "Get per-file VC PROPERTY for FILE."
(get (intern file vc-file-prop-obarray) property))
(defun vc-file-clearprops (file)
- ;; clear all properties of a given file
+ "Clear all VC properties of FILE."
(setplist (intern file vc-file-prop-obarray) nil))
-
-;;; Functions that determine property values, by examining the
-;;; working file, the master file, or log program output
-(defun vc-match-substring (bn)
- (buffer-substring (match-beginning bn) (match-end bn)))
-
-(defun vc-lock-file (file)
- ;; Generate lock file name corresponding to FILE
- (let ((master (vc-name file)))
- (and
- master
- (string-match "\\(.*/\\)s\\.\\(.*\\)" master)
- (concat
- (substring master (match-beginning 1) (match-end 1))
- "p."
- (substring master (match-beginning 2) (match-end 2))))))
-
-(defun vc-parse-buffer (patterns &optional file properties)
- ;; Use PATTERNS to parse information out of the current buffer.
- ;; Each element of PATTERNS is a list of 2 to 3 elements. The first element
- ;; is the pattern to be matched, and the second (an integer) is the
- ;; number of the subexpression that should be returned. If there's
- ;; a third element (also the number of a subexpression), that
- ;; subexpression is assumed to be a date field and we want the most
- ;; recent entry matching the template; this works for RCS format dates only.
- ;; If FILE and PROPERTIES are given, the latter must be a list of
- ;; properties of the same length as PATTERNS; each property is assigned
- ;; the corresponding value.
- (mapcar (function (lambda (p)
- (goto-char (point-min))
- (cond
- ((eq (length p) 2) ;; search for first entry
- (let ((value nil))
- (if (re-search-forward (car p) nil t)
- (setq value (vc-match-substring (elt p 1))))
- (if file
- (progn (vc-file-setprop file (car properties) value)
- (setq properties (cdr properties))))
- value))
- ((eq (length p) 3) ;; search for latest entry
- (let ((latest-date "") (latest-val))
- (while (re-search-forward (car p) nil t)
- (let ((date (vc-match-substring (elt p 2))))
- ;; Most (but not all) versions of RCS use two-digit years
- ;; to represent dates in the range 1900 through 1999.
- ;; The two-digit and four-digit notations can both appear
- ;; in the same file. Normalize the two-digit versions.
- (save-match-data
- (if (string-match "\\`[0-9][0-9]\\." date)
- (setq date (concat "19" date))))
- (if (string< latest-date date)
- (progn
- (setq latest-date date)
- (setq latest-val
- (vc-match-substring (elt p 1)))))))
- (if file
- (progn (vc-file-setprop file (car properties) latest-val)
- (setq properties (cdr properties))))
- latest-val)))))
- patterns)
- )
+
+;; We keep properties on each symbol naming a backend as follows:
+;; * `vc-functions': an alist mapping vc-FUNCTION to vc-BACKEND-FUNCTION.
+
+(defun vc-make-backend-sym (backend sym)
+ "Return BACKEND-specific version of VC symbol SYM."
+ (intern (concat "vc-" (downcase (symbol-name backend))
+ "-" (symbol-name sym))))
+
+(defun vc-find-backend-function (backend fun)
+ "Return BACKEND-specific implementation of FUN.
+If there is no such implementation, return the default implementation;
+if that doesn't exist either, return nil."
+ (let ((f (vc-make-backend-sym backend fun)))
+ (if (fboundp f) f
+ ;; Load vc-BACKEND.el if needed.
+ (require (intern (concat "vc-" (downcase (symbol-name backend)))))
+ (if (fboundp f) f
+ (let ((def (vc-make-backend-sym 'default fun)))
+ (if (fboundp def) (cons def backend) nil))))))
+
+(defun vc-call-backend (backend function-name &rest args)
+ "Call for BACKEND the implementation of FUNCTION-NAME with the given ARGS.
+Calls
+
+ (apply 'vc-BACKEND-FUN ARGS)
+
+if vc-BACKEND-FUN exists (after trying to find it in vc-BACKEND.el)
+and else calls
+
+ (apply 'vc-default-FUN BACKEND ARGS)
+
+It is usually called via the `vc-call' macro."
+ (let ((f (assoc function-name (get backend 'vc-functions))))
+ (if f (setq f (cdr f))
+ (setq f (vc-find-backend-function backend function-name))
+ (push (cons function-name f) (get backend 'vc-functions)))
+ (cond
+ ((null f)
+ (error "Sorry, %s is not implemented for %s" function-name backend))
+ ((consp f) (apply (car f) (cdr f) args))
+ (t (apply f args)))))
+
+(defmacro vc-call (fun file &rest args)
+ ;; BEWARE!! `file' is evaluated twice!!
+ `(vc-call-backend (vc-backend ,file) ',fun ,file , at args))
+
+(defsubst vc-parse-buffer (pattern i)
+ "Find PATTERN in the current buffer and return its Ith submatch."
+ (goto-char (point-min))
+ (if (re-search-forward pattern nil t)
+ (match-string i)))
(defun vc-insert-file (file &optional limit blocksize)
- ;; Insert the contents of FILE into the current buffer.
- ;; Optional argument LIMIT is a regexp. If present,
- ;; the file is inserted in chunks of size BLOCKSIZE
- ;; (default 8 kByte), until the first occurrence of
- ;; LIMIT is found. The function returns nil if FILE
- ;; doesn't exist.
+ "Insert the contents of FILE into the current buffer.
+
+Optional argument LIMIT is a regexp. If present, the file is inserted
+in chunks of size BLOCKSIZE (default 8 kByte), until the first
+occurrence of LIMIT is found. Anything from the start of that occurrence
+to the end of the buffer is then deleted. The function returns
+non-nil if FILE exists and its contents were successfully inserted."
(erase-buffer)
- (cond ((file-exists-p file)
- (cond (limit
- (if (not blocksize) (setq blocksize 8192))
- (let (found s)
- (while (not found)
- (setq s (buffer-size))
- (goto-char (1+ s))
- (setq found
- (or (zerop (car (cdr
- (insert-file-contents file nil s
- (+ s blocksize)))))
- (progn (beginning-of-line)
- (re-search-forward limit nil t)))))))
- (t (insert-file-contents file)))
- (set-buffer-modified-p nil)
- (auto-save-mode nil)
- t)
- (t nil)))
-
-(defun vc-parse-locks (file locks)
- ;; Parse RCS or SCCS locks.
- ;; The result is a list of the form ((VERSION USER) (VERSION USER) ...),
- ;; which is returned and stored into the property `vc-master-locks'.
- (if (not locks)
- (vc-file-setprop file 'vc-master-locks 'none)
- (let ((found t) (index 0) master-locks version user)
- (cond ((eq (vc-backend file) 'SCCS)
- (while (string-match "^\\([0-9.]+\\) [0-9.]+ \\([^ ]+\\) .*\n?"
- locks index)
- (setq version (substring locks
- (match-beginning 1) (match-end 1)))
- (setq user (substring locks
- (match-beginning 2) (match-end 2)))
- (setq master-locks (append master-locks
- (list (cons version user))))
- (setq index (match-end 0))))
- ((eq (vc-backend file) 'RCS)
- (while (string-match "[ \t\n]*\\([^:]+\\):\\([0-9.]+\\)"
- locks index)
- (setq version (substring locks
- (match-beginning 2) (match-end 2)))
- (setq user (substring locks
- (match-beginning 1) (match-end 1)))
- (setq master-locks (append master-locks
- (list (cons version user))))
- (setq index (match-end 0)))
- (if (string-match ";[ \t\n]+strict;" locks index)
- (vc-file-setprop file 'vc-checkout-model 'manual)
- (vc-file-setprop file 'vc-checkout-model 'implicit))))
- (vc-file-setprop file 'vc-master-locks (or master-locks 'none)))))
-
-(defun vc-simple-command (okstatus command file &rest args)
- ;; Simple version of vc-do-command, for use in vc-hooks only.
- ;; Don't switch to the *vc-info* buffer before running the
- ;; command, because that would change its default directory
- (save-excursion (set-buffer (get-buffer-create "*vc-info*"))
- (erase-buffer))
- (let ((exec-path (append vc-path exec-path)) exec-status
- ;; Add vc-path to PATH for the execution of this command.
- (process-environment
- (cons (concat "PATH=" (getenv "PATH")
- path-separator
- (mapconcat 'identity vc-path path-separator))
- process-environment)))
- (setq exec-status
- (apply 'call-process command nil "*vc-info*" nil
- (append args (list file))))
- (cond ((> exec-status okstatus)
- (switch-to-buffer (get-file-buffer file))
- (shrink-window-if-larger-than-buffer
- (display-buffer "*vc-info*"))
- (error "Couldn't find version control information")))
- exec-status))
-
-(defun vc-parse-cvs-status (&optional full)
- ;; Parse output of "cvs status" command in the current buffer and
- ;; 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 (concat default-directory (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-cvs-status 'up-to-date)
- (vc-file-setprop file 'vc-checkout-time
- (nth 5 (file-attributes file))))
- ((vc-file-setprop file 'vc-cvs-status
- (cond
- ((string-match "Locally Modified" status) 'locally-modified)
- ((string-match "Needs Merge" status) 'needs-merge)
- ((string-match "Needs \\(Checkout\\|Patch\\)" status)
- 'needs-checkout)
- ((string-match "Unresolved Conflict" status)
- 'unresolved-conflict)
- ((string-match "File had conflicts on merge" status)
- 'unresolved-conflict)
- ((string-match "Locally Added" status) 'locally-added)
- ((string-match "New file!" status) 'locally-added)
- (t 'unknown))))))))))
-
-(defun vc-fetch-master-properties (file)
- ;; Fetch those properties of FILE that are stored in the master file.
- ;; For an RCS file, we don't get vc-latest-version vc-your-latest-version
- ;; here because that is slow.
- ;; That gets done if/when the functions vc-latest-version
- ;; and vc-your-latest-version get called.
- (save-excursion
+ (when (file-exists-p file)
+ (if (not limit)
+ (insert-file-contents file)
+ (if (not blocksize) (setq blocksize 8192))
+ (let ((filepos 0))
+ (while
+ (and (< 0 (cadr (insert-file-contents
+ file nil filepos (incf filepos blocksize))))
+ (progn (beginning-of-line)
+ (let ((pos (re-search-forward limit nil 'move)))
+ (if pos (delete-region (match-beginning 0)
+ (point-max)))
+ (not pos)))))))
+ (set-buffer-modified-p nil)
+ t))
+
+(defun vc-find-root (file witness)
+ "Find the root of a checked out project.
+The function walks up the directory tree from FILE looking for WITNESS.
+If WITNESS if not found, return nil, otherwise return the root."
+ ;; Represent /home/luser/foo as ~/foo so that we don't try to look for
+ ;; witnesses in /home or in /.
+ ;; XEmacs: 2nd arg to `abbreviate-file-name' to match GNU functionality
+ (setq file (abbreviate-file-name file t))
+ (let ((root nil)
+ (user (nth 2 (file-attributes file))))
+ (while (not (or root
+ (equal file (setq file (file-name-directory file)))
+ (null file)
+ ;; As a heuristic, we stop looking up the hierarchy of
+ ;; directories as soon as we find a directory belonging
+ ;; to another user. This should save us from looking in
+ ;; things like /net and /afs. This assumes that all the
+ ;; files inside a project belong to the same user.
+ (not (equal user (nth 2 (file-attributes file))))
+ (string-match vc-ignore-dir-regexp file)))
+ (if (file-exists-p (expand-file-name witness file))
+ (setq root file)
+ (setq file (directory-file-name file))))
+ root))
+
+;; Access functions to file properties
+;; (Properties should be _set_ using vc-file-setprop, but
+;; _retrieved_ only through these functions, which decide
+;; if the property is already known or not. A property should
+;; only be retrieved by vc-file-getprop if there is no
+;; access function.)
+
+;; properties indicating the backend being used for FILE
+
+(defun vc-registered (file)
+ "Return non-nil if FILE is registered in a version control system.
+
+This function performs the check each time it is called. To rely
+on the result of a previous call, use `vc-backend' instead. If the
+file was previously registered under a certain backend, then that
+backend is tried first."
+ (let (handler)
(cond
- ((eq (vc-backend file) 'SCCS)
- (set-buffer (get-buffer-create "*vc-info*"))
- (if (vc-insert-file (vc-lock-file file))
- (vc-parse-locks file (buffer-string))
- (vc-file-setprop file 'vc-master-locks 'none))
- (vc-insert-file (vc-name file) "^\001e")
- (vc-parse-buffer
- (list '("^\001d D \\([^ ]+\\)" 1)
- (list (concat "^\001d D \\([^ ]+\\) .* "
- (regexp-quote (vc-user-login-name)) " ") 1))
- file
- '(vc-latest-version vc-your-latest-version)))
-
- ((eq (vc-backend file) 'RCS)
- (set-buffer (get-buffer-create "*vc-info*"))
- (vc-insert-file (vc-name file) "^[0-9]")
- (vc-parse-buffer
- (list '("^head[ \t\n]+\\([^;]+\\);" 1)
- '("^branch[ \t\n]+\\([^;]+\\);" 1)
- '("^locks[ \t\n]*\\([^;]*;\\([ \t\n]*strict;\\)?\\)" 1))
- file
- '(vc-head-version
- vc-default-branch
- vc-master-locks))
- ;; determine vc-master-workfile-version: it is either the head
- ;; of the trunk, the head of the default branch, or the
- ;; "default branch" itself, if that is a full revision number.
- (let ((default-branch (vc-file-getprop file 'vc-default-branch)))
- (cond
- ;; no default branch
- ((or (not default-branch) (string= "" default-branch))
- (vc-file-setprop file 'vc-master-workfile-version
- (vc-file-getprop file 'vc-head-version)))
- ;; default branch is actually a revision
- ((string-match "^[0-9]+\\.[0-9]+\\(\\.[0-9]+\\.[0-9]+\\)*$"
- default-branch)
- (vc-file-setprop file 'vc-master-workfile-version default-branch))
- ;; else, search for the head of the default branch
- (t (vc-insert-file (vc-name file) "^desc")
- (vc-parse-buffer (list (list
- (concat "^\\("
- (regexp-quote default-branch)
- "\\.[0-9]+\\)\ndate[ \t]+\\([0-9.]+\\);") 1 2))
- file '(vc-master-workfile-version)))))
- ;; translate the locks
- (vc-parse-locks file (vc-file-getprop file 'vc-master-locks)))
+ ((string-match vc-ignore-dir-regexp (file-name-directory file)) nil)
+ ((and (boundp 'file-name-handler-alist)
+ (setq handler (find-file-name-handler file 'vc-registered)))
+ ;; handler should set vc-backend and return t if registered
+ (funcall handler 'vc-registered file))
+ (t
+ ;; There is no file name handler.
+ ;; Try vc-BACKEND-registered for each handled BACKEND.
+ (catch 'found
+ (let ((backend (vc-file-getprop file 'vc-backend)))
+ (mapcar
+ (lambda (b)
+ ;; XEmacs change: autoload-embedded registered functions
+ ;; renamed to registered-lite due to 21.4 byte compiler or
+ ;; byte interpreter issues when/if the real -registered is
+ ;; redefined while executing the fully autoloaded version.
+ (and (if (fboundp (vc-make-backend-sym b 'registered))
+ (vc-call-backend b 'registered file)
+ (vc-call-backend b 'registered-lite file))
+ (vc-file-setprop file 'vc-backend b)
+ (throw 'found t)))
+ (if (or (not backend) (eq backend 'none))
+ vc-handled-backends
+ (cons backend vc-handled-backends))))
+ ;; File is not registered.
+ (vc-file-setprop file 'vc-backend 'none)
+ nil)))))
- ((eq (vc-backend file) 'CVS)
- (save-excursion
- ;; Call "cvs status" in the right directory, passing only the
- ;; nondirectory part of the file name -- otherwise CVS might
- ;; silently give a wrong result.
- (let ((default-directory (file-name-directory file)))
- (vc-simple-command
- 0 vc-cvs-program (file-name-nondirectory file) "status"))
- (set-buffer (get-buffer "*vc-info*"))
- (vc-parse-cvs-status t))))
- (if (get-buffer "*vc-info*")
- (kill-buffer (get-buffer "*vc-info*")))))
-
-;;; Functions that determine property values, by examining the
-;;; working file, the master file, or log program output
-
-(defun vc-consult-rcs-headers (file)
- ;; Search for RCS headers in FILE, and set properties
- ;; accordingly. This function can be disabled by setting
- ;; vc-consult-headers to nil.
- ;; Returns: nil if no headers were found
- ;; (or if the feature is disabled,
- ;; or if there is currently no buffer
- ;; visiting FILE)
- ;; 'rev if a workfile revision was found
- ;; 'rev-and-lock if revision and lock info was found
- (cond
- ((or (not vc-consult-headers)
- (not (get-file-buffer file))) nil)
- ((let (status version locking-user)
- (save-excursion
- (set-buffer (get-file-buffer file))
- (goto-char (point-min))
- (cond
- ;; search for $Id or $Header
- ;; -------------------------
- ;; The `\ 's below avoid an RCS 5.7 bug when checking in this file.
- ((or (and (search-forward "$Id\ : " nil t)
- (looking-at "[^ ]+ \\([0-9.]+\\) "))
- (and (progn (goto-char (point-min))
- (search-forward "$Header\ : " nil t))
- (looking-at "[^ ]+ \\([0-9.]+\\) ")))
- (goto-char (match-end 0))
- ;; if found, store the revision number ...
- (setq version (buffer-substring-no-properties (match-beginning 1)
- (match-end 1)))
- ;; ... and check for the locking state
- (cond
- ((looking-at
- (concat "[0-9]+[/-][01][0-9][/-][0-3][0-9] " ; date
- "[0-2][0-9]:[0-5][0-9]+:[0-6][0-9]+\\([+-][0-9:]+\\)? " ; time
- "[^ ]+ [^ ]+ ")) ; author & state
- (goto-char (match-end 0)) ; [0-6] in regexp handles leap seconds
- (cond
- ;; unlocked revision
- ((looking-at "\\$")
- (setq locking-user 'none)
- (setq status 'rev-and-lock))
- ;; revision is locked by some user
- ((looking-at "\\([^ ]+\\) \\$")
- (setq locking-user
- (buffer-substring-no-properties (match-beginning 1)
- (match-end 1)))
- (setq status 'rev-and-lock))
- ;; everything else: false
- (nil)))
- ;; unexpected information in
- ;; keyword string --> quit
- (nil)))
- ;; search for $Revision
- ;; --------------------
- ((re-search-forward (concat "\\$"
- "Revision: \\([0-9.]+\\) \\$")
- nil t)
- ;; if found, store the revision number ...
- (setq version (buffer-substring-no-properties (match-beginning 1)
- (match-end 1)))
- ;; and see if there's any lock information
- (goto-char (point-min))
- (if (re-search-forward (concat "\\$" "Locker:") nil t)
- (cond ((looking-at " \\([^ ]+\\) \\$")
- (setq locking-user (buffer-substring-no-properties
- (match-beginning 1)
- (match-end 1)))
- (setq status 'rev-and-lock))
- ((looking-at " *\\$")
- (setq locking-user 'none)
- (setq status 'rev-and-lock))
- (t
- (setq locking-user 'none)
- (setq status 'rev-and-lock)))
- (setq status 'rev)))
- ;; else: nothing found
- ;; -------------------
- (t nil)))
- (if status (vc-file-setprop file 'vc-workfile-version version))
- (and (eq status 'rev-and-lock)
- (eq (vc-backend file) 'RCS)
- (vc-file-setprop file 'vc-locking-user locking-user)
- ;; If the file has headers, we don't want to query the master file,
- ;; because that would eliminate all the performance gain the headers
- ;; brought us. We therefore use a heuristic for the checkout model
- ;; now: If we trust the file permissions, and the file is not
- ;; locked, then if the file is read-only the checkout model is
- ;; `manual', otherwise `implicit'.
- (not (vc-mistrust-permissions file))
- (not (vc-locking-user file))
- (if (string-match ".r-..-..-." (nth 8 (file-attributes file)))
- (vc-file-setprop file 'vc-checkout-model 'manual)
- (vc-file-setprop file 'vc-checkout-model 'implicit)))
- status))))
-
-;;; Access functions to file properties
-;;; (Properties should be _set_ using vc-file-setprop, but
-;;; _retrieved_ only through these functions, which decide
-;;; if the property is already known or not. A property should
-;;; only be retrieved by vc-file-getprop if there is no
-;;; access function.)
-
-;;; properties indicating the backend
-;;; being used for FILE
-
-(defun vc-backend-subdirectory-name (&optional file)
- ;; Where the master and lock files for the current directory are kept
- (symbol-name
- (or
- (and file (vc-backend file))
- vc-default-back-end
- (setq vc-default-back-end (if (vc-find-binary "rcs") 'RCS 'SCCS)))))
+(defun vc-backend (file)
+ "Return the version control type of FILE, nil if it is not registered."
+ ;; `file' can be nil in several places (typically due to the use of
+ ;; code like (vc-backend buffer-file-name)).
+ (when (stringp file)
+ (let ((property (vc-file-getprop file 'vc-backend)))
+ ;; Note that internally, Emacs remembers unregistered
+ ;; files by setting the property to `none'.
+ (cond ((eq property 'none) nil)
+ (property)
+ ;; vc-registered sets the vc-backend property
+ (t (if (vc-registered file)
+ (vc-file-getprop file 'vc-backend)
+ nil))))))
+
+(defun vc-backend-subdirectory-name (file)
+ "Return where the master and lock FILEs for the current directory are kept."
+ (symbol-name (vc-backend file)))
(defun vc-name (file)
- "Return the master name of a file, nil if it is not registered.
-For CVS, the full name of CVS/Entries is returned."
+ "Return the master name of FILE.
+If the file is not registered, or the master name is not known, return nil."
+ ;; TODO: This should ultimately become obsolete, at least up here
+ ;; in vc-hooks.
(or (vc-file-getprop file 'vc-name)
- ;; Use the caching mechanism of vc-backend, below.
- (if (vc-backend file)
+ ;; force computation of the property by calling
+ ;; vc-BACKEND-registered explicitly
+ (if (and (vc-backend file)
+ (vc-call-backend (vc-backend file) 'registered file))
(vc-file-getprop file 'vc-name))))
-(defun vc-backend (file)
- "Return the version-control type of a file, nil if it is not registered."
- ;; Note that internally, Emacs remembers unregistered
- ;; files by setting the property to `none'.
- (if file
- (let ((property (vc-file-getprop file 'vc-backend))
- (name-and-type))
- (cond ((eq property 'none) nil)
- (property)
- (t (setq name-and-type (vc-registered file))
- (if name-and-type
- (progn
- (vc-file-setprop file 'vc-name (car name-and-type))
- (vc-file-setprop file 'vc-backend (cdr name-and-type)))
- (vc-file-setprop file 'vc-backend 'none)
- nil))))))
-
(defun vc-checkout-model (file)
- ;; Return `manual' if the user has to type C-x C-q to check out FILE.
- ;; Return `implicit' if the file can be modified without locking it first.
- (or
- (vc-file-getprop file 'vc-checkout-model)
- (cond
- ((eq (vc-backend file) 'SCCS)
- (vc-file-setprop file 'vc-checkout-model 'manual))
- ((eq (vc-backend file) 'RCS)
- (vc-consult-rcs-headers file)
- (or (vc-file-getprop file 'vc-checkout-model)
- (progn (vc-fetch-master-properties file)
- (vc-file-getprop file 'vc-checkout-model))))
- ((eq (vc-backend file) 'CVS)
- (vc-file-setprop file 'vc-checkout-model
- (cond
- ((getenv "CVSREAD") 'manual)
- ;; If the file is not writeable, this is probably because the
- ;; file is being "watched" by other developers. Use "manual"
- ;; checkout in this case. (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)))
- 'manual)
- (t 'implicit)))))))
-
-;;; properties indicating the locking state
-
-(defun vc-cvs-status (file)
- ;; Return the cvs status of FILE
- ;; (Status field in output of "cvs status")
- (cond ((vc-file-getprop file 'vc-cvs-status))
- (t (vc-fetch-master-properties file)
- (vc-file-getprop file 'vc-cvs-status))))
-
-(defun vc-master-locks (file)
- ;; Return the lock entries in the master of FILE.
- ;; Return 'none if there are no such entries, and a list
- ;; of the form ((VERSION USER) (VERSION USER) ...) otherwise.
- (cond ((vc-file-getprop file 'vc-master-locks))
- (t (vc-fetch-master-properties file)
- (vc-file-getprop file 'vc-master-locks))))
-
-(defun vc-master-locking-user (file)
- ;; Return the master file's idea of who is locking
- ;; the current workfile version of FILE.
- ;; Return 'none if it is not locked.
- (let ((master-locks (vc-master-locks file)) lock)
- (if (eq master-locks 'none) 'none
- ;; search for a lock on the current workfile version
- (setq lock (assoc (vc-workfile-version file) master-locks))
- (cond (lock (cdr lock))
- ('none)))))
-
-(defun vc-lock-from-permissions (file)
- ;; If the permissions can be trusted for this file, determine the
- ;; locking state from them. Returns (user-login-name), `none', or nil.
- ;; This implementation assumes that any file which is under version
- ;; control and has -rw-r--r-- is locked by its owner. This is true
- ;; for both RCS and SCCS, which keep unlocked files at -r--r--r--.
- ;; We have to be careful not to exclude files with execute bits on;
- ;; scripts can be under version control too. Also, we must ignore the
- ;; group-read and other-read bits, since paranoid users turn them off.
- ;; This hack wins because calls to the somewhat expensive
- ;; `vc-fetch-master-properties' function only have to be made if
- ;; (a) the file is locked by someone other than the current user,
- ;; or (b) some untoward manipulation behind vc's back has changed
- ;; the owner or the `group' or `other' write bits.
- (let ((attributes (file-attributes file)))
- (if (not (vc-mistrust-permissions file))
- (cond ((string-match ".r-..-..-." (nth 8 attributes))
- (vc-file-setprop file 'vc-locking-user 'none))
- ((and (= (nth 2 attributes) (user-uid))
- (string-match ".rw..-..-." (nth 8 attributes)))
- (vc-file-setprop file 'vc-locking-user (vc-user-login-name)))
- (nil)))))
-
-(defun vc-user-login-name (&optional uid)
- ;; Return the name under which the user is logged in, as a string.
- ;; (With optional argument UID, return the name of that user.)
- ;; This function does the same as `user-login-name', but unlike
- ;; that, it never returns nil. If a UID cannot be resolved, that
- ;; UID is returned as a string.
- (or (user-login-name uid)
- (and uid (number-to-string uid))
+ "Indicate how FILE is checked out.
+
+If FILE is not registered, this function always returns nil.
+For registered files, the possible values are:
+
+ 'implicit FILE is always writeable, and checked out `implicitly'
+ when the user saves the first changes to the file.
+
+ 'locking FILE is read-only if up-to-date; user must type
+ \\[vc-next-action] before editing. Strict locking
+ is assumed.
+
+ 'announce FILE is read-only if up-to-date; user must type
+ \\[vc-next-action] before editing. But other users
+ may be editing at the same time."
+ (or (vc-file-getprop file 'vc-checkout-model)
+ (if (vc-backend file)
+ (vc-file-setprop file 'vc-checkout-model
+ (vc-call checkout-model file)))))
+
+(defun vc-user-login-name (file)
+ "Return the name under which the user accesses the given FILE."
+ (or (and (eq (string-match tramp-file-name-regexp file) 0)
+ ;; tramp case: execute "whoami" via tramp
+ (let ((default-directory (file-name-directory file)))
+ (with-temp-buffer
+ (if (not (zerop (process-file "whoami" nil t)))
+ ;; fall through if "whoami" didn't work
+ nil
+ ;; remove trailing newline
+ (delete-region (1- (point-max)) (point-max))
+ (buffer-string)))))
+ ;; normal case
+ (user-login-name)
+ ;; if user-login-name is nil, return the UID as a string
(number-to-string (user-uid))))
-(defun vc-file-owner (file)
- ;; Return who owns FILE (user name, as a string).
- (vc-user-login-name (nth 2 (file-attributes file))))
-
-(defun vc-rcs-lock-from-diff (file)
- ;; Diff the file against the master version. If differences are found,
- ;; mark the file locked. This is only used for RCS with non-strict
- ;; locking. (If "rcsdiff" doesn't understand --brief, we do a double-take
- ;; and remember the fact for the future.)
- (let* ((version (concat "-r" (vc-workfile-version file)))
- (status (if (eq vc-rcsdiff-knows-brief 'no)
- (vc-simple-command 1 "rcsdiff" file version)
- (vc-simple-command 2 "rcsdiff" file "--brief" version))))
- (if (eq status 2)
- (if (not vc-rcsdiff-knows-brief)
- (setq vc-rcsdiff-knows-brief 'no
- status (vc-simple-command 1 "rcsdiff" file version))
- (error "rcsdiff failed."))
- (if (not vc-rcsdiff-knows-brief) (setq vc-rcsdiff-knows-brief 'yes)))
- (if (zerop status)
- (vc-file-setprop file 'vc-locking-user 'none)
- (vc-file-setprop file 'vc-locking-user (vc-file-owner file)))))
-
-(defun vc-locking-user (file)
- ;; Return the name of the person currently holding a lock on FILE.
- ;; Return nil if there is no such person.
- ;; Under CVS, a file is considered locked if it has been modified since
- ;; it was checked out.
- ;; The property is cached. It is only looked up if it is currently nil.
- ;; Note that, for a file that is not locked, the actual property value
- ;; is `none', to distinguish it from an unknown locking state. That value
- ;; is converted to nil by this function, and returned to the caller.
- (let ((locking-user (vc-file-getprop file 'vc-locking-user)))
- (if locking-user
- ;; if we already know the property, return it
- (if (eq locking-user 'none) nil locking-user)
-
- ;; otherwise, infer the property...
- (cond
- ((eq (vc-backend file) 'CVS)
- (or (and (eq (vc-checkout-model file) 'manual)
- (vc-lock-from-permissions file))
- (and (equal (vc-file-getprop file 'vc-checkout-time)
- (nth 5 (file-attributes file)))
- (vc-file-setprop file 'vc-locking-user 'none))
- (vc-file-setprop file 'vc-locking-user (vc-file-owner file))))
-
- ((eq (vc-backend file) 'RCS)
- (let (p-lock)
-
- ;; Check for RCS headers first
- (or (eq (vc-consult-rcs-headers file) 'rev-and-lock)
-
- ;; If there are no headers, try to learn it
- ;; from the permissions.
- (and (setq p-lock (vc-lock-from-permissions file))
- (if (eq p-lock 'none)
-
- ;; If the permissions say "not locked", we know
- ;; that the checkout model must be `manual'.
- (vc-file-setprop file 'vc-checkout-model 'manual)
-
- ;; If the permissions say "locked", we can only trust
- ;; this *if* the checkout model is `manual'.
- (eq (vc-checkout-model file) 'manual)))
-
- ;; Otherwise, use lock information from the master file.
- (vc-file-setprop file 'vc-locking-user
- (vc-master-locking-user file)))
-
- ;; Finally, if the file is not explicitly locked
- ;; it might still be locked implicitly.
- (and (eq (vc-file-getprop file 'vc-locking-user) 'none)
- (eq (vc-checkout-model file) 'implicit)
- (vc-rcs-lock-from-diff file))))
-
- ((eq (vc-backend file) 'SCCS)
- (or (vc-lock-from-permissions file)
- (vc-file-setprop file 'vc-locking-user
- (vc-master-locking-user file)))))
-
- ;; convert a possible 'none value
- (setq locking-user (vc-file-getprop file 'vc-locking-user))
- (if (eq locking-user 'none) nil locking-user))))
-
-;;; properties to store current and recent version numbers
-
-(defun vc-latest-version (file)
- ;; Return version level of the latest version of FILE
- (cond ((vc-file-getprop file 'vc-latest-version))
- (t (vc-fetch-properties file)
- (vc-file-getprop file 'vc-latest-version))))
-
-(defun vc-your-latest-version (file)
- ;; Return version level of the latest version of FILE checked in by you
- (cond ((vc-file-getprop file 'vc-your-latest-version))
- (t (vc-fetch-properties file)
- (vc-file-getprop file 'vc-your-latest-version))))
-
-(defun vc-master-workfile-version (file)
- ;; Return the master file's idea of what is the current workfile version.
- ;; This property is defined for RCS only.
- (cond ((vc-file-getprop file 'vc-master-workfile-version))
- (t (vc-fetch-master-properties file)
- (vc-file-getprop file 'vc-master-workfile-version))))
-
-(defun vc-fetch-properties (file)
- ;; Fetch vc-latest-version and vc-your-latest-version
- ;; if that wasn't already done.
- (cond
- ((eq (vc-backend file) 'RCS)
- (save-excursion
- (set-buffer (get-buffer-create "*vc-info*"))
- (vc-insert-file (vc-name file) "^desc")
- (vc-parse-buffer
- (list '("^\\([0-9]+\\.[0-9.]+\\)\ndate[ \t]+\\([0-9.]+\\);" 1 2)
- (list (concat "^\\([0-9]+\\.[0-9.]+\\)\n"
- "date[ \t]+\\([0-9.]+\\);[ \t]+"
- "author[ \t]+"
- (regexp-quote (vc-user-login-name)) ";") 1 2))
- file
- '(vc-latest-version vc-your-latest-version))
- (if (get-buffer "*vc-info*")
- (kill-buffer (get-buffer "*vc-info*")))))
- (t (vc-fetch-master-properties file))
- ))
+(defun vc-state (file)
+ "Return the version control state of FILE.
+
+If FILE is not registered, this function always returns nil.
+For registered files, the value returned is one of:
+
+ 'up-to-date The working file is unmodified with respect to the
+ latest version on the current branch, and not locked.
+
+ 'edited The working file has been edited by the user. If
+ locking is used for the file, this state means that
+ the current version is locked by the calling user.
+
+ USER The current version of the working file is locked by
+ some other USER (a string).
+
+ 'needs-patch The file has not been edited by the user, but there is
+ a more recent version on the current branch stored
+ in the master file.
+
+ 'needs-merge The file has been edited by the user, and there is also
+ a more recent version on the current branch stored in
+ the master file. This state can only occur if locking
+ is not used for the file.
+
+ 'unlocked-changes The current version of the working file is not locked,
+ but the working file has been changed with respect
+ to that version. This state can only occur for files
+ with locking; it represents an erroneous condition that
+ should be resolved by the user (vc-next-action will
+ prompt the user to do it)."
+ ;; FIXME: New (sub)states needed (?):
+ ;; - `added' (i.e. `edited' but with no base version yet,
+ ;; typically represented by vc-workfile-version = "0")
+ ;; - `conflict' (i.e. `edited' with conflict markers)
+ ;; - `removed'
+ ;; - `copied' and `moved' (might be handled by `removed' and `added')
+ (or (vc-file-getprop file 'vc-state)
+ (if (vc-backend file)
+ (vc-file-setprop file 'vc-state
+ (vc-call state-heuristic file)))))
+(defun vc-recompute-state (file)
+ "Recompute the version control state of FILE, and return it.
+This calls the possibly expensive function vc-BACKEND-state,
+rather than the heuristic."
+ (vc-file-setprop file 'vc-state (vc-call state file)))
+
+(defsubst vc-up-to-date-p (file)
+ "Convenience function that checks whether `vc-state' of FILE is `up-to-date'."
+ (eq (vc-state file) 'up-to-date))
+
+(defun vc-default-state-heuristic (backend file)
+ "Default implementation of vc-state-heuristic.
+It simply calls the real state computation function `vc-BACKEND-state'
+and does not employ any heuristic at all."
+ (vc-call-backend backend 'state file))
+
+(defun vc-workfile-unchanged-p (file)
+ "Return non-nil if FILE has not changed since the last checkout."
+ (let ((checkout-time (vc-file-getprop file 'vc-checkout-time))
+ (lastmod (nth 5 (file-attributes file))))
+ (if (and checkout-time
+ ;; Tramp and Ange-FTP return this when they don't know the time.
+ (not (equal lastmod '(0 0))))
+ (equal checkout-time lastmod)
+ (let ((unchanged (vc-call workfile-unchanged-p file)))
+ (vc-file-setprop file 'vc-checkout-time (if unchanged lastmod 0))
+ unchanged))))
+
+(defun vc-default-workfile-unchanged-p (backend file)
+ "Check if FILE is unchanged by diffing against the master version.
+Return non-nil if FILE is unchanged."
+ (zerop (condition-case err
+ ;; If the implementation supports it, let the output
+ ;; go to *vc*, not *vc-diff*, since this is an internal call.
+ (vc-call diff file nil nil "*vc*")
+ (wrong-number-of-arguments
+ ;; If this error came from the above call to vc-BACKEND-diff,
+ ;; 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)
+ 'diff))))
+ (not (eq (caddr err) 4)))
+ (signal (car err) (cdr err))
+ (vc-call diff file))))))
+
(defun vc-workfile-version (file)
- ;; Return version level of the current workfile FILE
- ;; This is attempted by first looking at the RCS keywords.
- ;; If there are no keywords in the working file,
- ;; vc-master-workfile-version is taken.
- ;; Note that this property is cached, that is, it is only
- ;; looked up if it is nil.
- ;; For SCCS, this property is equivalent to vc-latest-version.
- (cond ((vc-file-getprop file 'vc-workfile-version))
- ((eq (vc-backend file) 'SCCS) (vc-latest-version file))
- ((eq (vc-backend file) 'RCS)
- (if (vc-consult-rcs-headers file)
- (vc-file-getprop file 'vc-workfile-version)
- (let ((rev (cond ((vc-master-workfile-version file))
- ((vc-latest-version file)))))
- (vc-file-setprop file 'vc-workfile-version rev)
- rev)))
- ((eq (vc-backend file) 'CVS)
- (if (vc-consult-rcs-headers file) ;; CVS
- (vc-file-getprop file 'vc-workfile-version)
- (catch 'found
- (vc-find-cvs-master (file-name-directory file)
- (file-name-nondirectory file)))
- (vc-file-getprop file 'vc-workfile-version)))))
+ "Return the version level of the current workfile FILE.
+If FILE is not registered, this function always returns nil."
+ (or (vc-file-getprop file 'vc-workfile-version)
+ (if (vc-backend file)
+ (vc-file-setprop file 'vc-workfile-version
+ (vc-call workfile-version file)))))
-;;; actual version-control code starts here
+(defun vc-default-registered (backend file)
+ "Check if FILE is registered in BACKEND using vc-BACKEND-master-templates."
+ (let ((sym (vc-make-backend-sym backend 'master-templates)))
+ (unless (get backend 'vc-templates-grabbed)
+ (put backend 'vc-templates-grabbed t)
+ (set sym (append (delq nil
+ (mapcar
+ (lambda (template)
+ (and (consp template)
+ (eq (cdr template) backend)
+ (car template)))
+ (with-no-warnings
+ vc-master-templates)))
+ (symbol-value sym))))
+ (let ((result (vc-check-master-templates file (symbol-value sym))))
+ (if (stringp result)
+ (vc-file-setprop file 'vc-name result)
+ nil)))) ; Not registered
-(defun vc-registered (file)
- (let (handler handlers)
- (if (boundp 'file-name-handler-alist)
- (setq handler (find-file-name-handler file 'vc-registered)))
- (if handler
- (funcall handler 'vc-registered file)
- ;; Search for a master corresponding to the given file
- (let ((dirname (or (file-name-directory file) ""))
- (basename (file-name-nondirectory file)))
- (catch 'found
- (mapcar
- (function (lambda (s)
- (if (atom s)
- (funcall s dirname basename)
- (let ((trial (format (car s) dirname basename)))
- (if (and (file-exists-p trial)
- ;; Make sure the file we found with name
- ;; TRIAL is not the source file itself.
- ;; That can happen with RCS-style names
- ;; if the file name is truncated
- ;; (e.g. to 14 chars). See if either
- ;; directory or attributes differ.
- (or (not (string= dirname
- (file-name-directory trial)))
- (not (equal
- (file-attributes file)
- (file-attributes trial)))))
- (throw 'found (cons trial (cdr s))))))))
- vc-master-templates)
- nil)))))
-
-(defun vc-sccs-project-dir ()
- ;; Return the full pathname of the SCCS PROJECTDIR, if it exists,
- ;; otherwise nil. The PROJECTDIR is indicated by the environment
- ;; variable of the same name. If its value starts with a slash,
- ;; it must be an absolute path name that points to the
- ;; directory where SCCS history files reside. If it does not
- ;; begin with a slash, it is taken as the name of a user,
- ;; and history files reside in an "src" or "source" subdirectory
- ;; of that user's home directory.
- (let ((project-dir (getenv "PROJECTDIR")))
- (and project-dir
- (if (eq (elt project-dir 0) ?/)
- (if (file-exists-p (concat project-dir "/SCCS"))
- (concat project-dir "/SCCS/")
- (if (file-exists-p project-dir)
- project-dir))
- (setq project-dir (expand-file-name (concat "~" project-dir)))
- (let (trial)
- (setq trial (concat project-dir "/src/SCCS"))
- (if (file-exists-p trial)
- (concat trial "/")
- (setq trial (concat project-dir "/src"))
- (if (file-exists-p trial)
- (concat trial "/")
- (setq trial (concat project-dir "/source/SCCS"))
- (if (file-exists-p trial)
- (concat trial "/")
- (setq trial (concat project-dir "/source/"))
- (if (file-exists-p trial)
- (concat trial "/"))))))))))
-
-(defun vc-search-sccs-project-dir (dirname basename)
- ;; Check if there is a master file for BASENAME in the
- ;; SCCS project directory. If yes, throw `found' as
- ;; expected by vc-registered. If not, return nil.
- (let* ((project-dir (vc-sccs-project-dir))
- (master-file (and project-dir (concat project-dir "s." basename))))
- (and master-file
- (file-exists-p master-file)
- (throw 'found (cons master-file 'SCCS)))))
-
-(defun vc-find-cvs-master (dirname basename)
- ;; Check if DIRNAME/BASENAME is handled by CVS.
- ;; If it is, do a (throw 'found (cons MASTER-FILE 'CVS)).
- ;; Note: This function throws the name of CVS/Entries
- ;; NOT that of the RCS master file (because we wouldn't be able
- ;; to access it under remote CVS).
- ;; The function returns nil if DIRNAME/BASENAME is not handled by CVS.
- (if (and vc-handle-cvs
- (file-directory-p (concat dirname "CVS/"))
- (file-readable-p (concat dirname "CVS/Entries")))
- (let ((file (concat dirname basename))
- buffer)
- (unwind-protect
- (save-excursion
- (setq buffer (set-buffer (get-buffer-create "*vc-info*")))
- (vc-insert-file (concat dirname "CVS/Entries"))
- (goto-char (point-min))
- ;; make sure that the file name is searched
- ;; case-sensitively - case-fold-search is a buffer-local
- ;; variable, so setting it here won't affect any other buffers
- (setq case-fold-search nil)
- (cond
- ;; entry for a "locally added" file (not yet committed)
- ((re-search-forward
- (concat "^/" (regexp-quote basename) "/0/") nil t)
- (vc-file-setprop file 'vc-checkout-time 0)
- (vc-file-setprop file 'vc-workfile-version "0")
- (throw 'found (cons (concat dirname "CVS/Entries") 'CVS)))
- ;; normal entry
- ((re-search-forward
- (concat "^/" (regexp-quote basename)
- ;; 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
- "\\(+[^/]*\\)?/")
- nil t)
- ;; We found it. Store away version number now that we
- ;; are anyhow so close to finding it.
- (vc-file-setprop file
- 'vc-workfile-version
- (match-string 1))
- ;; If the file hasn't been modified since checkout,
- ;; store the checkout-time.
- (let ((mtime (nth 5 (file-attributes file)))
- (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))))
- (if (equal mtime
- (encode-time
- second minute hour day
- (/ (string-match
- (match-string 2)
- "xxxJanFebMarAprMayJunJulAugSepOctNovDec")
- 3)
- year 0))
- (vc-file-setprop file 'vc-checkout-time mtime)
- (vc-file-setprop file 'vc-checkout-time 0)))
- (throw 'found (cons (concat dirname "CVS/Entries") 'CVS)))
- ;; entry with arbitrary text as timestamp
- ;; (this means we should consider it modified)
- ((re-search-forward
- (concat "^/" (regexp-quote basename)
- ;; revision
- "/\\([^/]*\\)"
- ;; timestamp (arbitrary text)
- "/[^/]*"
- ;; optional conflict field
- "\\(+[^/]*\\)?/")
- nil t)
- ;; We found it. Store away version number now that we
- ;; are anyhow so close to finding it.
- (vc-file-setprop file 'vc-workfile-version (match-string 1))
- (vc-file-setprop file 'vc-checkout-time 0)
- (throw 'found (cons (concat dirname "CVS/Entries") 'CVS)))
- (t nil)))
- (kill-buffer buffer)))))
-
-(defun vc-buffer-backend ()
- "Return the version-control type of the visited file, or nil if none."
- (if (eq vc-buffer-backend t)
- (setq vc-buffer-backend (vc-backend (buffer-file-name)))
- vc-buffer-backend))
+(defun vc-possible-master (s dirname basename)
+ (cond
+ ((stringp s) (format s dirname basename))
+ ((functionp s)
+ ;; The template is a function to invoke. If the
+ ;; function returns non-nil, that means it has found a
+ ;; master. For backward compatibility, we also handle
+ ;; the case that the function throws a 'found atom
+ ;; and a pair (cons MASTER-FILE BACKEND).
+ (let ((result (catch 'found (funcall s dirname basename))))
+ (if (consp result) (car result) result)))))
+
+(defun vc-check-master-templates (file templates)
+ "Return non-nil if there is a master corresponding to FILE.
+
+TEMPLATES is a list of strings or functions. If an element is a
+string, it must be a control string as required by `format', with two
+string placeholders, such as \"%sRCS/%s,v\". The directory part of
+FILE is substituted for the first placeholder, the basename of FILE
+for the second. If a file with the resulting name exists, it is taken
+as the master of FILE, and returned.
+
+If an element of TEMPLATES is a function, it is called with the
+directory part and the basename of FILE as arguments. It should
+return non-nil if it finds a master; that value is then returned by
+this function."
+ (let ((dirname (or (file-name-directory file) ""))
+ (basename (file-name-nondirectory file)))
+ (catch 'found
+ (mapcar
+ (lambda (s)
+ (let ((trial (vc-possible-master s dirname basename)))
+ (if (and trial (file-exists-p trial)
+ ;; Make sure the file we found with name
+ ;; TRIAL is not the source file itself.
+ ;; That can happen with RCS-style names if
+ ;; the file name is truncated (e.g. to 14
+ ;; chars). See if either directory or
+ ;; attributes differ.
+ (or (not (string= dirname
+ (file-name-directory trial)))
+ (not (equal (file-attributes file)
+ (file-attributes trial)))))
+ (throw 'found trial))))
+ templates))))
(defun vc-toggle-read-only (&optional verbose)
"Change read-only status of current buffer, perhaps via version control.
+
If the buffer is visiting a file registered with version control,
then check the file in or out. Otherwise, just change the read-only flag
of the buffer.
With prefix argument, ask for version number to check in or check out.
Check-out of a specified version number does not lock the file;
-to do that, use this command a second time with no argument."
+to do that, use this command a second time with no argument.
+
+If you bind this function to \\[toggle-read-only], then Emacs checks files
+in or out whenever you toggle the read-only flag."
(interactive "P")
(if (or (and (boundp 'vc-dired-mode) vc-dired-mode)
- ;; use boundp because vc.el might not be loaded
- (vc-backend (buffer-file-name)))
+ ;; use boundp because vc.el might not be loaded
+ (vc-backend buffer-file-name))
(vc-next-action verbose)
(toggle-read-only)))
+;; XEmacs addition: backwards compat with our old vc package.
(define-key global-map "\C-x\C-q" 'vc-toggle-read-only)
+(defun vc-default-make-version-backups-p (backend file)
+ "Return non-nil if unmodified versions should be backed up locally.
+The default is to switch off this feature."
+ nil)
+
+(defun vc-version-backup-file-name (file &optional rev manual regexp)
+ "Return a backup file name for REV or the current version of FILE.
+If MANUAL is non-nil it means that a name for backups created by
+the user should be returned; if REGEXP is non-nil that means to return
+a regexp for matching all such backup files, regardless of the version."
+ (if regexp
+ (concat (regexp-quote (file-name-nondirectory file))
+ "\\.~.+" (unless manual "\\.") "~")
+ (expand-file-name (concat (file-name-nondirectory file)
+ ".~" (subst-char-in-string
+ ?/ ?_ (or rev (vc-workfile-version file)))
+ (unless manual ".") "~")
+ (file-name-directory file))))
+
+(defun vc-delete-automatic-version-backups (file)
+ "Delete all existing automatic version backups for FILE."
+ (condition-case nil
+ (mapcar
+ 'delete-file
+ (directory-files (or (file-name-directory file) default-directory) t
+ (vc-version-backup-file-name file nil nil t)))
+ ;; Don't fail when the directory doesn't exist.
+ (file-error nil)))
+
+(defun vc-make-version-backup (file)
+ "Make a backup copy of FILE, which is assumed in sync with the repository.
+Before doing that, check if there are any old backups and get rid of them."
+ (unless (and (fboundp 'msdos-long-file-names)
+ (not (with-no-warnings (msdos-long-file-names))))
+ (vc-delete-automatic-version-backups file)
+ (condition-case nil
+ (copy-file file (vc-version-backup-file-name file)
+ nil 'keep-date)
+ ;; It's ok if it doesn't work (e.g. directory not writable),
+ ;; since this is just for efficiency.
+ (file-error
+ (message
+ (concat "Warning: Cannot make version backup; "
+ "diff/revert therefore not local"))))))
+
+(defun vc-before-save ()
+ "Function to be called by `basic-save-buffer' (in files.el)."
+ ;; If the file on disk is still in sync with the repository,
+ ;; and version backups should be made, copy the file to
+ ;; another name. This enables local diffs and local reverting.
+ (let ((file buffer-file-name))
+ (and (vc-backend file)
+ (vc-up-to-date-p file)
+ (eq (vc-checkout-model file) 'implicit)
+ (vc-call make-version-backups-p file)
+ (vc-make-version-backup file))))
+
(defun vc-after-save ()
- ;; Function to be called by basic-save-buffer (in files.el).
+ "Function to be called by `basic-save-buffer' (in files.el)."
;; If the file in the current buffer is under version control,
- ;; not locked, and the checkout model for it is `implicit',
- ;; mark it "locked" and redisplay the mode line.
- (let ((file (buffer-file-name)))
+ ;; up-to-date, and locking is not used for the file, set
+ ;; the state to 'edited and redisplay the mode line.
+ (let ((file buffer-file-name))
(and (vc-backend file)
(or (and (equal (vc-file-getprop file 'vc-checkout-time)
(nth 5 (file-attributes file)))
@@ -1011,90 +714,87 @@ to do that, use this command a second ti
;; it was checked out. Clear the checkout-time
;; to avoid confusion.
(vc-file-setprop file 'vc-checkout-time nil))
- t)
- (not (vc-locking-user file))
- (eq (vc-checkout-model file) 'implicit)
- (vc-file-setprop file 'vc-locking-user (vc-user-login-name))
- (or (and (eq (vc-backend file) 'CVS)
- (vc-file-setprop file 'vc-cvs-status nil))
t)
- (vc-mode-line file))))
+ (vc-up-to-date-p file)
+ (eq (vc-checkout-model file) 'implicit)
+ (vc-file-setprop file 'vc-state 'edited)
+ (vc-mode-line file)
+ (if (featurep 'vc)
+ ;; If VC is not loaded, then there can't be
+ ;; any VC Dired buffer to synchronize.
+ (vc-dired-resynch-file file)))))
+;; XEmacs addition, used in vc-mode-line
(defvar vc-mode-ext (make-extent nil nil))
-(defun vc-mode-line (file &optional label)
+(defun vc-mode-line (file)
"Set `vc-mode' to display type of version control for FILE.
The value is set in the current buffer, which should be the buffer
-visiting FILE. Second optional arg LABEL is put in place of version
-control system name."
- (interactive (list buffer-file-name nil))
- (let ((vc-type (vc-backend file)))
- (setq vc-mode
- (and vc-type
- (let* ((str
- (concat (or label (symbol-name vc-type))
- (and vc-display-status (vc-status file))))
- (test-str "^\\(CVS\\|RCS\\|SCCS\\)-")
- (not-locked (string-match test-str str)))
- (if (or not-locked (not vc-mode-face))
- (concat " " str)
- (progn
- (set-extent-face vc-mode-ext vc-mode-face)
- (list " " (cons vc-mode-ext str)))))))
- ;; If the file is locked by some other user, make
- ;; the buffer read-only. Like this, even root
- ;; cannot modify a file that someone else has locked.
- (and vc-type
- (equal file (buffer-file-name))
- (vc-locking-user file)
- (not (string= (vc-user-login-name) (vc-locking-user file)))
- (setq buffer-read-only t))
- ;; If the user is root, and the file is not owner-writable,
- ;; then pretend that we can't write it
- ;; even though we can (because root can write anything).
+visiting FILE."
+ (interactive (list buffer-file-name))
+ (let ((backend (vc-backend file)))
+ (if (not backend)
+ (setq vc-mode nil)
+ ;; XEmacs: mode line extent stuff
+ (setq vc-mode
+ (let* ((str (if vc-display-status (vc-call mode-line-string file)
+ (symbol-name backend)))
+ ;; XEmacs change: add GIT
+ (test-str "^\\(RCS\\|CVS\\|SVN\\|SCCS\\|Arch\\|MCVS\\|GIT\\)-")
+ (not-locked (string-match test-str str)))
+ (if (or not-locked (not vc-mode-face))
+ (concat " " str)
+ (progn
+ (set-extent-face vc-mode-ext vc-mode-face)
+ (list " " (cons vc-mode-ext str))))))
+; (setq vc-mode (concat " " (if vc-display-status
+; (vc-call mode-line-string file)
+; (symbol-name backend))))
+ ;; If the file is locked by some other user, make
+ ;; the buffer read-only. Like this, even root
+ ;; cannot modify a file that someone else has locked.
+ (and (equal file buffer-file-name)
+ (stringp (vc-state file))
+ (setq buffer-read-only t))
+ ;; If the user is root, and the file is not owner-writable,
+ ;; then pretend that we can't write it
+ ;; even though we can (because root can write anything).
;; This way, even root cannot modify a file that isn't locked.
- (and vc-type
- (equal file (buffer-file-name))
+ (and (equal file buffer-file-name)
(not buffer-read-only)
- (zerop (user-real-uid))
- (zerop (logand (file-modes (buffer-file-name)) 128))
- (setq buffer-read-only t))
+ (zerop (user-real-uid))
+ (zerop (logand (file-modes buffer-file-name) 128))
+ (setq buffer-read-only t)))
(force-mode-line-update)
- ;;(set-buffer-modified-p (buffer-modified-p)) ;;use this if Emacs 18
- vc-type))
+ backend))
-(defun vc-status (file)
- ;; Return string for placement in modeline by `vc-mode-line'.
- ;; Format:
- ;;
- ;; "-REV" if the revision is not locked
- ;; ":REV" if the revision is locked by the user
- ;; ":LOCKER:REV" if the revision is locked by somebody else
- ;; " @@" for a CVS file that is added, but not yet committed
- ;;
- ;; In the CVS case, a "locked" working file is a
- ;; working file that is modified with respect to the master.
- ;; The file is "locked" from the moment when the user saves
- ;; the modified buffer.
- ;;
- ;; This function assumes that the file is registered.
-
- (let ((locker (vc-locking-user file))
- (rev (vc-workfile-version file)))
- (cond ((string= "0" rev)
- " @@")
- ((not locker)
- (concat "-" rev))
- ((string= locker (vc-user-login-name))
- (concat ":" rev))
- (t
- (concat ":" locker ":" rev)))))
+(defun vc-default-mode-line-string (backend file)
+ "Return string for placement in modeline by `vc-mode-line' for FILE.
+Format:
+
+ \"BACKEND-REV\" if the file is up-to-date
+ \"BACKEND:REV\" if the file is edited (or locked by the calling user)
+ \"BACKEND:LOCKER:REV\" if the file is locked by somebody else
+
+This function assumes that the file is registered."
+ (setq backend (symbol-name backend))
+ (let ((state (vc-state file))
+ (rev (vc-workfile-version file)))
+ (cond ((or (eq state 'up-to-date)
+ (eq state 'needs-patch))
+ (concat backend "-" rev))
+ ((stringp state)
+ (concat backend ":" 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 backend ":" rev)))))
(defun vc-follow-link ()
- ;; If the current buffer visits a symbolic link, this function makes it
- ;; visit the real file instead. If the real file is already visited in
- ;; another buffer, make that buffer current, and kill the buffer
- ;; that visits the link.
+ "If current buffer visits a symbolic link, visit the real file.
+If the real file is already visited in another buffer, make that buffer
+current, and kill the buffer that visits the link."
(let* ((truename (abbreviate-file-name (file-chase-links buffer-file-name)))
(true-buffer (find-buffer-visiting truename))
(this-buffer (current-buffer)))
@@ -1108,243 +808,163 @@ control system name."
(set-buffer true-buffer)
(kill-buffer this-buffer))))
-;;; install a call to the above as a find-file hook
+(defun vc-default-find-file-hook (backend)
+ nil)
+
(defun vc-find-file-hook ()
+ "Function for `find-file-hook' activating VC mode if appropriate."
;; Recompute whether file is version controlled,
;; if user has killed the buffer and revisited.
- (cond
- ((and (not vc-ignore-vc-files) buffer-file-name)
+ (if vc-mode
+ (setq vc-mode nil))
+ (when buffer-file-name
(vc-file-clearprops buffer-file-name)
(cond
((vc-backend buffer-file-name)
+ ;; Compute the state and put it in the modeline.
(vc-mode-line buffer-file-name)
- (cond ((not vc-make-backup-files)
- ;; Use this variable, not make-backup-files,
- ;; because this is for things that depend on the file name.
- (make-local-variable 'backup-inhibited)
- (setq backup-inhibited t))))
- ((let* ((link (file-symlink-p buffer-file-name))
- (link-type (and link (vc-backend (file-chase-links link)))))
- (if link-type
- (cond ((eq vc-follow-symlinks nil)
- (message
+ (unless vc-make-backup-files
+ ;; Use this variable, not make-backup-files,
+ ;; because this is for things that depend on the file name.
+ (set (make-local-variable 'backup-inhibited) t))
+ ;; Let the backend setup any buffer-local things he needs.
+ (vc-call-backend (vc-backend buffer-file-name) 'find-file-hook))
+ ((let ((link-type (and (file-symlink-p buffer-file-name)
+ (vc-backend (file-chase-links buffer-file-name)))))
+ (cond ((not link-type) nil) ;Nothing to do.
+ ((eq vc-follow-symlinks nil)
+ (message
"Warning: symbolic link to %s-controlled source file" link-type))
- ((or (not (eq vc-follow-symlinks 'ask))
- ;; If we already visited this file by following
- ;; the link, don't ask again if we try to visit
- ;; it again. GUD does that, and repeated questions
- ;; are painful.
- (get-file-buffer
- (abbreviate-file-name (file-chase-links buffer-file-name))))
-
- (vc-follow-link)
- (message "Followed link to %s" buffer-file-name)
- (vc-find-file-hook))
- (t
- (if (yes-or-no-p (format
+ ((or (not (eq vc-follow-symlinks 'ask))
+ ;; If we already visited this file by following
+ ;; the link, don't ask again if we try to visit
+ ;; it again. GUD does that, and repeated questions
+ ;; are painful.
+ (get-file-buffer
+ (abbreviate-file-name
+ (file-chase-links buffer-file-name))))
+
+ (vc-follow-link)
+ (message "Followed link to %s" buffer-file-name)
+ (vc-find-file-hook))
+ (t
+ (if (yes-or-no-p (format
"Symbolic link to %s-controlled source file; follow link? " link-type))
- (progn (vc-follow-link)
- (message "Followed link to %s" buffer-file-name)
- (vc-find-file-hook))
- (message
+ (progn (vc-follow-link)
+ (message "Followed link to %s" buffer-file-name)
+ (vc-find-file-hook))
+ (message
"Warning: editing through the link bypasses version control")
- ))))))))))
+ ))))))))
-(add-hook 'find-file-hooks 'vc-find-file-hook)
+(add-hook 'find-file-hook 'vc-find-file-hook)
-;;; more hooks, this time for file-not-found
+;; more hooks, this time for file-not-found
(defun vc-file-not-found-hook ()
- "When file is not found, try to check it out from RCS or SCCS.
-Returns t if checkout was successful, nil otherwise."
+ "When file is not found, try to check it out from version control.
+Returns t if checkout was successful, nil otherwise.
+Used in `find-file-not-found-functions'."
;; When a file does not exist, ignore cached info about it
;; from a previous visit.
(vc-file-clearprops buffer-file-name)
- (if (and (not vc-ignore-vc-files)
- (vc-backend buffer-file-name))
+ (let ((backend (vc-backend buffer-file-name)))
+ (if backend (vc-call-backend backend 'find-file-not-found-hook))))
+
+(defun vc-default-find-file-not-found-hook (backend)
+ (if (yes-or-no-p
+ (format "File %s was lost; check out from version control? "
+ (file-name-nondirectory buffer-file-name)))
(save-excursion
(require 'vc)
- (setq default-directory (file-name-directory (buffer-file-name)))
+ (setq default-directory (file-name-directory buffer-file-name))
(not (vc-error-occurred (vc-checkout buffer-file-name))))))
-(add-hook 'find-file-not-found-hooks 'vc-file-not-found-hook)
+(add-hook 'find-file-not-found-functions 'vc-file-not-found-hook)
-;; Discard info about a file when we kill its buffer.
(defun vc-kill-buffer-hook ()
- (if (stringp (buffer-file-name))
- (progn
- (vc-file-clearprops (buffer-file-name))
- (kill-local-variable 'vc-buffer-backend))))
-
-;;;(add-hook 'kill-buffer-hook 'vc-kill-buffer-hook)
-
-;;; Now arrange for bindings and autoloading of the main package.
-;;; Bindings for this have to go in the global map, as we'll often
-;;; want to call them from random buffers.
-
-(setq vc-prefix-map (lookup-key global-map "\C-xv"))
-(if (not (keymapp vc-prefix-map))
- (progn
- (setq vc-prefix-map (make-sparse-keymap))
- (define-key global-map "\C-xv" vc-prefix-map)
- (define-key vc-prefix-map "a" 'vc-update-change-log)
- (define-key vc-prefix-map "c" 'vc-cancel-version)
- (define-key vc-prefix-map "d" 'vc-directory)
- (define-key vc-prefix-map "g" 'vc-annotate)
- (define-key vc-prefix-map "h" 'vc-insert-headers)
- (define-key vc-prefix-map "i" 'vc-register)
- (define-key vc-prefix-map "l" 'vc-print-log)
- ;; XEmacs change.
-;; (define-key vc-prefix-map "m" 'vc-merge)
- (define-key vc-prefix-map "r" 'vc-retrieve-snapshot)
- (define-key vc-prefix-map "s" 'vc-create-snapshot)
- (define-key vc-prefix-map "u" 'vc-revert-buffer)
- (define-key vc-prefix-map "v" 'vc-next-action)
- (define-key vc-prefix-map "=" 'vc-diff)
- (define-key vc-prefix-map "~" 'vc-version-other-window)))
-
-;; Emacs menus
-;(if (not (boundp 'vc-menu-map))
-; ;; Don't do the menu bindings if menu-bar.el wasn't loaded to defvar
-; ;; vc-menu-map.
-; ()
-; ;;(define-key vc-menu-map [show-files]
-; ;; '("Show Files under VC" . (vc-directory t)))
-; (define-key vc-menu-map [vc-directory] '("Show Locked Files" . vc-directory))
-; (define-key vc-menu-map [separator1] '("----"))
-; (define-key vc-menu-map [vc-rename-file] '("Rename File" . vc-rename-file))
-; (define-key vc-menu-map [vc-version-other-window]
-; '("Show Other Version" . vc-version-other-window))
-; (define-key vc-menu-map [vc-diff] '("Compare with Last Version" . vc-diff))
-; (define-key vc-menu-map [vc-update-change-log]
-; '("Update ChangeLog" . vc-update-change-log))
-; (define-key vc-menu-map [vc-print-log] '("Show History" . vc-print-log))
-; (define-key vc-menu-map [separator2] '("----"))
-; (define-key vc-menu-map [undo] '("Undo Last Check-In" . vc-cancel-version))
-; (define-key vc-menu-map [vc-revert-buffer]
-; '("Revert to Last Version" . vc-revert-buffer))
-; (define-key vc-menu-map [vc-insert-header]
-; '("Insert Header" . vc-insert-headers))
-; (define-key vc-menu-map [vc-menu-check-in] '("Check In" . vc-next-action))
-; (define-key vc-menu-map [vc-check-out] '("Check Out" . vc-toggle-read-only))
-; (define-key vc-menu-map [vc-register] '("Register" . vc-register)))
-
-;(put 'vc-rename-file 'menu-enable 'vc-mode)
-;(put 'vc-version-other-window 'menu-enable 'vc-mode)
-;(put 'vc-diff 'menu-enable 'vc-mode)
-;(put 'vc-update-change-log 'menu-enable
-; '(eq (vc-buffer-backend) 'RCS))
-;(put 'vc-print-log 'menu-enable 'vc-mode)
-;(put 'vc-cancel-version 'menu-enable 'vc-mode)
-;(put 'vc-revert-buffer 'menu-enable 'vc-mode)
-;(put 'vc-insert-headers 'menu-enable 'vc-mode)
-;(put 'vc-next-action 'menu-enable 'vc-mode)
-;(put 'vc-toggle-read-only 'menu-enable 'vc-mode)
-;(put 'vc-register 'menu-enable '(and buffer-file-name (not vc-mode)))
-
-(defconst vc-menu
- '("VC"
-:filter vc-menu-filter
- ["" vc-next-action buffer-file-name nil]
- ;;["Show Locked Files" vc-directory t] ;; needs new dired
- "----"
- ["Revert to Last Revision" vc-revert-buffer vc-mode nil]
- ["Cancel Last Checkin" vc-cancel-version vc-mode]
- ["Rename File" vc-rename-this-file vc-mode nil]
- "----"
- ["Diff Against Last Version" vc-diff vc-mode]
- ["Diff Between Revisions..." vc-version-diff vc-mode]
- ;;["Ediff Between Revisions..." ediff-revision vc-mode]
- ["Visit Other Version..." vc-version-other-window vc-mode]
- ["Show Edit History" vc-print-log vc-mode]
- "----"
- ;; The two commented out List functions simply don't work at the
- ;; moment.
- ;;["List Locked Files" (vc-directory '(16)) t]
- ["List Locked Files Any User" vc-directory t]
- ;;["List Registered Files" (vc-directory '(4)) t]
- "----"
- ["Create Snapshot" vc-create-snapshot t]
- ["Retrieve Snapshot" vc-retrieve-snapshot t]
- "----"
- ["CVS Update Directory" cvs-update t] ; pcl-cvs
- ;;["Show File Status" vc-cvs-file-status vc-mode]
- )
- "Menubar entry for using the revision control system.")
-
-(defun vc-menu-filter (menu-items)
- (let* ((result menu-items) ; modify in-place
- (case-fold-search t)
- (type (vc-backend buffer-file-name))
- ;; VC works with full path!
- (file (if buffer-file-name
- buffer-file-name
- (expand-file-name (buffer-name))))
- op owner item status)
- (setq op (cond ((null type)
- "Register File")
- ((eq type 'CVS)
- (setq status
- (vc-file-getprop buffer-file-name 'cvs-status))
- (if status
- (cdr (assoc status
- '(("Locally Modified" . "Commit")
- ("Needs Merge" . "Merge with repository")
- ("Up-to-date" . "Do nothing to")
- ("Needs Checkout" . "Update"))))
- ;; #### - we're not gonna call cvs status just to
- ;; post a lousy menu...that's insane!
- "Next action on"
- ))
- ;; these are all for RCS and SCCS
- ((not (setq owner (vc-locking-user file)))
- ;; VC locking user is faster now. vc-file-owner
- ;; is superceded by incompatible FSF version (JV).
- "Check out File")
- ((not (string-equal owner (user-login-name)))
- "Steal File Lock")
- (t "Check in File")))
- ;; We do not want the full name in the menu
- (setq file (file-name-nondirectory file))
- (while (setq item (pop menu-items))
- (and (vectorp item)
- (cond ((eq 'vc-next-action (aref item 1))
- (aset item 0 op)
- (aset item 3 file))
- ((eq 'vc-file-status (aref item 1))
- (aset item 2 (eq 'CVS type))
- (aset item 3 file))
- ((> (length item) 3)
- (aset item 3 file)))))
- result))
-
-(and (featurep 'menubar)
- current-menubar
- (car (find-menu-item current-menubar '("Tools")))
- (add-submenu '("Tools") vc-menu "Compare")
- (add-menu-button '("Tools") "---" "Compare"))
+ "Discard VC info about a file when we kill its buffer."
+ (if buffer-file-name
+ (vc-file-clearprops buffer-file-name)))
+
+(add-hook 'kill-buffer-hook 'vc-kill-buffer-hook)
+
+;; Now arrange for (autoloaded) bindings of the main package.
+;; Bindings for this have to go in the global map, as we'll often
+;; want to call them from random buffers.
+
+;; Autoloading works fine, but it prevents shortcuts from appearing
+;; in the menu because they don't exist yet when the menu is built.
+;; (autoload 'vc-prefix-map "vc" nil nil 'keymap)
+(defvar vc-prefix-map
+ (let ((map (make-sparse-keymap)))
+ (define-key map "a" 'vc-update-change-log)
+ (define-key map "b" 'vc-switch-backend)
+ (define-key map "c" 'vc-cancel-version)
+ (define-key map "d" 'vc-directory)
+ (define-key map "g" 'vc-annotate)
+ (define-key map "h" 'vc-insert-headers)
+ (define-key map "i" 'vc-register)
+ (define-key map "l" 'vc-print-log)
+ (define-key map "m" 'vc-merge)
+ (define-key map "r" 'vc-retrieve-snapshot)
+ (define-key map "s" 'vc-create-snapshot)
+ (define-key map "u" 'vc-revert-buffer)
+ (define-key map "v" 'vc-next-action)
+ (define-key map "=" 'vc-diff)
+ (define-key map "~" 'vc-version-other-window)
+ map))
+(fset 'vc-prefix-map vc-prefix-map)
+(define-key global-map "\C-xv" 'vc-prefix-map)
+
+(if (not (boundp 'vc-menu-map))
+ ;; Don't do the menu bindings if menu-bar.el wasn't loaded to defvar
+ ;; vc-menu-map.
+ ()
+ ;;(define-key vc-menu-map [show-files]
+ ;; '("Show Files under VC" . (vc-directory t)))
+ (define-key vc-menu-map [vc-retrieve-snapshot]
+ '("Retrieve Snapshot" . vc-retrieve-snapshot))
+ (define-key vc-menu-map [vc-create-snapshot]
+ '("Create Snapshot" . vc-create-snapshot))
+ (define-key vc-menu-map [vc-directory] '("VC Directory Listing" . vc-directory))
+ (define-key vc-menu-map [separator1] '("----"))
+ (define-key vc-menu-map [vc-annotate] '("Annotate" . vc-annotate))
+ (define-key vc-menu-map [vc-rename-file] '("Rename File" . vc-rename-file))
+ (define-key vc-menu-map [vc-version-other-window]
+ '("Show Other Version" . vc-version-other-window))
+ (define-key vc-menu-map [vc-diff] '("Compare with Base Version" . vc-diff))
+ (define-key vc-menu-map [vc-update-change-log]
+ '("Update ChangeLog" . vc-update-change-log))
+ (define-key vc-menu-map [vc-print-log] '("Show History" . vc-print-log))
+ (define-key vc-menu-map [separator2] '("----"))
+ (define-key vc-menu-map [vc-insert-header]
+ '("Insert Header" . vc-insert-headers))
+ (define-key vc-menu-map [undo] '("Undo Last Check-In" . vc-cancel-version))
+ (define-key vc-menu-map [vc-revert-buffer]
+ '("Revert to Base Version" . vc-revert-buffer))
+ (define-key vc-menu-map [vc-update]
+ '("Update to Latest Version" . vc-update))
+ (define-key vc-menu-map [vc-next-action] '("Check In/Out" . vc-next-action))
+ (define-key vc-menu-map [vc-register] '("Register" . vc-register)))
+
+;; These are not correct and it's not currently clear how doing it
+;; better (with more complicated expressions) might slow things down
+;; on older systems.
+
+;;(put 'vc-rename-file 'menu-enable 'vc-mode)
+;;(put 'vc-annotate 'menu-enable '(eq (vc-buffer-backend) 'CVS))
+;;(put 'vc-version-other-window 'menu-enable 'vc-mode)
+;;(put 'vc-diff 'menu-enable 'vc-mode)
+;;(put 'vc-update-change-log 'menu-enable
+;; '(member (vc-buffer-backend) '(RCS CVS)))
+;;(put 'vc-print-log 'menu-enable 'vc-mode)
+;;(put 'vc-cancel-version 'menu-enable 'vc-mode)
+;;(put 'vc-revert-buffer 'menu-enable 'vc-mode)
+;;(put 'vc-insert-headers 'menu-enable 'vc-mode)
+;;(put 'vc-next-action 'menu-enable 'vc-mode)
+;;(put 'vc-register 'menu-enable '(and buffer-file-name (not vc-mode)))
-;;; End XEmacs menus
-
(provide 'vc-hooks)
-
-;; This NEEDS to go AFTER 'vc-hooks, package load only (XEmacs)
-
-;;;###autoload
-(defun vc-load-vc-hooks ()
- (interactive)
- (require 'vc-hooks)
- (vc-find-file-hook))
-
-;;;###autoload
-(and (featurep 'menubar)
- (featurep 'xemacs)
- (not (or (featurep 'vc-hooks) (featurep 'infodock)))
- current-menubar
- (car (find-menu-item current-menubar '("Tools")))
- (add-submenu '("Tools")
- '("VC"
- ["Load VC" vc-load-vc-hooks t])
- "Compare"))
-
+;; arch-tag: 2e5a6fa7-1d30-48e2-8bd0-e3d335f04f32
;;; vc-hooks.el ends here
1.23 +3230 -2799XEmacs/packages/xemacs-packages/vc/vc.el
Index: vc.el
===================================================================
RCS file: /pack/xemacscvs/XEmacs/packages/xemacs-packages/vc/vc.el,v
retrieving revision 1.22
retrieving revision 1.23
diff -u -p -r1.22 -r1.23
--- vc.el 2005/06/05 17:20:36 1.22
+++ vc.el 2007/08/23 21:27:55 1.23
@@ -1,13 +1,14 @@
;;; vc.el --- drive a version-control system from within Emacs
-;; Copyright (C) 1992, 93, 94, 95, 96 Free Software Foundation, Inc.
+;; Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 2000,
+;; 2001, 2002, 2003, 2004, 2005, 2006, 2007 Free Software Foundation, Inc.
-;; Author: Eric S. Raymond <esr at snark.thyrsus.com>
-;; Andre Spiegel <spiegel at inf.fu-berlin.de>
-;; Maintainer: XEmacs Development Team <xemacs at xemacs.org>
-;; Maintainer: (ClearCase) Rod Whitby <rwhitby at geocities.com>
-;; XEmacs conversion: Steve Baur <steve at xemacs.org>
+;; Author: FSF (see below for full credits)
+;; Maintainer: Andre Spiegel <spiegel at gnu.org>
+;; Keywords: tools
+;; $Id: vc.el,v 1.377 2004/04/23 21:02:23 lektu Exp $
+
;; This file is part of GNU Emacs.
;; GNU Emacs is free software; you can redistribute it and/or modify
@@ -22,92 +23,456 @@
;; 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:
+;; VC was initially designed and implemented by Eric S. Raymond
+;; <esr at snark.thyrsus.com>. Over the years, many people have
+;; contributed substantial amounts of work to VC. These include:
+;; Per Cederqvist <ceder at lysator.liu.se>
+;; Paul Eggert <eggert at twinsun.com>
+;; Sebastian Kremer <sk at thp.uni-koeln.de>
+;; Martin Lorentzson <martinl at gnu.org>
+;; Dave Love <fx at gnu.org>
+;; Stefan Monnier <monnier at cs.yale.edu>
+;; J.D. Smith <jdsmith at alum.mit.edu>
+;; Andre Spiegel <spiegel at gnu.org>
+;; Richard Stallman <rms at gnu.org>
+;; Thien-Thi Nguyen <ttn at gnu.org>
+
;;; Commentary:
;; This mode is fully documented in the Emacs user's manual.
-;;
-;; This was designed and implemented by Eric Raymond <esr at snark.thyrsus.com>.
-;; Paul Eggert <eggert at twinsun.com>, Sebastian Kremer <sk at thp.uni-koeln.de>,
-;; and Richard Stallman contributed valuable criticism, support, and testing.
-;; CVS support was added by Per Cederqvist <ceder at lysator.liu.se>
-;; in Jan-Feb 1994. Further enhancements came from ttn.netcom.com and
-;; Andre Spiegel <spiegel at inf.fu-berlin.de>.
;;
-;; 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
-;; disallows those features (stealing locks, for example, works only
+;; disallows those features (stealing locks, for example, works only
;; from 5.6.2 onwards).
;; Even initial checkins will fail if your RCS version is so old that ci
;; doesn't understand -t-; this has been known to happen to people running
-;; NExTSTEP 3.0.
+;; NExTSTEP 3.0.
;;
-;; You can support the RCS -x option by adding pairs to the
-;; vc-master-templates list.
+;; You can support the RCS -x option by customizing vc-rcs-master-templates.
;;
;; Proper function of the SCCS diff commands requires the shellscript vcdiff
;; to be installed somewhere on Emacs's path for executables.
;;
;; If your site uses the ChangeLog convention supported by Emacs, the
-;; function vc-comment-to-change-log should prove a useful checkin hook.
+;; function log-edit-comment-to-change-log could prove a useful checkin hook,
+;; although you might prefer to use C-c C-a (i.e. log-edit-insert-changelog)
+;; from the commit buffer instead or to set `log-edit-setup-invert'.
;;
-;; This code depends on call-process passing back the subprocess exit
-;; status. Thus, you need Emacs 18.58 or later to run it. For the
-;; vc-directory command to work properly as documented, you need 19.
-;; You also need Emacs 19's ring.el.
-;;
;; 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!
;;
;; Developer's notes on some concurrency issues are included at the end of
;; the file.
+;;
+;; ADDING SUPPORT FOR OTHER BACKENDS
+;;
+;; VC can use arbitrary version control systems as a backend. To add
+;; support for a new backend named SYS, write a library vc-sys.el that
+;; contains functions of the form `vc-sys-...' (note that SYS is in lower
+;; case for the function and library names). VC will use that library if
+;; you put the symbol SYS somewhere into the list of
+;; `vc-handled-backends'. Then, for example, if `vc-sys-registered'
+;; returns non-nil for a file, all SYS-specific versions of VC commands
+;; will be available for that file.
+;;
+;; VC keeps some per-file information in the form of properties (see
+;; vc-file-set/getprop in vc-hooks.el). The backend-specific functions
+;; do not generally need to be aware of these properties. For example,
+;; `vc-sys-workfile-version' should compute the workfile version and
+;; return it; it should not look it up in the property, and it needn't
+;; store it there either. However, if a backend-specific function does
+;; store a value in a property, that value takes precedence over any
+;; value that the generic code might want to set (check for uses of
+;; the macro `with-vc-properties' in vc.el).
+;;
+;; In the list of functions below, each identifier needs to be prepended
+;; with `vc-sys-'. Some of the functions are mandatory (marked with a
+;; `*'), others are optional (`-').
+;;
+;; STATE-QUERYING FUNCTIONS
+;;
+;; * registered (file)
+;;
+;; Return non-nil if FILE is registered in this backend. Both this
+;; function as well as `state' should be careful to fail gracefully in the
+;; event that the backend executable is absent.
+;;
+;; * state (file)
+;;
+;; Return the current version control state of FILE. For a list of
+;; possible values, see `vc-state'. This function should do a full and
+;; reliable state computation; it is usually called immediately after
+;; C-x v v. If you want to use a faster heuristic when visiting a
+;; file, put that into `state-heuristic' below.
+;;
+;; - state-heuristic (file)
+;;
+;; If provided, this function is used to estimate the version control
+;; state of FILE at visiting time. It should be considerably faster
+;; than the implementation of `state'. For a list of possible values,
+;; see the doc string of `vc-state'.
+;;
+;; - dir-state (dir)
+;;
+;; If provided, this function is used to find the version control state
+;; of all files in DIR in a fast way. The function should not return
+;; anything, but rather store the files' states into the corresponding
+;; `vc-state' properties.
+;;
+;; * workfile-version (file)
+;;
+;; Return the current workfile version of FILE.
+;;
+;; - latest-on-branch-p (file)
+;;
+;; Return non-nil if the current workfile version of FILE is the latest
+;; on its branch. The default implementation always returns t, which
+;; means that working with non-current versions is not supported by
+;; default.
+;;
+;; * checkout-model (file)
+;;
+;; Indicate whether FILE needs to be "checked out" before it can be
+;; edited. See `vc-checkout-model' for a list of possible values.
+;;
+;; - workfile-unchanged-p (file)
+;;
+;; Return non-nil if FILE is unchanged from its current workfile
+;; version. This function should do a brief comparison of FILE's
+;; contents with those of the master version. If the backend does not
+;; 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, see variable `vc-disable-async-diff'.)
+;;
+;; - mode-line-string (file)
+;;
+;; If provided, this function should return the VC-specific mode line
+;; string for FILE. The default implementation deals well with all
+;; states that `vc-state' can return.
+;;
+;; - dired-state-info (file)
+;;
+;; Translate the `vc-state' property of FILE into a string that can be
+;; used in a vc-dired buffer. The default implementation deals well
+;; with all states that `vc-state' can return.
+;;
+;; STATE-CHANGING FUNCTIONS
+;;
+;; * register (file &optional rev comment)
+;;
+;; Register FILE in this backend. Optionally, an initial revision REV
+;; and an initial description of the file, COMMENT, may be specified.
+;; The implementation should pass the value of vc-register-switches
+;; to the backend command.
+;;
+;; - init-version (file)
+;;
+;; The initial version to use when registering FILE if one is not
+;; specified by the user. If not provided, the variable
+;; vc-default-init-version is used instead.
+;;
+;; - responsible-p (file)
+;;
+;; Return non-nil if this backend considers itself "responsible" for
+;; FILE, which can also be a directory. This function is used to find
+;; out what backend to use for registration of new files and for things
+;; like change log generation. The default implementation always
+;; returns nil.
+;;
+;; - could-register (file)
+;;
+;; Return non-nil if FILE could be registered under this backend. The
+;; default implementation always returns t.
+;;
+;; - receive-file (file rev)
+;;
+;; Let this backend "receive" a file that is already registered under
+;; another backend. The default implementation simply calls `register'
+;; for FILE, but it can be overridden to do something more specific,
+;; e.g. keep revision numbers consistent or choose editing modes for
+;; FILE that resemble those of the other backend.
+;;
+;; - unregister (file)
+;;
+;; Unregister FILE from this backend. This is only needed if this
+;; backend may be used as a "more local" backend for temporary editing.
+;;
+;; * checkin (file rev comment)
+;;
+;; Commit changes in FILE to this backend. If REV is non-nil, that
+;; should become the new revision number. COMMENT is used as a
+;; check-in comment. The implementation should pass the value of
+;; vc-checkin-switches to the backend command.
+;;
+;; * find-version (file rev buffer)
+;;
+;; Fetch revision REV of file FILE and put it into BUFFER.
+;; If REV is the empty string, fetch the head of the trunk.
+;; The implementation should pass the value of vc-checkout-switches
+;; to the backend command.
+;;
+;; * checkout (file &optional editable rev)
+;;
+;; Check out revision REV of FILE into the working area. If EDITABLE
+;; is non-nil, FILE should be writable by the user and if locking is
+;; used for FILE, a lock should also be set. If REV is non-nil, that
+;; is the revision to check out (default is current workfile version).
+;; If REV is t, that means to check out the head of the current branch;
+;; if it is the empty string, check out the head of the trunk.
+;; The implementation should pass the value of vc-checkout-switches
+;; to the backend command.
+;;
+;; * revert (file &optional contents-done)
+;;
+;; Revert FILE back to the current workfile version. If optional
+;; arg CONTENTS-DONE is non-nil, then the contents of FILE have
+;; already been reverted from a version backup, and this function
+;; only needs to update the status of FILE within the backend.
+;;
+;; - cancel-version (file editable)
+;;
+;; Cancel the current workfile version of FILE, i.e. remove it from the
+;; master. EDITABLE non-nil means that FILE should be writable
+;; afterwards, and if locking is used for FILE, then a lock should also
+;; be set. If this function is not provided, trying to cancel a
+;; version is caught as an error.
+;;
+;; - merge (file rev1 rev2)
+;;
+;; Merge the changes between REV1 and REV2 into the current working file.
+;;
+;; - merge-news (file)
+;;
+;; Merge recent changes from the current branch into FILE.
+;;
+;; - steal-lock (file &optional version)
+;;
+;; Steal any lock on the current workfile version of FILE, or on
+;; VERSION if that is provided. This function is only needed if
+;; locking is used for files under this backend, and if files can
+;; indeed be locked by other users.
+;;
+;; HISTORY FUNCTIONS
+;;
+;; * print-log (file &optional buffer)
+;;
+;; Insert the revision log of FILE into BUFFER, or the *vc* buffer
+;; if BUFFER is nil.
+;;
+;; - log-view-mode ()
+;;
+;; Mode to use for the output of print-log. This defaults to
+;; `log-view-mode' and is expected to be changed (if at all) to a derived
+;; mode of `log-view-mode'.
;;
-;; Rudimentary ClearCase support by Rod Whitby <rwhitby at geocities.com>.
-;; I (Rod Whitby) intend to maintain the rudimentary functionality that is
-;; currently in this file. At some time in the future (don't hold your
-;; breath), I intend to merge the functionality of the cc-vc package
-;; (separately available from /rtfm.mit.edu:/pub/cc-vc/) into this file.
-;; I am not the maintainer of cc-vc, nor am I the maintainer of the
-;; non-ClearCase parts of this file.
+;; -