 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 resolve' 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)

;;; 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 do here:

   (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)
