subversion-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From gst...@apache.org
Subject svn commit: r930468 - in /subversion/trunk/subversion: libsvn_fs/fs-loader.c libsvn_fs_fs/tree.c
Date Sat, 03 Apr 2010 04:03:44 GMT
Author: gstein
Date: Sat Apr  3 04:03:44 2010
New Revision: 930468

URL: http://svn.apache.org/viewvc?rev=930468&view=rev
Log:
Add some svn_error_return love.

* subversion/libsvn_fs/fs-loader.c:
  (...): add svn_error_return to a ton of functions

* subverison/libsvn_fs_fs/tree.c:
  (fs_copy, fs_revision_link): add svn_error_return

Modified:
    subversion/trunk/subversion/libsvn_fs/fs-loader.c
    subversion/trunk/subversion/libsvn_fs_fs/tree.c

Modified: subversion/trunk/subversion/libsvn_fs/fs-loader.c
URL: http://svn.apache.org/viewvc/subversion/trunk/subversion/libsvn_fs/fs-loader.c?rev=930468&r1=930467&r2=930468&view=diff
==============================================================================
--- subversion/trunk/subversion/libsvn_fs/fs-loader.c (original)
+++ subversion/trunk/subversion/libsvn_fs/fs-loader.c Sat Apr  3 04:03:44 2010
@@ -263,7 +263,7 @@ fs_library_vtable(fs_library_vtable_t **
   SVN_ERR(svn_fs_type(&fs_type, path, pool));
 
   /* Fetch the library vtable by name, now that we've chosen one. */
-  return get_library_vtable(vtable, fs_type, pool);
+  return svn_error_return(get_library_vtable(vtable, fs_type, pool));
 }
 
 static svn_error_t *
@@ -279,7 +279,7 @@ write_fs_type(const char *path, const ch
   SVN_ERR(svn_io_file_write_full(file, fs_type, strlen(fs_type), NULL,
                                  pool));
   SVN_ERR(svn_io_file_write_full(file, "\n", 1, NULL, pool));
-  return svn_io_file_close(file, pool);
+  return svn_error_return(svn_io_file_close(file, pool));
 }
 
 
@@ -419,9 +419,9 @@ svn_fs_create(svn_fs_t **fs_p, const cha
   if (err)
     {
       svn_error_clear(err2);
-      return err;
+      return svn_error_return(err);
     }
-  return err2;
+  return svn_error_return(err2);
 }
 
 svn_error_t *
@@ -440,9 +440,9 @@ svn_fs_open(svn_fs_t **fs_p, const char 
   if (err)
     {
       svn_error_clear(err2);
-      return err;
+      return svn_error_return(err);
     }
-  return err2;
+  return svn_error_return(err2);
 }
 
 svn_error_t *
@@ -461,9 +461,9 @@ svn_fs_upgrade(const char *path, apr_poo
   if (err)
     {
       svn_error_clear(err2);
-      return err;
+      return svn_error_return(err);
     }
-  return err2;
+  return svn_error_return(err2);
 }
 
 const char *
@@ -478,7 +478,7 @@ svn_fs_delete_fs(const char *path, apr_p
   fs_library_vtable_t *vtable;
 
   SVN_ERR(fs_library_vtable(&vtable, path, pool));
-  return vtable->delete_fs(path, pool);
+  return svn_error_return(vtable->delete_fs(path, pool));
 }
 
 svn_error_t *
@@ -491,7 +491,7 @@ svn_fs_hotcopy(const char *src_path, con
   SVN_ERR(svn_fs_type(&fs_type, src_path, pool));
   SVN_ERR(get_library_vtable(&vtable, fs_type, pool));
   SVN_ERR(vtable->hotcopy(src_path, dest_path, clean, pool));
-  return write_fs_type(dest_path, fs_type, pool);
+  return svn_error_return(write_fs_type(dest_path, fs_type, pool));
 }
 
 svn_error_t *
@@ -516,9 +516,9 @@ svn_fs_pack(const char *path,
   if (err)
     {
       svn_error_clear(err2);
-      return err;
+      return svn_error_return(err);
     }
-  return err2;
+  return svn_error_return(err2);
 }
 
 svn_error_t *
@@ -539,11 +539,11 @@ svn_fs_recover(const char *path,
   if (err)
     {
       svn_error_clear(err2);
-      return err;
+      return svn_error_return(err);
     }
   if (! err2)
     err2 = vtable->recover(fs, cancel_func, cancel_baton, pool);
-  return err2;
+  return svn_error_return(err2);
 }
 
 
@@ -569,9 +569,9 @@ svn_fs_create_berkeley(svn_fs_t *fs, con
   if (err)
     {
       svn_error_clear(err2);
-      return err;
+      return svn_error_return(err);
     }
-  return err2;
+  return svn_error_return(err2);
 }
 
 svn_error_t *
@@ -588,9 +588,9 @@ svn_fs_open_berkeley(svn_fs_t *fs, const
   if (err)
     {
       svn_error_clear(err2);
-      return err;
+      return svn_error_return(err);
     }
-  return err2;
+  return svn_error_return(err2);
 }
 
 const char *
@@ -602,27 +602,28 @@ svn_fs_berkeley_path(svn_fs_t *fs, apr_p
 svn_error_t *
 svn_fs_delete_berkeley(const char *path, apr_pool_t *pool)
 {
-  return svn_fs_delete_fs(path, pool);
+  return svn_error_return(svn_fs_delete_fs(path, pool));
 }
 
 svn_error_t *
 svn_fs_hotcopy_berkeley(const char *src_path, const char *dest_path,
                         svn_boolean_t clean_logs, apr_pool_t *pool)
 {
-  return svn_fs_hotcopy(src_path, dest_path, clean_logs, pool);
+  return svn_error_return(svn_fs_hotcopy(src_path, dest_path, clean_logs,
+                                         pool));
 }
 
 svn_error_t *
 svn_fs_berkeley_recover(const char *path, apr_pool_t *pool)
 {
-  return svn_fs_recover(path, NULL, NULL, pool);
+  return svn_error_return(svn_fs_recover(path, NULL, NULL, pool));
 }
 
 svn_error_t *
 svn_fs_set_berkeley_errcall(svn_fs_t *fs,
                             void (*handler)(const char *errpfx, char *msg))
 {
-  return fs->vtable->bdb_set_errcall(fs, handler);
+  return svn_error_return(fs->vtable->bdb_set_errcall(fs, handler));
 }
 
 svn_error_t *
@@ -634,7 +635,8 @@ svn_fs_berkeley_logfiles(apr_array_heade
   fs_library_vtable_t *vtable;
 
   SVN_ERR(fs_library_vtable(&vtable, path, pool));
-  return vtable->bdb_logfiles(logfiles, path, only_unused, pool);
+  return svn_error_return(vtable->bdb_logfiles(logfiles, path, only_unused,
+                                               pool));
 }
 
 
@@ -644,7 +646,7 @@ svn_error_t *
 svn_fs_begin_txn2(svn_fs_txn_t **txn_p, svn_fs_t *fs, svn_revnum_t rev,
                   apr_uint32_t flags, apr_pool_t *pool)
 {
-  return fs->vtable->begin_txn(txn_p, fs, rev, flags, pool);
+  return svn_error_return(fs->vtable->begin_txn(txn_p, fs, rev, flags, pool));
 }
 
 
@@ -652,7 +654,7 @@ svn_error_t *
 svn_fs_begin_txn(svn_fs_txn_t **txn_p, svn_fs_t *fs, svn_revnum_t rev,
                  apr_pool_t *pool)
 {
-  return svn_fs_begin_txn2(txn_p, fs, rev, 0, pool);
+  return svn_error_return(svn_fs_begin_txn2(txn_p, fs, rev, 0, pool));
 }
 
 svn_error_t *
@@ -661,7 +663,8 @@ svn_fs__begin_obliteration_txn(svn_fs_tx
                                svn_revnum_t rev,
                                apr_pool_t *pool)
 {
-  return fs->vtable->begin_obliteration_txn(txn_p, fs, rev, pool);
+  return svn_error_return(fs->vtable->begin_obliteration_txn(txn_p, fs, rev,
+                                                             pool));
 }
 
 svn_error_t *
@@ -703,13 +706,13 @@ svn_fs__commit_obliteration_txn(svn_revn
 svn_error_t *
 svn_fs_abort_txn(svn_fs_txn_t *txn, apr_pool_t *pool)
 {
-  return txn->vtable->abort(txn, pool);
+  return svn_error_return(txn->vtable->abort(txn, pool));
 }
 
 svn_error_t *
 svn_fs_purge_txn(svn_fs_t *fs, const char *txn_id, apr_pool_t *pool)
 {
-  return fs->vtable->purge_txn(fs, txn_id, pool);
+  return svn_error_return(fs->vtable->purge_txn(fs, txn_id, pool));
 }
 
 svn_error_t *
@@ -729,41 +732,41 @@ svn_error_t *
 svn_fs_open_txn(svn_fs_txn_t **txn, svn_fs_t *fs, const char *name,
                 apr_pool_t *pool)
 {
-  return fs->vtable->open_txn(txn, fs, name, pool);
+  return svn_error_return(fs->vtable->open_txn(txn, fs, name, pool));
 }
 
 svn_error_t *
 svn_fs_list_transactions(apr_array_header_t **names_p, svn_fs_t *fs,
                          apr_pool_t *pool)
 {
-  return fs->vtable->list_transactions(names_p, fs, pool);
+  return svn_error_return(fs->vtable->list_transactions(names_p, fs, pool));
 }
 
 svn_error_t *
 svn_fs_txn_prop(svn_string_t **value_p, svn_fs_txn_t *txn,
                 const char *propname, apr_pool_t *pool)
 {
-  return txn->vtable->get_prop(value_p, txn, propname, pool);
+  return svn_error_return(txn->vtable->get_prop(value_p, txn, propname, pool));
 }
 
 svn_error_t *
 svn_fs_txn_proplist(apr_hash_t **table_p, svn_fs_txn_t *txn, apr_pool_t *pool)
 {
-  return txn->vtable->get_proplist(table_p, txn, pool);
+  return svn_error_return(txn->vtable->get_proplist(table_p, txn, pool));
 }
 
 svn_error_t *
 svn_fs_change_txn_prop(svn_fs_txn_t *txn, const char *name,
                        const svn_string_t *value, apr_pool_t *pool)
 {
-  return txn->vtable->change_prop(txn, name, value, pool);
+  return svn_error_return(txn->vtable->change_prop(txn, name, value, pool));
 }
 
 svn_error_t *
 svn_fs_change_txn_props(svn_fs_txn_t *txn, const apr_array_header_t *props,
                         apr_pool_t *pool)
 {
-  return txn->vtable->change_props(txn, props, pool);
+  return svn_error_return(txn->vtable->change_props(txn, props, pool));
 }
 
 
@@ -776,7 +779,7 @@ svn_fs_revision_root(svn_fs_root_t **roo
   /* We create a subpool for each root object to allow us to implement
      svn_fs_close_root.  */
   apr_pool_t *subpool = svn_pool_create(pool);
-  return fs->vtable->revision_root(root_p, fs, rev, subpool);
+  return svn_error_return(fs->vtable->revision_root(root_p, fs, rev, subpool));
 }
 
 svn_error_t *
@@ -785,7 +788,7 @@ svn_fs_txn_root(svn_fs_root_t **root_p, 
   /* We create a subpool for each root object to allow us to implement
      svn_fs_close_root.  */
   apr_pool_t *subpool = svn_pool_create(pool);
-  return txn->vtable->root(root_p, txn, subpool);
+  return svn_error_return(txn->vtable->root(root_p, txn, subpool));
 }
 
 void
@@ -871,14 +874,15 @@ svn_error_t *
 svn_fs_check_path(svn_node_kind_t *kind_p, svn_fs_root_t *root,
                   const char *path, apr_pool_t *pool)
 {
-  return root->vtable->check_path(kind_p, root, path, pool);
+  return svn_error_return(root->vtable->check_path(kind_p, root, path, pool));
 }
 
 svn_error_t *
 svn_fs_node_history(svn_fs_history_t **history_p, svn_fs_root_t *root,
                     const char *path, apr_pool_t *pool)
 {
-  return root->vtable->node_history(history_p, root, path, pool);
+  return svn_error_return(root->vtable->node_history(history_p, root, path,
+                                                     pool));
 }
 
 svn_error_t *
@@ -907,42 +911,47 @@ svn_error_t *
 svn_fs_node_id(const svn_fs_id_t **id_p, svn_fs_root_t *root,
                const char *path, apr_pool_t *pool)
 {
-  return root->vtable->node_id(id_p, root, path, pool);
+  return svn_error_return(root->vtable->node_id(id_p, root, path, pool));
 }
 
 svn_error_t *
 svn_fs_node_created_rev(svn_revnum_t *revision, svn_fs_root_t *root,
                         const char *path, apr_pool_t *pool)
 {
-  return root->vtable->node_created_rev(revision, root, path, pool);
+  return svn_error_return(root->vtable->node_created_rev(revision, root, path,
+                                                         pool));
 }
 
 svn_error_t *
 svn_fs_node_origin_rev(svn_revnum_t *revision, svn_fs_root_t *root,
                        const char *path, apr_pool_t *pool)
 {
-  return root->vtable->node_origin_rev(revision, root, path, pool);
+  return svn_error_return(root->vtable->node_origin_rev(revision, root, path,
+                                                        pool));
 }
 
 svn_error_t *
 svn_fs_node_created_path(const char **created_path, svn_fs_root_t *root,
                          const char *path, apr_pool_t *pool)
 {
-  return root->vtable->node_created_path(created_path, root, path, pool);
+  return svn_error_return(root->vtable->node_created_path(created_path, root,
+                                                          path, pool));
 }
 
 svn_error_t *
 svn_fs_node_prop(svn_string_t **value_p, svn_fs_root_t *root,
                  const char *path, const char *propname, apr_pool_t *pool)
 {
-  return root->vtable->node_prop(value_p, root, path, propname, pool);
+  return svn_error_return(root->vtable->node_prop(value_p, root, path,
+                                                  propname, pool));
 }
 
 svn_error_t *
 svn_fs_node_proplist(apr_hash_t **table_p, svn_fs_root_t *root,
                      const char *path, apr_pool_t *pool)
 {
-  return root->vtable->node_proplist(table_p, root, path, pool);
+  return svn_error_return(root->vtable->node_proplist(table_p, root, path,
+                                                      pool));
 }
 
 svn_error_t *
@@ -950,7 +959,8 @@ svn_fs_change_node_prop(svn_fs_root_t *r
                         const char *name, const svn_string_t *value,
                         apr_pool_t *pool)
 {
-  return root->vtable->change_node_prop(root, path, name, value, pool);
+  return svn_error_return(root->vtable->change_node_prop(root, path, name,
+                                                         value, pool));
 }
 
 svn_error_t *
@@ -958,22 +968,26 @@ svn_fs_props_changed(svn_boolean_t *chan
                      const char *path1, svn_fs_root_t *root2,
                      const char *path2, apr_pool_t *pool)
 {
-  return root1->vtable->props_changed(changed_p, root1, path1, root2, path2,
-                                      pool);
+  return svn_error_return(root1->vtable->props_changed(changed_p,
+                                                       root1, path1,
+                                                       root2, path2,
+                                                       pool));
 }
 
 svn_error_t *
 svn_fs_copied_from(svn_revnum_t *rev_p, const char **path_p,
                    svn_fs_root_t *root, const char *path, apr_pool_t *pool)
 {
-  return root->vtable->copied_from(rev_p, path_p, root, path, pool);
+  return svn_error_return(root->vtable->copied_from(rev_p, path_p, root, path,
+                                                    pool));
 }
 
 svn_error_t *
 svn_fs_closest_copy(svn_fs_root_t **root_p, const char **path_p,
                     svn_fs_root_t *root, const char *path, apr_pool_t *pool)
 {
-  return root->vtable->closest_copy(root_p, path_p, root, path, pool);
+  return svn_error_return(root->vtable->closest_copy(root_p, path_p,
+                                                     root, path, pool));
 }
 
 svn_error_t *
@@ -984,8 +998,10 @@ svn_fs_get_mergeinfo(svn_mergeinfo_catal
                      svn_boolean_t include_descendants,
                      apr_pool_t *pool)
 {
-  return root->vtable->get_mergeinfo(catalog, root, paths, inherit,
-                                     include_descendants, pool);
+  return svn_error_return(root->vtable->get_mergeinfo(catalog, root, paths,
+                                                      inherit,
+                                                      include_descendants,
+                                                      pool));
 }
 
 svn_error_t *
@@ -994,29 +1010,32 @@ svn_fs_merge(const char **conflict_p, sv
              const char *target_path, svn_fs_root_t *ancestor_root,
              const char *ancestor_path, apr_pool_t *pool)
 {
-  return target_root->vtable->merge(conflict_p, source_root, source_path,
-                                    target_root, target_path, ancestor_root,
-                                    ancestor_path, pool);
+  return svn_error_return(target_root->vtable->merge(conflict_p,
+                                                     source_root, source_path,
+                                                     target_root, target_path,
+                                                     ancestor_root,
+                                                     ancestor_path, pool));
 }
 
 svn_error_t *
 svn_fs_dir_entries(apr_hash_t **entries_p, svn_fs_root_t *root,
                    const char *path, apr_pool_t *pool)
 {
-  return root->vtable->dir_entries(entries_p, root, path, pool);
+  return svn_error_return(root->vtable->dir_entries(entries_p, root, path,
+                                                    pool));
 }
 
 svn_error_t *
 svn_fs_make_dir(svn_fs_root_t *root, const char *path, apr_pool_t *pool)
 {
   SVN_ERR(path_valid(path, pool));
-  return root->vtable->make_dir(root, path, pool);
+  return svn_error_return(root->vtable->make_dir(root, path, pool));
 }
 
 svn_error_t *
 svn_fs_delete(svn_fs_root_t *root, const char *path, apr_pool_t *pool)
 {
-  return root->vtable->delete_node(root, path, pool);
+  return svn_error_return(root->vtable->delete_node(root, path, pool));
 }
 
 svn_error_t *
@@ -1024,21 +1043,24 @@ svn_fs_copy(svn_fs_root_t *from_root, co
             svn_fs_root_t *to_root, const char *to_path, apr_pool_t *pool)
 {
   SVN_ERR(path_valid(to_path, pool));
-  return to_root->vtable->copy(from_root, from_path, to_root, to_path, pool);
+  return svn_error_return(to_root->vtable->copy(from_root, from_path,
+                                                to_root, to_path, pool));
 }
 
 svn_error_t *
 svn_fs_revision_link(svn_fs_root_t *from_root, svn_fs_root_t *to_root,
                      const char *path, apr_pool_t *pool)
 {
-  return to_root->vtable->revision_link(from_root, to_root, path, pool);
+  return svn_error_return(to_root->vtable->revision_link(from_root, to_root,
+                                                         path, pool));
 }
 
 svn_error_t *
 svn_fs_file_length(svn_filesize_t *length_p, svn_fs_root_t *root,
                    const char *path, apr_pool_t *pool)
 {
-  return root->vtable->file_length(length_p, root, path, pool);
+  return svn_error_return(root->vtable->file_length(length_p, root, path,
+                                                    pool));
 }
 
 svn_error_t *
@@ -1086,14 +1108,15 @@ svn_error_t *
 svn_fs_file_contents(svn_stream_t **contents, svn_fs_root_t *root,
                      const char *path, apr_pool_t *pool)
 {
-  return root->vtable->file_contents(contents, root, path, pool);
+  return svn_error_return(root->vtable->file_contents(contents, root, path,
+                                                      pool));
 }
 
 svn_error_t *
 svn_fs_make_file(svn_fs_root_t *root, const char *path, apr_pool_t *pool)
 {
   SVN_ERR(path_valid(path, pool));
-  return root->vtable->make_file(root, path, pool);
+  return svn_error_return(root->vtable->make_file(root, path, pool));
 }
 
 svn_error_t *
@@ -1111,8 +1134,13 @@ svn_fs_apply_textdelta(svn_txdelta_windo
   SVN_ERR(svn_checksum_parse_hex(&result, svn_checksum_md5, result_checksum,
                                  pool));
 
-  return root->vtable->apply_textdelta(contents_p, contents_baton_p, root,
-                                       path, base, result, pool);
+  return svn_error_return(root->vtable->apply_textdelta(contents_p,
+                                                        contents_baton_p,
+                                                        root,
+                                                        path,
+                                                        base,
+                                                        result,
+                                                        pool));
 }
 
 svn_error_t *
@@ -1127,7 +1155,8 @@ svn_fs_apply_text(svn_stream_t **content
   SVN_ERR(svn_checksum_parse_hex(&result, svn_checksum_md5, result_checksum,
                                  pool));
 
-  return root->vtable->apply_text(contents_p, root, path, result, pool);
+  return svn_error_return(root->vtable->apply_text(contents_p, root, path,
+                                                   result, pool));
 }
 
 svn_error_t *
@@ -1135,41 +1164,46 @@ svn_fs_contents_changed(svn_boolean_t *c
                         const char *path1, svn_fs_root_t *root2,
                         const char *path2, apr_pool_t *pool)
 {
-  return root1->vtable->contents_changed(changed_p, root1, path1, root2,
-                                         path2, pool);
+  return svn_error_return(root1->vtable->contents_changed(changed_p,
+                                                          root1, path1,
+                                                          root2, path2,
+                                                          pool));
 }
 
 svn_error_t *
 svn_fs_youngest_rev(svn_revnum_t *youngest_p, svn_fs_t *fs, apr_pool_t *pool)
 {
-  return fs->vtable->youngest_rev(youngest_p, fs, pool);
+  return svn_error_return(fs->vtable->youngest_rev(youngest_p, fs, pool));
 }
 
 svn_error_t *
 svn_fs_deltify_revision(svn_fs_t *fs, svn_revnum_t revision, apr_pool_t *pool)
 {
-  return fs->vtable->deltify(fs, revision, pool);
+  return svn_error_return(fs->vtable->deltify(fs, revision, pool));
 }
 
 svn_error_t *
 svn_fs_revision_prop(svn_string_t **value_p, svn_fs_t *fs, svn_revnum_t rev,
                      const char *propname, apr_pool_t *pool)
 {
-  return fs->vtable->revision_prop(value_p, fs, rev, propname, pool);
+  return svn_error_return(fs->vtable->revision_prop(value_p, fs, rev,
+                                                    propname, pool));
 }
 
 svn_error_t *
 svn_fs_revision_proplist(apr_hash_t **table_p, svn_fs_t *fs, svn_revnum_t rev,
                          apr_pool_t *pool)
 {
-  return fs->vtable->revision_proplist(table_p, fs, rev, pool);
+  return svn_error_return(fs->vtable->revision_proplist(table_p, fs, rev,
+                                                        pool));
 }
 
 svn_error_t *
 svn_fs_change_rev_prop(svn_fs_t *fs, svn_revnum_t rev, const char *name,
                        const svn_string_t *value, apr_pool_t *pool)
 {
-  return fs->vtable->change_rev_prop(fs, rev, name, value, pool);
+  return svn_error_return(fs->vtable->change_rev_prop(fs, rev, name, value,
+                                                      pool));
 }
 
 svn_error_t *
@@ -1179,15 +1213,16 @@ svn_fs_get_file_delta_stream(svn_txdelta
                              svn_fs_root_t *target_root,
                              const char *target_path, apr_pool_t *pool)
 {
-  return target_root->vtable->get_file_delta_stream(stream_p, source_root,
-                                                    source_path, target_root,
-                                                    target_path, pool);
+  return svn_error_return(target_root->vtable->get_file_delta_stream(
+                            stream_p,
+                            source_root, source_path,
+                            target_root, target_path, pool));
 }
 
 svn_error_t *
 svn_fs_get_uuid(svn_fs_t *fs, const char **uuid, apr_pool_t *pool)
 {
-  return fs->vtable->get_uuid(fs, uuid, pool);
+  return svn_error_return(fs->vtable->get_uuid(fs, uuid, pool));
 }
 
 svn_error_t *
@@ -1205,7 +1240,7 @@ svn_fs_set_uuid(svn_fs_t *fs, const char
         return svn_error_createf(SVN_ERR_BAD_UUID, NULL,
                                  _("Malformed UUID '%s'"), uuid);
     }
-  return fs->vtable->set_uuid(fs, uuid, pool);
+  return svn_error_return(fs->vtable->set_uuid(fs, uuid, pool));
 }
 
 svn_error_t *
@@ -1229,28 +1264,30 @@ svn_fs_lock(svn_lock_t **lock, svn_fs_t 
           (SVN_ERR_INCORRECT_PARAMS, NULL,
            _("Negative expiration date passed to svn_fs_lock"));
 
-  return fs->vtable->lock(lock, fs, path, token, comment, is_dav_comment,
-                          expiration_date, current_rev, steal_lock, pool);
+  return svn_error_return(fs->vtable->lock(lock, fs, path, token, comment,
+                                           is_dav_comment, expiration_date,
+                                           current_rev, steal_lock, pool));
 }
 
 svn_error_t *
 svn_fs_generate_lock_token(const char **token, svn_fs_t *fs, apr_pool_t *pool)
 {
-  return fs->vtable->generate_lock_token(token, fs, pool);
+  return svn_error_return(fs->vtable->generate_lock_token(token, fs, pool));
 }
 
 svn_error_t *
 svn_fs_unlock(svn_fs_t *fs, const char *path, const char *token,
               svn_boolean_t break_lock, apr_pool_t *pool)
 {
-  return fs->vtable->unlock(fs, path, token, break_lock, pool);
+  return svn_error_return(fs->vtable->unlock(fs, path, token, break_lock,
+                                             pool));
 }
 
 svn_error_t *
 svn_fs_get_lock(svn_lock_t **lock, svn_fs_t *fs, const char *path,
                 apr_pool_t *pool)
 {
-  return fs->vtable->get_lock(lock, fs, path, pool);
+  return svn_error_return(fs->vtable->get_lock(lock, fs, path, pool));
 }
 
 svn_error_t *
@@ -1259,8 +1296,8 @@ svn_fs_get_locks(svn_fs_t *fs, const cha
                  void *get_locks_baton,
                  apr_pool_t *pool)
 {
-  return fs->vtable->get_locks(fs, path, get_locks_func,
-                               get_locks_baton, pool);
+  return svn_error_return(fs->vtable->get_locks(fs, path, get_locks_func,
+                                                get_locks_baton, pool));
 }
 
 
@@ -1272,14 +1309,16 @@ svn_fs_history_prev(svn_fs_history_t **p
                     svn_fs_history_t *history, svn_boolean_t cross_copies,
                     apr_pool_t *pool)
 {
-  return history->vtable->prev(prev_history_p, history, cross_copies, pool);
+  return svn_error_return(history->vtable->prev(prev_history_p, history,
+                                                cross_copies, pool));
 }
 
 svn_error_t *
 svn_fs_history_location(const char **path, svn_revnum_t *revision,
                         svn_fs_history_t *history, apr_pool_t *pool)
 {
-  return history->vtable->location(path, revision, history, pool);
+  return svn_error_return(history->vtable->location(path, revision, history,
+                                                    pool));
 }
 
 

Modified: subversion/trunk/subversion/libsvn_fs_fs/tree.c
URL: http://svn.apache.org/viewvc/subversion/trunk/subversion/libsvn_fs_fs/tree.c?rev=930468&r1=930467&r2=930468&view=diff
==============================================================================
--- subversion/trunk/subversion/libsvn_fs_fs/tree.c (original)
+++ subversion/trunk/subversion/libsvn_fs_fs/tree.c Sat Apr  3 04:03:44 2010
@@ -2132,7 +2132,8 @@ fs_copy(svn_fs_root_t *from_root,
         const char *to_path,
         apr_pool_t *pool)
 {
-  return copy_helper(from_root, from_path, to_root, to_path, TRUE, pool);
+  return svn_error_return(copy_helper(from_root, from_path, to_root, to_path,
+                                    TRUE, pool));
 }
 
 
@@ -2148,7 +2149,8 @@ fs_revision_link(svn_fs_root_t *from_roo
   if (! to_root->is_txn_root)
     return SVN_FS__NOT_TXN(to_root);
 
-  return copy_helper(from_root, path, to_root, path, FALSE, pool);
+  return svn_error_return(copy_helper(from_root, path, to_root, path,
+                                      FALSE, pool));
 }
 
 



Mime
View raw message