Second try on fixing the emacs bindings

Package-Manager: portage-2.0.51.22-r1

5 files changed, 425 insertions, 550 deletions

diff --git a/dev-util/subversion/ChangeLog b/dev-util/subversion/ChangeLog
index 80e4c056e333..b1ac8c9e26fa 100644
--- a/dev-util/subversion/ChangeLog
+++ b/dev-util/subversion/ChangeLog
@@ -1,6 +1,11 @@
 # ChangeLog for dev-util/subversion
 # Copyright 2002-2005 Gentoo Foundation; Distributed under the GPL v2
-# $Header: /var/cvsroot/gentoo-x86/dev-util/subversion/ChangeLog,v 1.161 2005/05/27 08:55:03 pauldv Exp $
+# $Header: /var/cvsroot/gentoo-x86/dev-util/subversion/ChangeLog,v 1.162 2005/05/27 13:17:16 pauldv Exp $
+
+  27 May 2005; <pauldv@gentoo.org> +files/vc-svn.el,
+  -files/vc-svn.el.20050527, subversion-1.2.0.ebuild:
+  Use the vc-svn.el from the 1.1.4 version of subversion. The new one 
+  doesn't work with current emacs.
 
   27 May 2005; <pauldv@gentoo.org> +files/vc-svn.el.20050527,
   subversion-1.2.0.ebuild:
diff --git a/dev-util/subversion/Manifest b/dev-util/subversion/Manifest
index 740671036435..dcc209dff450 100644
--- a/dev-util/subversion/Manifest
+++ b/dev-util/subversion/Manifest
@@ -1,12 +1,13 @@
-MD5 a8039e04e19fb36989521846ee25fa08 ChangeLog 27814
+MD5 90e550a554d33f98e10151f9b8fc3cf0 ChangeLog 28028
 MD5 8fbcd267012fd1eef74d5161888cc7b8 metadata.xml 222
 MD5 a2e298f0596fa2fdb58b6ce9e498fcde subversion-1.0.9.ebuild 9523
 MD5 c60d28f0f833c15ac51412e104163f4b subversion-1.1.1-r3.ebuild 10930
-MD5 621ece0fed1bc78a1d09c5f1f6848b86 subversion-1.2.0.ebuild 10490
+MD5 b1cfb27a130b5e0cb5eb70e6ef489bf9 subversion-1.2.0.ebuild 10481
 MD5 4d04ccc1b8acfef398e6041cba214ea1 subversion-1.1.4-r1.ebuild 10382
 MD5 3f83683d616c92808b7199860bea02fd subversion-1.1.3-r1.ebuild 10164
 MD5 d5bdcb0f0a0e607798bd6ee426d8acc2 subversion-1.1.3.ebuild 11118
 MD5 510ae3644667754081230ee08e87eada subversion-1.1.4.ebuild 10289
+MD5 dc8ba46b50a61d868eb76f524c212381 files/vc-svn.el 16847
 MD5 4fd39b311d09602c93a9ff0aceaf8596 files/70svn-gentoo.el 136
 MD5 b355b623d5259b4b1ff75eead17fac0b files/digest-subversion-1.0.9 70
 MD5 53809180b5372b204b32db3962b409ba files/digest-subversion-1.1.1-r3 70
@@ -21,4 +22,3 @@ MD5 9f06ce72de714decff8fad3a674fb64d files/svnserve.xinetd 334
 MD5 505f961a65fe6223d0c8c688aa4c01d0 files/digest-subversion-1.2.0 70
 MD5 1c207179f5bf0b148528312cbc37632d files/digest-subversion-1.1.3 70
 MD5 1c207179f5bf0b148528312cbc37632d files/digest-subversion-1.1.3-r1 70
-MD5 dd98f7a8bef9519fb3ed4096a0b41c1f files/vc-svn.el.20050527 19264
diff --git a/dev-util/subversion/files/vc-svn.el b/dev-util/subversion/files/vc-svn.el
new file mode 100644
index 000000000000..e591820f3abf
--- /dev/null
+++ b/dev-util/subversion/files/vc-svn.el
@@ -0,0 +1,414 @@
+;;;; vc-svn.el --- a VC backend for Subversion
+;;;; Jim Blandy <jimb@red-bean.com> --- July 2002
+
+;;; Writing this back end has shown up some problems in VC: bugs,
+;;; shortcomings in the back end interface, and so on.  But I want to
+;;; first produce code that Subversion users can use with an already
+;;; released Emacs distribution.
+;;;
+;;; So for now we're working within the limitations of the released
+;;; VC; once we've got something functional, then we can start writing
+;;; VC patches.
+
+
+;;; To make this file load on demand, put this file into a directory
+;;; in `load-path', and add this line to a startup file:
+;;;
+;;;     (add-to-list 'vc-handled-backends 'SVN)
+
+
+;;; To do here:
+;;; Provide more of the optional VC backend functions: 
+;;; - dir-state
+;;; - merge across arbitrary revisions
+;;;
+;;; Maybe we want more info in mode-line-string.  Status of props?  Status 
+;;; compared to what's in the repository (svn st -u) ? 
+;;;
+;;; VC passes the vc-svn-register function a COMMENT argument, which
+;;; is like the file description in CVS and RCS.  Could we store the
+;;; COMMENT as a Subversion property?  Would that show up in fancy DAV
+;;; web folder displays, or would it just languish in obscurity, the
+;;; way CVS and RCS descriptions do?
+;;;
+;;; After manual merging, need some way to run `svn resolved'.  Perhaps
+;;; we should just prompt for approval when somebody tries to commit a
+;;; conflicted file?
+;;;
+;;; vc-svn ought to handle more gracefully an attempted commit that
+;;; fails with "Transaction is out of date".  Probably the best
+;;; approach is to ask "file is not up-to-date; do you want to merge
+;;; now?"  I think vc-cvs does this.
+;;;
+;;; Perhaps show the "conflicted" marker in the modeline?
+;;;
+;;; If conflicted, before committing or merging, ask the user if they
+;;; want to mark the file as resolved.
+;;;
+;;; Won't searching for strings in svn output cause trouble if the
+;;; locale language is not English?
+;;;
+;;; After merging news, need to recheck our idea of which workfile
+;;; version we have.  Reverting the file does this but we need to
+;;; force it.  Note that this can be necessary even if the file has
+;;; not changed.
+;;;
+;;; Does everything work properly if we're rolled back to an old
+;;; revision?
+;;;
+;;; Perhaps need to implement vc-svn-latest-on-branch-p?
+
+
+;;; To do in VC:
+;;;
+;;; Make sure vc's documentation for `workfile-unchanged-p' default
+;;; function mentions that it must not run asynchronously, and the
+;;; symptoms if it does.
+;;; 
+;;; Fix logic for finding log entries.
+;;;
+;;; Allow historical diff to choose an appropriate default previous
+;;; revision number.  I think this entails moving vc-previous-revision
+;;; et al into the back end.
+;;;
+;;; Should vc-BACKEND-checkout really have to set the workfile version
+;;; itself?
+;;;
+;;; Fix smerge for svn conflict markers.
+;;;
+;;; We can have files which are not editable for reasons other than
+;;; needing to be checked out.  For example, they might be a read-only
+;;; view of an old revision opened with [C-x v ~].  (See vc-merge)
+;;;
+;;; Would be nice if there was a way to mark a file as
+;;; just-checked-out, aside from updating the checkout-time property
+;;; which in theory is not to be changed by backends.
+
+
+(add-to-list 'vc-handled-backends 'SVN)
+
+(defcustom vc-svn-program-name "svn"
+  "*Name of Subversion client program, for use by Emacs's VC package."
+  :type 'string
+  :group 'vc
+  :version "21.2.90.2")
+
+(defcustom vc-svn-diff-switches nil
+  "*A string or list of strings specifying extra switches for `svn diff' under VC."
+  :type '(repeat string)
+  :group 'vc
+  :version "21.2.90.2")
+
+(defun vc-svn-registered (file)
+  "Return true if FILE is registered under Subversion."
+  ;; First, a quick false positive test: is there a `.svn/entries' file?
+  (and (file-exists-p (expand-file-name ".svn/entries"
+                                        (file-name-directory file)))
+       (not (null (vc-svn-run-status file)))))
+
+
+(put 'vc-svn-with-output-buffer 'lisp-indent-function 0)
+(defmacro vc-svn-with-output-buffer (&rest body)
+  "Save excursion, switch to buffer ` *Subversion Output*', and erase it."
+  `(save-excursion
+     ;; Let's not delete this buffer when we're done --- leave
+     ;; it around for debugging.
+     (set-buffer (get-buffer-create " *Subversion Output*"))
+     (erase-buffer)
+     ,@body))
+
+
+(defun vc-svn-pop-up-error (&rest args)
+  "Pop up the Subversion output buffer, and raise an error with ARGS."
+  (pop-to-buffer " *Subversion Output*")
+  (goto-char (point-min))
+  (shrink-window-if-larger-than-buffer)
+  (apply 'error args))
+
+
+(defun vc-svn-run-status (file &optional update)
+  "Run `svn status -v' on FILE, and return the result.
+If optional arg UPDATE is true, pass the `-u' flag to check against
+the repository, across the network.
+See `vc-svn-parse-status' for a description of the result."
+  (vc-svn-with-output-buffer
+
+    ;; We should call vc-do-command here, but Subversion exits with an
+    ;; error status if FILE isn't under its control, and we want to
+    ;; return that as nil, not display it to the user.  We can tell
+    ;; vc-do-command to
+    
+    (let ((status (apply 'call-process vc-svn-program-name nil t nil
+                         (append '("status" "-v")
+                                 (if update '("-u") '())
+                                 (list file)))))
+      (goto-char (point-min))
+      (if (not (equal 0 status)) ; not zerop; status can be a string
+          ;; If you ask for the status of a file that isn't even in a
+          ;; Subversion-controlled directory, then Subversion exits with
+          ;; this error.
+          (if (or (looking-at "\\(.*\n\\)*.*is not a working copy")
+                  (looking-at "\\(.*\n\\)*.*is not a versioned resource")
+                  (looking-at "\\(.*\n\\)*.*: No such file or directory"))
+              nil
+            ;; Other errors we should actually report to the user.
+            (vc-svn-pop-up-error
+             "Error running Subversion to check status of `%s'"
+             (file-name-nondirectory file)))
+
+        ;; Otherwise, we've got valid status output in the buffer, so
+        ;; just parse that.
+        (vc-svn-parse-status)))))
+
+
+(defun vc-svn-parse-status ()
+  "Parse the output from `svn status -v' at point.
+We return nil for a file not under Subversion's control,
+or (STATE LOCAL CHANGED) for files that are, where:
+STATE is the file's VC state (see the documentation for `vc-state'),
+LOCAL is the base revision in the working copy, and
+CHANGED is the last revision in which it was changed.
+Both LOCAL and CHANGED are strings, not numbers.
+If we passed `svn status' the `-u' flag, then CHANGED could be a later
+revision than LOCAL.
+If the file is newly added, LOCAL is \"0\" and CHANGED is nil."
+  (let ((state (vc-svn-parse-state-only)))
+    (cond
+     ((not state) nil)
+     ;; A newly added file has no revision.
+     ((looking-at "....\\s-+\\(\\*\\s-+\\)?[-0]\\s-+\\?")
+      (list state "0" nil))
+     ((looking-at "....\\s-+\\(\\*\\s-+\\)?\\([0-9]+\\)\\s-+\\([0-9]+\\)")
+      (list state
+            (match-string 2)
+            (match-string 3)))
+     ((looking-at "^I +") nil)       ;; An ignored file
+     ((looking-at " \\{40\\}") nil)  ;; A file that is not in the wc nor svn?
+     (t (error "Couldn't parse output from `svn status -v'")))))
+
+
+(defun vc-svn-parse-state-only ()
+  "Parse the output from `svn status -v' at point, and return a state.
+The documentation for the function `vc-state' describes the possible values."
+  (cond
+   ;; Be careful --- some of the later clauses here could yield false
+   ;; positives, if the clauses preceding them didn't screen those
+   ;; out.  Making a pattern more selective could break something.
+
+   ;; nil                 The given file is not under version control,
+   ;;                     or does not exist.
+   ((looking-at "\\?\\|^$") nil)
+
+   ;; '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.
+   ((looking-at "  ..\\s-+\\*") 'needs-patch)
+
+   ;; 'up-to-date         The working file is unmodified with
+   ;;                     respect to the latest version on the
+   ;;                     current branch, and not locked.
+   ;;
+   ;;                     This is also returned for files which do not
+   ;;                     exist, as will be the case when finding a
+   ;;                     new file in a svn-controlled directory.  That
+   ;;                     case is handled in vc-svn-parse-status.
+   ((looking-at "  ") 'up-to-date)
+
+   ;; '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.
+   ((looking-at "\\S-+\\s-+\\*") 'needs-merge)
+
+   ;; '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.
+   (t 'edited)))
+
+
+;;; Is it really safe not to check for updates?  I haven't seen any
+;;; cases where failing to check causes a problem that is not caught
+;;; in some other way.  However, there *are* cases where checking
+;;; needlessly causes network delay, such as C-x v v.  The common case
+;;; is for the commit to be OK; we can handle errors if they occur. -- mbp
+(defun vc-svn-state (file)
+  "Return the current version control state of FILE.
+For a list of possible return values, see `vc-state'.
+
+This function should do a full and reliable state computation; it is
+usually called immediately after `C-x v v'.  `vc-svn-state-heuristic'
+provides a faster heuristic when visiting a file.
+
+For svn this does *not* check for updates in the repository, because
+that needlessly slows down vc when the repository is remote.  Instead,
+we rely on Subversion to trap situations such as needing a merge
+before commit."
+  (car (vc-svn-run-status file)))
+
+
+(defun vc-svn-state-heuristic (file)
+  "Estimate the version control state of FILE at visiting time.
+For a list of possible values, see the doc string of `vc-state'.
+This is supposed to be considerably faster than `vc-svn-state'.  It
+just runs `svn status -v', without the `-u' flag, so it's a strictly
+local operation."
+  (car (vc-svn-run-status file)))
+
+
+
+(defun vc-svn-workfile-version (file)
+  "Return the current workfile version of FILE."
+  (cadr (vc-svn-run-status file)))
+
+
+(defun vc-svn-checkout-model (file)
+  'implicit)
+
+
+(defun vc-svn-register (file &optional rev comment)
+  "Register FILE with Subversion.
+REV is an initial revision; Subversion ignores it.
+COMMENT is an initial description of the file; currently this is ignored."
+  (vc-svn-with-output-buffer
+    (let ((status (call-process vc-svn-program-name nil t nil "add" file)))
+      (or (equal 0 status) ; not zerop; status can be a string
+          (vc-svn-pop-up-error "Error running Subversion to add `%s'"
+                               (file-name-nondirectory file))))))
+
+
+(defun vc-svn-checkin (file rev comment)
+  (apply 'vc-do-command nil 0 vc-svn-program-name file 
+         "commit" (if comment (list "-m" comment) '())))
+
+
+(defun vc-svn-checkout (file &optional editable rev destfile)
+  "Check out revision REV of FILE into the working area.
+The EDITABLE argument must be non-nil, since Subversion doesn't
+support locking.
+If REV is non-nil, that is the revision to check out (default is
+current workfile version).  If REV is the empty string, that means to
+check out the head of the trunk.  For Subversion, that's equivalent to
+passing nil.
+If optional arg DESTFILE is given, it is an alternate filename to
+write the contents to; we raise an error."
+  (unless editable
+    (error "VC asked Subversion to check out a read-only copy of file"))
+  (when destfile
+    (error "VC asked Subversion to check out a file under another name"))
+  (when (equal rev "")
+    (setq rev nil))
+  (apply 'vc-do-command nil 0 vc-svn-program-name file
+         "update" (if rev (list "-r" rev) '()))
+  (vc-file-setprop file 'vc-workfile-version nil))
+
+
+(defun vc-svn-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.  This
+function ignores the CONTENTS-DONE argument."
+  (vc-do-command nil 0 vc-svn-program-name file "revert"))
+
+
+(defun vc-svn-merge-news (file)
+  "Merge recent changes into FILE.
+
+This calls `svn update'.  In the case of conflicts, Subversion puts
+conflict markers into the file and leaves additional temporary files
+containing the `ancestor', `mine', and `other' files.
+
+You may need to run `svn resolved' by hand once these conflicts have
+been resolved.  
+
+Returns a vc status, which is used to determine whether conflicts need
+to be merged."
+  (prog1
+      (vc-do-command nil 0 vc-svn-program-name file "update")
+    
+    ;; This file may not have changed in the revisions which were
+    ;; merged, which means that its mtime on disk will not have been
+    ;; updated.  However, the workfile version may still have been
+    ;; updated, and we want that to be shown correctly in the
+    ;; modeline.
+
+    ;; vc-cvs does something like this
+    (vc-file-setprop file 'vc-checkout-time 0)
+    (vc-file-setprop file 'vc-workfile-version
+                     (vc-svn-workfile-version file))))
+
+
+(defun vc-svn-print-log (file)
+  "Insert the revision log of FILE into the *vc* buffer."
+  (vc-do-command nil 'async vc-svn-program-name file "log"))
+
+
+(defun vc-svn-show-log-entry (version)
+  "Search the log entry for VERSION in the current buffer.
+Make sure it is displayed in the buffer's window."
+  (when (re-search-forward (concat "^-+\n\\(rev\\) "
+                                   (regexp-quote version)
+                                   ":[^|]+|[^|]+| [0-9]+ lines?"))
+    (goto-char (match-beginning 1))
+    (recenter 1)))
+
+
+(defun vc-svn-diff (file &optional rev1 rev2)
+  "Insert the diff for FILE into the *vc-diff* buffer.
+If REV1 and REV2 are non-nil, report differences from REV1 to REV2.
+If REV1 is nil, use the current workfile version (as found in the
+repository) as the older version; if REV2 is nil, use the current
+workfile contents as the newer version.
+This function returns a status of either 0 (no differences found), or
+1 (either non-empty diff or the diff is run asynchronously)."
+  (let* ((diff-switches-list
+          ;; In Emacs 21.3.50 or so, the `vc-diff-switches-list' macro
+          ;; started requiring its symbol argument to be quoted.
+          (condition-case nil
+              (vc-diff-switches-list svn)
+            (void-variable (vc-diff-switches-list 'SVN))))
+         (status (vc-svn-run-status file))
+         (local (elt status 1))
+         (changed (elt status 2))
+         
+         ;; If rev1 is the default (the base revision) set it to nil.
+         ;; This is nice because it lets us recognize when the diff
+         ;; will run locally, and thus when we shouldn't bother to run
+         ;; it asynchronously.  But it's also necessary, since a diff
+         ;; for vc-default-workfile-unchanged-p *must* run
+         ;; synchronously, or else you'll end up with two diffs in the
+         ;; *vc-diff* buffer.  `vc-diff-workfile-unchanged-p' passes
+         ;; the base revision explicitly, but this kludge lets us
+         ;; recognize that we can run the diff synchronously anyway.
+         ;; Fragile, no?
+         (rev1 (if (and rev1 (not (equal rev1 local))) rev1))
+
+         (rev-switches-list
+          (cond
+           ;; Given base rev against given rev.
+           ((and rev1 rev2) (list "-r" (format "%s:%s" rev1 rev2)))
+           ;; Given base rev against working copy.
+           (rev1 (list "-r" rev1))
+           ;; Working copy base against given rev.
+           (rev2 (list "-r" (format "%s:%s" local rev2)))
+           ;; Working copy base against working copy.
+           (t '())))
+
+         ;; Run diff asynchronously if we're going to have to go
+         ;; across the network.
+         (async (or rev1 rev2)))
+
+    (let ((status (apply 'vc-do-command "*vc-diff*" (if async 'async 0)
+                         vc-svn-program-name file
+                         (append '("diff") rev-switches-list))))
+      (if (or async (> (buffer-size (get-buffer "*vc-diff*")) 0))
+          1 0))))
+
+(defun vc-svn-find-version (file rev buffer)
+  (vc-do-command buffer 0 vc-svn-program-name file 
+         "cat" "-r" rev))
+
+(provide 'vc-svn)
diff --git a/dev-util/subversion/files/vc-svn.el.20050527 b/dev-util/subversion/files/vc-svn.el.20050527
deleted file mode 100644
index b6e3ac295689..000000000000
--- a/dev-util/subversion/files/vc-svn.el.20050527
+++ /dev/null
@@ -1,544 +0,0 @@
-;;; vc-svn.el --- non-resident support for Subversion version-control
-
-;; Copyright (C) 1995, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005
-;;           Free Software Foundation, Inc.
-
-;; Author:      FSF (see vc.el for full credits)
-;; Maintainer:  Stefan Monnier <monnier@gnu.org>
-
-;; This file is part of GNU Emacs.
-
-;; GNU Emacs is free software; you can redistribute it and/or modify
-;; it under the terms of the GNU General Public License as published by
-;; the Free Software Foundation; either version 2, or (at your option)
-;; any later version.
-
-;; GNU Emacs is distributed in the hope that it will be useful,
-;; but WITHOUT ANY WARRANTY; without even the implied warranty of
-;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-;; GNU General Public License for more details.
-
-;; 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.
-
-;;; Commentary:
-
-;; This is preliminary support for Subversion (http://subversion.tigris.org/).
-;; It started as `sed s/cvs/svn/ vc.cvs.el' (from version 1.56)
-;; and hasn't been completely fixed since.
-
-;; Sync'd with Subversion's vc-svn.el as of revision 5801.
-
-;;; Bugs:
-
-;; - VC-dired is (really) slow.
-
-;;; Code:
-
-(eval-when-compile
-  (require 'vc))
-
-;;;
-;;; Customization options
-;;;
-
-(defcustom vc-svn-global-switches nil
-  "*Global switches to pass to any SVN command."
-  :type '(choice (const :tag "None" nil)
-		 (string :tag "Argument String")
-		 (repeat :tag "Argument List"
-			 :value ("")
-			 string))
-  :version "22.1"
-  :group 'vc)
-
-(defcustom vc-svn-register-switches nil
-  "*Extra switches for registering a file into SVN.
-A string or list of strings passed to the checkin program by
-\\[vc-register]."
-  :type '(choice (const :tag "None" nil)
-		 (string :tag "Argument String")
-		 (repeat :tag "Argument List"
-			 :value ("")
-			 string))
-  :version "22.1"
-  :group 'vc)
-
-(defcustom vc-svn-diff-switches
-  t			   ;`svn' doesn't support common args like -c or -b.
-  "String or list of strings specifying extra switches for svn diff under VC.
-If nil, use the value of `vc-diff-switches'.
-If you want to force an empty list of arguments, use t."
-  :type '(choice (const :tag "Unspecified" nil)
-		 (const :tag "None" t)
-		 (string :tag "Argument String")
-		 (repeat :tag "Argument List"
-			 :value ("")
-			 string))
-  :version "22.1"
-  :group 'vc)
-
-(defcustom vc-svn-header (or (cdr (assoc 'SVN vc-header-alist)) '("\$Id\$"))
-  "*Header keywords to be inserted by `vc-insert-headers'."
-  :version "22.1"
-  :type '(repeat string)
-  :group 'vc)
-
-(defconst vc-svn-use-edit nil
-  ;; Subversion does not provide this feature (yet).
-  "*Non-nil means to use `svn edit' to \"check out\" a file.
-This is only meaningful if you don't use the implicit checkout model
-\(i.e. if you have $SVNREAD set)."
-  ;; :type 'boolean
-  ;; :version "22.1"
-  ;; :group 'vc
-  )
-
-;;;
-;;; State-querying functions
-;;;
-
-;;;###autoload (defun vc-svn-registered (f)
-;;;###autoload   (when (file-readable-p (expand-file-name
-;;;###autoload 			  ".svn/entries" (file-name-directory f)))
-;;;###autoload       (load "vc-svn")
-;;;###autoload       (vc-svn-registered f)))
-
-;;;###autoload
-(add-to-list 'completion-ignored-extensions ".svn/")
-
-(defun vc-svn-registered (file)
-  "Check if FILE is SVN registered."
-  (when (file-readable-p (expand-file-name ".svn/entries"
-					   (file-name-directory file)))
-    (with-temp-buffer
-      (cd (file-name-directory file))
-      (condition-case nil
-	  (vc-svn-command t 0 file "status" "-v")
-	;; We can't find an `svn' executable.  We could also deregister SVN.
-	(file-error nil))
-      (vc-svn-parse-status t)
-      (eq 'SVN (vc-file-getprop file 'vc-backend)))))
-
-(defun vc-svn-state (file &optional localp)
-  "SVN-specific version of `vc-state'."
-  (setq localp (or localp (vc-stay-local-p file)))
-  (with-temp-buffer
-    (cd (file-name-directory file))
-    (vc-svn-command t 0 file "status" (if localp "-v" "-u"))
-    (vc-svn-parse-status localp)
-    (vc-file-getprop file 'vc-state)))
-
-(defun vc-svn-state-heuristic (file)
-  "SVN-specific state heuristic."
-  (vc-svn-state file 'local))
-
-(defun vc-svn-dir-state (dir &optional localp)
-  "Find the SVN state of all files in DIR."
-  (setq localp (or localp (vc-stay-local-p dir)))
-  (let ((default-directory dir))
-    ;; Don't specify DIR in this command, the default-directory is
-    ;; enough.  Otherwise it might fail with remote repositories.
-    (with-temp-buffer
-      (vc-svn-command t 0 nil "status" (if localp "-v" "-u"))
-      (vc-svn-parse-status localp))))
-
-(defun vc-svn-workfile-version (file)
-  "SVN-specific version of `vc-workfile-version'."
-  ;; There is no need to consult RCS headers under SVN, because we
-  ;; get the workfile version for free when we recognize that a file
-  ;; is registered in SVN.
-  (vc-svn-registered file)
-  (vc-file-getprop file 'vc-workfile-version))
-
-(defun vc-svn-checkout-model (file)
-  "SVN-specific version of `vc-checkout-model'."
-  ;; It looks like Subversion has no equivalent of CVSREAD.
-  'implicit)
-
-;; vc-svn-mode-line-string doesn't exist because the default implementation
-;; works just fine.
-
-(defun vc-svn-dired-state-info (file)
-  "SVN-specific version of `vc-dired-state-info'."
-  (let ((svn-state (vc-state file)))
-    (cond ((eq svn-state 'edited)
-	   (if (equal (vc-workfile-version file) "0")
-	       "(added)" "(modified)"))
-	  ((eq svn-state 'needs-patch) "(patch)")
-	  ((eq svn-state 'needs-merge) "(merge)"))))
-
-
-;;;
-;;; State-changing functions
-;;;
-
-(defun vc-svn-register (file &optional rev comment)
-  "Register FILE into the SVN version-control system.
-COMMENT can be used to provide an initial description of FILE.
-
-`vc-register-switches' and `vc-svn-register-switches' are passed to
-the SVN command (in that order)."
-  (apply 'vc-svn-command nil 0 file "add" (vc-switches 'SVN 'register)))
-
-(defun vc-svn-responsible-p (file)
-  "Return non-nil if SVN thinks it is responsible for FILE."
-  (file-directory-p (expand-file-name ".svn"
-				      (if (file-directory-p file)
-					  file
-					(file-name-directory file)))))
-
-(defalias 'vc-svn-could-register 'vc-svn-responsible-p
-  "Return non-nil if FILE could be registered in SVN.
-This is only possible if SVN is responsible for FILE's directory.")
-
-(defun vc-svn-checkin (file rev comment)
-  "SVN-specific version of `vc-backend-checkin'."
-  (let ((status (apply
-                 'vc-svn-command nil 1 file "ci"
-                 (nconc (list "-m" comment) (vc-switches 'SVN 'checkin)))))
-    (set-buffer "*vc*")
-    (goto-char (point-min))
-    (unless (equal status 0)
-      ;; Check checkin problem.
-      (cond
-       ((search-forward "Transaction is out of date" nil t)
-        (vc-file-setprop file 'vc-state 'needs-merge)
-        (error (substitute-command-keys
-                (concat "Up-to-date check failed: "
-                        "type \\[vc-next-action] to merge in changes"))))
-       (t
-        (pop-to-buffer (current-buffer))
-        (goto-char (point-min))
-        (shrink-window-if-larger-than-buffer)
-        (error "Check-in failed"))))
-    ;; Update file properties
-    ;; (vc-file-setprop
-    ;;  file 'vc-workfile-version
-    ;;  (vc-parse-buffer "^\\(new\\|initial\\) revision: \\([0-9.]+\\)" 2))
-    ))
-
-(defun vc-svn-find-version (file rev buffer)
-  (apply 'vc-svn-command
-	 buffer 0 file
-	 "cat"
-	 (and rev (not (string= rev ""))
-	      (concat "-r" rev))
-	 (vc-switches 'SVN 'checkout)))
-
-(defun vc-svn-checkout (file &optional editable rev)
-  (message "Checking out %s..." file)
-  (with-current-buffer (or (get-file-buffer file) (current-buffer))
-    (vc-call update file editable rev (vc-switches 'SVN 'checkout)))
-  (vc-mode-line file)
-  (message "Checking out %s...done" file))
-
-(defun vc-svn-update (file editable rev switches)
-  (if (and (file-exists-p file) (not rev))
-      ;; If no revision was specified, just make the file writable
-      ;; if necessary (using `svn-edit' if requested).
-      (and editable (not (eq (vc-svn-checkout-model file) 'implicit))
-	   (if vc-svn-use-edit
-	       (vc-svn-command nil 0 file "edit")
-	     (set-file-modes file (logior (file-modes file) 128))
-	     (if (equal file buffer-file-name) (toggle-read-only -1))))
-    ;; Check out a particular version (or recreate the file).
-    (vc-file-setprop file 'vc-workfile-version nil)
-    (apply 'vc-svn-command nil 0 file
-	   "update"
-	   ;; default for verbose checkout: clear the sticky tag so
-	   ;; that the actual update will get the head of the trunk
-	   (cond
-	    ((null rev) "-rBASE")
-	    ((or (eq rev t) (equal rev "")) nil)
-	    (t (concat "-r" rev)))
-	   switches)))
-
-(defun vc-svn-delete-file (file)
-  (vc-svn-command nil 0 file "remove"))
-
-(defun vc-svn-rename-file (old new)
-  (vc-svn-command nil 0 new "move" (file-relative-name old)))
-
-(defun vc-svn-revert (file &optional contents-done)
-  "Revert FILE to the version it was based on."
-  (unless contents-done
-    (vc-svn-command nil 0 file "revert"))
-  (unless (eq (vc-checkout-model file) 'implicit)
-    (if vc-svn-use-edit
-        (vc-svn-command nil 0 file "unedit")
-      ;; Make the file read-only by switching off all w-bits
-      (set-file-modes file (logand (file-modes file) 3950)))))
-
-(defun vc-svn-merge (file first-version &optional second-version)
-  "Merge changes into current working copy of FILE.
-The changes are between FIRST-VERSION and SECOND-VERSION."
-  (vc-svn-command nil 0 file
-                 "merge"
-		 "-r" (if second-version
-			(concat first-version ":" second-version)
-		      first-version))
-  (vc-file-setprop file 'vc-state 'edited)
-  (with-current-buffer (get-buffer "*vc*")
-    (goto-char (point-min))
-    (if (looking-at "C  ")
-        1				; signal conflict
-      0)))				; signal success
-
-(defun vc-svn-merge-news (file)
-  "Merge in any new changes made to FILE."
-  (message "Merging changes into %s..." file)
-  ;; (vc-file-setprop file 'vc-workfile-version nil)
-  (vc-file-setprop file 'vc-checkout-time 0)
-  (vc-svn-command nil 0 file "update")
-  ;; Analyze the merge result reported by SVN, and set
-  ;; file properties accordingly.
-  (with-current-buffer (get-buffer "*vc*")
-    (goto-char (point-min))
-    ;; get new workfile version
-    (if (re-search-forward
-	 "^\\(Updated to\\|At\\) revision \\([0-9]+\\)" nil t)
-	(vc-file-setprop file 'vc-workfile-version (match-string 2))
-      (vc-file-setprop file 'vc-workfile-version nil))
-    ;; get file status
-    (goto-char (point-min))
-    (prog1
-        (if (looking-at "At revision")
-            0 ;; there were no news; indicate success
-          (if (re-search-forward
-               (concat "^\\([CGDU]  \\)?"
-                       (regexp-quote (file-name-nondirectory file)))
-               nil t)
-              (cond
-               ;; Merge successful, we are in sync with repository now
-               ((string= (match-string 1) "U  ")
-                (vc-file-setprop file 'vc-state 'up-to-date)
-                (vc-file-setprop file 'vc-checkout-time
-                                 (nth 5 (file-attributes file)))
-                0);; indicate success to the caller
-               ;; Merge successful, but our own changes are still in the file
-               ((string= (match-string 1) "G  ")
-                (vc-file-setprop file 'vc-state 'edited)
-                0);; indicate success to the caller
-               ;; Conflicts detected!
-               (t
-                (vc-file-setprop file 'vc-state 'edited)
-                1);; signal the error to the caller
-               )
-            (pop-to-buffer "*vc*")
-            (error "Couldn't analyze svn update result")))
-      (message "Merging changes into %s...done" file))))
-
-
-;;;
-;;; History functions
-;;;
-
-(defun vc-svn-print-log (file &optional buffer)
-  "Get change log associated with FILE."
-  (save-current-buffer
-    (vc-setup-buffer buffer)
-    (let ((inhibit-read-only t))
-      (goto-char (point-min))
-      ;; Add a line to tell log-view-mode what file this is.
-      (insert "Working file: " (file-relative-name file) "\n"))
-    (vc-svn-command
-     buffer
-     (if (and (vc-stay-local-p file) (fboundp 'start-process)) 'async 0)
-     file "log")))
-
-(defun vc-svn-diff (file &optional oldvers newvers buffer)
-  "Get a difference report using SVN between two versions of FILE."
-  (unless buffer (setq buffer "*vc-diff*"))
-  (if (and oldvers (equal oldvers (vc-workfile-version file)))
-      ;; Use nil rather than the current revision because svn handles it
-      ;; better (i.e. locally).
-      (setq oldvers nil))
-  (if (string= (vc-workfile-version file) "0")
-      ;; This file is added but not yet committed; there is no master file.
-      (if (or oldvers newvers)
-	  (error "No revisions of %s exist" file)
-	;; We regard this as "changed".
-	;; Diff it against /dev/null.
-	;; Note: this is NOT a "svn diff".
-	(apply 'vc-do-command buffer
-	       1 "diff" file
-	       (append (vc-switches nil 'diff) '("/dev/null")))
-	;; Even if it's empty, it's locally modified.
-	1)
-    (let* ((switches
-	    (if vc-svn-diff-switches
-		(vc-switches 'SVN 'diff)
-	      (list "-x" (mapconcat 'identity (vc-switches nil 'diff) " "))))
-	   (async (and (not vc-disable-async-diff)
-                       (vc-stay-local-p file)
-		       (or oldvers newvers) ; Svn diffs those locally.
-		       (fboundp 'start-process))))
-      (apply 'vc-svn-command buffer
-	     (if async 'async 0)
-	     file "diff"
-	     (append
-	      switches
-	      (when oldvers
-		(list "-r" (if newvers (concat oldvers ":" newvers)
-			     oldvers)))))
-      (if async 1		      ; async diff => pessimistic assumption
-	;; For some reason `svn diff' does not return a useful
-	;; status w.r.t whether the diff was empty or not.
-	(buffer-size (get-buffer buffer))))))
-
-(defun vc-svn-diff-tree (dir &optional rev1 rev2)
-  "Diff all files at and below DIR."
-  (vc-svn-diff (file-name-as-directory dir) rev1 rev2))
-
-;;;
-;;; Snapshot system
-;;;
-
-(defun vc-svn-create-snapshot (dir name branchp)
-  "Assign to DIR's current version a given NAME.
-If BRANCHP is non-nil, the name is created as a branch (and the current
-workspace is immediately moved to that new branch).
-NAME is assumed to be a URL."
-  (vc-svn-command nil 0 dir "copy" name)
-  (when branchp (vc-svn-retrieve-snapshot dir name nil)))
-
-(defun vc-svn-retrieve-snapshot (dir name update)
-  "Retrieve a snapshot at and below DIR.
-NAME is the name of the snapshot; if it is empty, do a `svn update'.
-If UPDATE is non-nil, then update (resynch) any affected buffers.
-NAME is assumed to be a URL."
-  (vc-svn-command nil 0 dir "switch" name)
-  ;; FIXME: parse the output and obey `update'.
-  )
-
-;;;
-;;; Miscellaneous
-;;;
-
-;; Subversion makes backups for us, so don't bother.
-;; (defalias 'vc-svn-make-version-backups-p 'vc-stay-local-p
-;;   "Return non-nil if version backups should be made for FILE.")
-
-(defun vc-svn-check-headers ()
-  "Check if the current file has any headers in it."
-  (save-excursion
-    (goto-char (point-min))
-    (re-search-forward "\\$[A-Za-z\300-\326\330-\366\370-\377]+\
-\\(: [\t -#%-\176\240-\377]*\\)?\\$" nil t)))
-
-
-;;;
-;;; Internal functions
-;;;
-
-(defun vc-svn-command (buffer okstatus file &rest flags)
-  "A wrapper around `vc-do-command' for use in vc-svn.el.
-The difference to vc-do-command is that this function always invokes `svn',
-and that it passes `vc-svn-global-switches' to it before FLAGS."
-  (apply 'vc-do-command buffer okstatus "svn" file
-         (if (stringp vc-svn-global-switches)
-             (cons vc-svn-global-switches flags)
-           (append vc-svn-global-switches
-                   flags))))
-
-(defun vc-svn-repository-hostname (dirname)
-  (with-temp-buffer
-    (let ((coding-system-for-read
-	   (or file-name-coding-system
-	       default-file-name-coding-system)))
-      (vc-insert-file (expand-file-name ".svn/entries" dirname)))
-    (goto-char (point-min))
-    (when (re-search-forward
-	   ;; Old `svn' used name="svn:dir", newer use just name="".
-	   (concat "name=\"\\(?:svn:this_dir\\)?\"[\n\t ]*"
-		   "\\(?:[-a-z]+=\"[^\"]*\"[\n\t ]*\\)*?"
-		   "url=\"\\([^\"]+\\)\"") nil t)
-      ;; This is not a hostname but a URL.  This may actually be considered
-      ;; as a feature since it allows vc-svn-stay-local to specify different
-      ;; behavior for different modules on the same server.
-      (match-string 1))))
-
-(defun vc-svn-parse-status (localp)
-  "Parse output of \"svn status\" command in the current buffer.
-Set file properties accordingly.  Unless FULL is t, parse only
-essential information."
-  (let (file status)
-    (goto-char (point-min))
-    (while (re-search-forward
-	    "^[ ADMCI?!~][ MC][ L][ +][ S]..\\([ *]\\) +\\([-0-9]+\\) +\\([0-9?]+\\) +\\([^ ]+\\) +" nil t)
-      (setq file (expand-file-name
-		  (buffer-substring (point) (line-end-position))))
-      (setq status (char-after (line-beginning-position)))
-      (unless (eq status ??)
-	(vc-file-setprop file 'vc-backend 'SVN)
-	;; Use the last-modified revision, so that searching in vc-print-log
-	;; output works.
-	(vc-file-setprop file 'vc-workfile-version (match-string 3))
-	(vc-file-setprop
-	 file 'vc-state
-	 (cond
-	  ((eq status ?\ )
-	   (if (eq (char-after (match-beginning 1)) ?*)
-	       'needs-patch
-             (vc-file-setprop file 'vc-checkout-time
-                              (nth 5 (file-attributes file)))
-	     'up-to-date))
-	  ((eq status ?A)
-	   ;; If the file was actually copied, (match-string 2) is "-".
-	   (vc-file-setprop file 'vc-workfile-version "0")
-	   (vc-file-setprop file 'vc-checkout-time 0)
-	   'edited)
-	  ((memq status '(?M ?C))
-	   (if (eq (char-after (match-beginning 1)) ?*)
-	       'needs-merge
-	     'edited))
-	  (t 'edited)))))))
-
-(defun vc-svn-dir-state-heuristic (dir)
-  "Find the SVN state of all files in DIR, using only local information."
-  (vc-svn-dir-state dir 'local))
-
-(defun vc-svn-valid-symbolic-tag-name-p (tag)
-  "Return non-nil if TAG is a valid symbolic tag name."
-  ;; According to the SVN manual, a valid symbolic tag must start with
-  ;; an uppercase or lowercase letter and can contain uppercase and
-  ;; lowercase letters, digits, `-', and `_'.
-  (and (string-match "^[a-zA-Z]" tag)
-       (not (string-match "[^a-z0-9A-Z-_]" tag))))
-
-(defun vc-svn-valid-version-number-p (tag)
-  "Return non-nil if TAG is a valid version number."
-  (and (string-match "^[0-9]" tag)
-       (not (string-match "[^0-9]" tag))))
-
-;; Support for `svn annotate'
-
-(defun vc-svn-annotate-command (file buf &optional rev)
-  (vc-svn-command buf 0 file "annotate" (if rev (concat "-r" rev))))
-
-(defun vc-svn-annotate-time-of-rev (rev)
-  ;; Arbitrarily assume 10 commmits per day.
-  (/ (string-to-number rev) 10.0))
-
-(defun vc-svn-annotate-current-time ()
-  (vc-svn-annotate-time-of-rev vc-annotate-parent-rev))
-
-(defconst vc-svn-annotate-re "[ \t]*\\([0-9]+\\)[ \t]+[^\t ]+ ")
-
-(defun vc-svn-annotate-time ()
-  (when (looking-at vc-svn-annotate-re)
-    (goto-char (match-end 0))
-    (vc-svn-annotate-time-of-rev (match-string 1))))
-
-(defun vc-svn-annotate-extract-revision-at-line ()
-  (save-excursion
-    (beginning-of-line)
-    (if (looking-at vc-svn-annotate-re) (match-string 1))))
-
-(provide 'vc-svn)
-
-;; arch-tag: 02f10c68-2b4d-453a-90fc-1eee6cfb268d
-;;; vc-svn.el ends here
diff --git a/dev-util/subversion/subversion-1.2.0.ebuild b/dev-util/subversion/subversion-1.2.0.ebuild
index bcbdf28efafb..4da35a5efab6 100644
--- a/dev-util/subversion/subversion-1.2.0.ebuild
+++ b/dev-util/subversion/subversion-1.2.0.ebuild
@@ -1,6 +1,6 @@
 # Copyright 1999-2005 Gentoo Foundation
 # Distributed under the terms of the GNU General Public License v2
-# $Header: /var/cvsroot/gentoo-x86/dev-util/subversion/subversion-1.2.0.ebuild,v 1.2 2005/05/27 08:55:03 pauldv Exp $
+# $Header: /var/cvsroot/gentoo-x86/dev-util/subversion/subversion-1.2.0.ebuild,v 1.3 2005/05/27 13:17:16 pauldv Exp $
 
 inherit elisp-common libtool python eutils bash-completion flag-o-matic depend.apache perl-module
 
@@ -66,7 +66,7 @@ src_unpack() {
 	(cd apr-util; autoconf)
 	sed -i -e 's,\(subversion/svnversion/svnversion.*\)\(>.*svn-revision.txt\),echo "exported" \2,' Makefile.in
 
-	use emacs && cp ${FILESDIR}/vc-svn.el.20050527 ${S}/contrib/client-side/vc-svn.el
+	use emacs && cp ${FILESDIR}/vc-svn.el ${S}/contrib/client-side/vc-svn.el
 }
 
 src_compile() {