subversion-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From stef...@apache.org
Subject svn commit: r1498157 [11/11] - in /subversion/branches/fsfs-format7/subversion: libsvn_fs_x/ tests/libsvn_fs_x/
Date Sun, 30 Jun 2013 17:01:17 GMT
Modified: subversion/branches/fsfs-format7/subversion/libsvn_fs_x/tree.h
URL: http://svn.apache.org/viewvc/subversion/branches/fsfs-format7/subversion/libsvn_fs_x/tree.h?rev=1498157&r1=1498156&r2=1498157&view=diff
==============================================================================
--- subversion/branches/fsfs-format7/subversion/libsvn_fs_x/tree.h (original)
+++ subversion/branches/fsfs-format7/subversion/libsvn_fs_x/tree.h Sun Jun 30 17:01:16 2013
@@ -33,77 +33,77 @@ extern "C" {
 
 /* In POOL, create an instance of a DAG node 1st level cache.
    The POOL will be cleared at regular intervals. */
-fs_fs_dag_cache_t*
-svn_fs_fs__create_dag_cache(apr_pool_t *pool);
+fs_x_dag_cache_t*
+svn_fs_x__create_dag_cache(apr_pool_t *pool);
 
 /* Set *ROOT_P to the root directory of revision REV in filesystem FS.
    Allocate the structure in POOL. */
-svn_error_t *svn_fs_fs__revision_root(svn_fs_root_t **root_p, svn_fs_t *fs,
-                                      svn_revnum_t rev, apr_pool_t *pool);
+svn_error_t *svn_fs_x__revision_root(svn_fs_root_t **root_p, svn_fs_t *fs,
+                                     svn_revnum_t rev, apr_pool_t *pool);
 
 /* Does nothing, but included for Subversion 1.0.x compatibility. */
-svn_error_t *svn_fs_fs__deltify(svn_fs_t *fs, svn_revnum_t rev,
-                                apr_pool_t *pool);
+svn_error_t *svn_fs_x__deltify(svn_fs_t *fs, svn_revnum_t rev,
+                               apr_pool_t *pool);
 
 /* Commit the transaction TXN as a new revision.  Return the new
    revision in *NEW_REV.  If the transaction conflicts with other
    changes return SVN_ERR_FS_CONFLICT and set *CONFLICT_P to a string
    that details the cause of the conflict.  Perform temporary
    allocations in POOL. */
-svn_error_t *svn_fs_fs__commit_txn(const char **conflict_p,
-                                   svn_revnum_t *new_rev, svn_fs_txn_t *txn,
-                                   apr_pool_t *pool);
+svn_error_t *svn_fs_x__commit_txn(const char **conflict_p,
+                                  svn_revnum_t *new_rev, svn_fs_txn_t *txn,
+                                  apr_pool_t *pool);
 
 /* Set ROOT_P to the root directory of transaction TXN.  Allocate the
    structure in POOL. */
-svn_error_t *svn_fs_fs__txn_root(svn_fs_root_t **root_p, svn_fs_txn_t *txn,
-                                 apr_pool_t *pool);
+svn_error_t *svn_fs_x__txn_root(svn_fs_root_t **root_p, svn_fs_txn_t *txn,
+                                apr_pool_t *pool);
 
 
 /* Set KIND_P to the node kind of the node at PATH in ROOT.
    Allocate the structure in POOL. */
 svn_error_t *
-svn_fs_fs__check_path(svn_node_kind_t *kind_p,
-                      svn_fs_root_t *root,
-                      const char *path,
-                      apr_pool_t *pool);
+svn_fs_x__check_path(svn_node_kind_t *kind_p,
+                     svn_fs_root_t *root,
+                     const char *path,
+                     apr_pool_t *pool);
 
 /* Implement root_vtable_t.node_id(). */
 svn_error_t *
-svn_fs_fs__node_id(const svn_fs_id_t **id_p,
-                   svn_fs_root_t *root,
-                   const char *path,
-                   apr_pool_t *pool);
+svn_fs_x__node_id(const svn_fs_id_t **id_p,
+                  svn_fs_root_t *root,
+                  const char *path,
+                  apr_pool_t *pool);
 
 /* Set *REVISION to the revision in which PATH under ROOT was created.
    Use POOL for any temporary allocations.  If PATH is in an
    uncommitted transaction, *REVISION will be set to
    SVN_INVALID_REVNUM. */
 svn_error_t *
-svn_fs_fs__node_created_rev(svn_revnum_t *revision,
-                            svn_fs_root_t *root,
-                            const char *path,
-                            apr_pool_t *pool);
+svn_fs_x__node_created_rev(svn_revnum_t *revision,
+                           svn_fs_root_t *root,
+                           const char *path,
+                           apr_pool_t *pool);
 
 /* Verify metadata for ROOT.
    ### Currently only implemented for revision roots. */
 svn_error_t *
-svn_fs_fs__verify_root(svn_fs_root_t *root,
-                       apr_pool_t *pool);
+svn_fs_x__verify_root(svn_fs_root_t *root,
+                      apr_pool_t *pool);
 
 svn_error_t *
-svn_fs_fs__info_format(int *fs_format,
-                       svn_version_t **supports_version,
-                       svn_fs_t *fs,
-                       apr_pool_t *result_pool,
-                       apr_pool_t *scratch_pool);
+svn_fs_x__info_format(int *fs_format,
+                      svn_version_t **supports_version,
+                      svn_fs_t *fs,
+                      apr_pool_t *result_pool,
+                      apr_pool_t *scratch_pool);
 
 
 svn_error_t *
-svn_fs_fs__info_config_files(apr_array_header_t **files,
-                             svn_fs_t *fs,
-                             apr_pool_t *result_pool,
-                             apr_pool_t *scratch_pool);
+svn_fs_x__info_config_files(apr_array_header_t **files,
+                            svn_fs_t *fs,
+                            apr_pool_t *result_pool,
+                            apr_pool_t *scratch_pool);
 
 #ifdef __cplusplus
 }

Modified: subversion/branches/fsfs-format7/subversion/libsvn_fs_x/util.c
URL: http://svn.apache.org/viewvc/subversion/branches/fsfs-format7/subversion/libsvn_fs_x/util.c?rev=1498157&r1=1498156&r2=1498157&view=diff
==============================================================================
--- subversion/branches/fsfs-format7/subversion/libsvn_fs_x/util.c (original)
+++ subversion/branches/fsfs-format7/subversion/libsvn_fs_x/util.c Sun Jun 30 17:01:16 2013
@@ -53,18 +53,18 @@ are likely some errors because of that.
 
 /* Return TRUE is REV is packed in FS, FALSE otherwise. */
 svn_boolean_t
-is_packed_rev(svn_fs_t *fs, svn_revnum_t rev)
+svn_fs_x__is_packed_rev(svn_fs_t *fs, svn_revnum_t rev)
 {
-  fs_fs_data_t *ffd = fs->fsap_data;
+  fs_x_data_t *ffd = fs->fsap_data;
 
   return (rev < ffd->min_unpacked_rev);
 }
 
 /* Return TRUE is REV is packed in FS, FALSE otherwise. */
 svn_boolean_t
-is_packed_revprop(svn_fs_t *fs, svn_revnum_t rev)
+svn_fs_x__is_packed_revprop(svn_fs_t *fs, svn_revnum_t rev)
 {
-  fs_fs_data_t *ffd = fs->fsap_data;
+  fs_x_data_t *ffd = fs->fsap_data;
 
   /* rev 0 will not be packed */
   return (rev < ffd->min_unpacked_rev)
@@ -73,9 +73,9 @@ is_packed_revprop(svn_fs_t *fs, svn_revn
 }
 
 svn_revnum_t
-packed_base_rev(svn_fs_t *fs, svn_revnum_t rev)
+svn_fs_x__packed_base_rev(svn_fs_t *fs, svn_revnum_t rev)
 {
-  fs_fs_data_t *ffd = fs->fsap_data;
+  fs_x_data_t *ffd = fs->fsap_data;
 
   return rev < ffd->min_unpacked_rev
        ? rev - (rev % ffd->max_files_per_dir)
@@ -83,63 +83,63 @@ packed_base_rev(svn_fs_t *fs, svn_revnum
 }
 
 svn_revnum_t
-pack_size(svn_fs_t *fs, svn_revnum_t rev)
+svn_fs_x__pack_size(svn_fs_t *fs, svn_revnum_t rev)
 {
-  fs_fs_data_t *ffd = fs->fsap_data;
+  fs_x_data_t *ffd = fs->fsap_data;
 
   return rev < ffd->min_unpacked_rev ? ffd->max_files_per_dir : 1;
 }
 
 const char *
-path_format(svn_fs_t *fs, apr_pool_t *pool)
+svn_fs_x__path_format(svn_fs_t *fs, apr_pool_t *pool)
 {
   return svn_dirent_join(fs->path, PATH_FORMAT, pool);
 }
 
 const char *
-path_uuid(svn_fs_t *fs, apr_pool_t *pool)
+svn_fs_x__path_uuid(svn_fs_t *fs, apr_pool_t *pool)
 {
   return svn_dirent_join(fs->path, PATH_UUID, pool);
 }
 
 const char *
-svn_fs_fs__path_current(svn_fs_t *fs, apr_pool_t *pool)
+svn_fs_x__path_current(svn_fs_t *fs, apr_pool_t *pool)
 {
   return svn_dirent_join(fs->path, PATH_CURRENT, pool);
 }
 
 const char *
-path_txn_current(svn_fs_t *fs, apr_pool_t *pool)
+svn_fs_x__path_txn_current(svn_fs_t *fs, apr_pool_t *pool)
 {
   return svn_dirent_join(fs->path, PATH_TXN_CURRENT, pool);
 }
 
 const char *
-path_txn_current_lock(svn_fs_t *fs, apr_pool_t *pool)
+svn_fs_x__path_txn_current_lock(svn_fs_t *fs, apr_pool_t *pool)
 {
   return svn_dirent_join(fs->path, PATH_TXN_CURRENT_LOCK, pool);
 }
 
 const char *
-path_lock(svn_fs_t *fs, apr_pool_t *pool)
+svn_fs_x__path_lock(svn_fs_t *fs, apr_pool_t *pool)
 {
   return svn_dirent_join(fs->path, PATH_LOCK_FILE, pool);
 }
 
 const char *
-path_revprop_generation(svn_fs_t *fs, apr_pool_t *pool)
+svn_fs_x__path_revprop_generation(svn_fs_t *fs, apr_pool_t *pool)
 {
   return svn_dirent_join(fs->path, PATH_REVPROP_GENERATION, pool);
 }
 
 const char *
-path_rev_packed(svn_fs_t *fs, svn_revnum_t rev, const char *kind,
-                apr_pool_t *pool)
+svn_fs_x__path_rev_packed(svn_fs_t *fs, svn_revnum_t rev, const char *kind,
+                          apr_pool_t *pool)
 {
-  fs_fs_data_t *ffd = fs->fsap_data;
+  fs_x_data_t *ffd = fs->fsap_data;
 
   assert(ffd->max_files_per_dir);
-  assert(is_packed_rev(fs, rev));
+  assert(svn_fs_x__is_packed_rev(fs, rev));
 
   return svn_dirent_join_many(pool, fs->path, PATH_REVS_DIR,
                               apr_psprintf(pool,
@@ -149,9 +149,9 @@ path_rev_packed(svn_fs_t *fs, svn_revnum
 }
 
 const char *
-path_rev_shard(svn_fs_t *fs, svn_revnum_t rev, apr_pool_t *pool)
+svn_fs_x__path_rev_shard(svn_fs_t *fs, svn_revnum_t rev, apr_pool_t *pool)
 {
-  fs_fs_data_t *ffd = fs->fsap_data;
+  fs_x_data_t *ffd = fs->fsap_data;
 
   assert(ffd->max_files_per_dir);
   return svn_dirent_join_many(pool, fs->path, PATH_REVS_DIR,
@@ -161,15 +161,15 @@ path_rev_shard(svn_fs_t *fs, svn_revnum_
 }
 
 const char *
-path_rev(svn_fs_t *fs, svn_revnum_t rev, apr_pool_t *pool)
+svn_fs_x__path_rev(svn_fs_t *fs, svn_revnum_t rev, apr_pool_t *pool)
 {
-  fs_fs_data_t *ffd = fs->fsap_data;
+  fs_x_data_t *ffd = fs->fsap_data;
 
-  assert(! is_packed_rev(fs, rev));
+  assert(! svn_fs_x__is_packed_rev(fs, rev));
 
   if (ffd->max_files_per_dir)
     {
-      return svn_dirent_join(path_rev_shard(fs, rev, pool),
+      return svn_dirent_join(svn_fs_x__path_rev_shard(fs, rev, pool),
                              apr_psprintf(pool, "%ld", rev),
                              pool);
     }
@@ -179,40 +179,42 @@ path_rev(svn_fs_t *fs, svn_revnum_t rev,
 }
 
 const char *
-path_l2p_index(svn_fs_t *fs,
-               svn_revnum_t rev,
-               apr_pool_t *pool)
+svn_fs_x__path_l2p_index(svn_fs_t *fs,
+                         svn_revnum_t rev,
+                         apr_pool_t *pool)
 {
   return apr_psprintf(pool, "%s" PATH_EXT_L2P_INDEX,
-                      svn_fs_fs__path_rev_absolute(fs, rev, pool));
+                      svn_fs_x__path_rev_absolute(fs, rev, pool));
 }
 
 const char *
-path_p2l_index(svn_fs_t *fs,
-               svn_revnum_t rev,
-               apr_pool_t *pool)
+svn_fs_x__path_p2l_index(svn_fs_t *fs,
+                         svn_revnum_t rev,
+                         apr_pool_t *pool)
 {
   return apr_psprintf(pool, "%s" PATH_EXT_P2L_INDEX,
-                      svn_fs_fs__path_rev_absolute(fs, rev, pool));
+                      svn_fs_x__path_rev_absolute(fs, rev, pool));
 }
 
 const char *
-svn_fs_fs__path_rev_absolute(svn_fs_t *fs,
-                             svn_revnum_t rev,
-                             apr_pool_t *pool)
+svn_fs_x__path_rev_absolute(svn_fs_t *fs,
+                            svn_revnum_t rev,
+                            apr_pool_t *pool)
 {
-  fs_fs_data_t *ffd = fs->fsap_data;
+  fs_x_data_t *ffd = fs->fsap_data;
 
   return (   ffd->format < SVN_FS_FS__MIN_PACKED_FORMAT
-          || ! is_packed_rev(fs, rev))
-       ? path_rev(fs, rev, pool)
-       : path_rev_packed(fs, rev, PATH_PACKED, pool);
+          || ! svn_fs_x__is_packed_rev(fs, rev))
+       ? svn_fs_x__path_rev(fs, rev, pool)
+       : svn_fs_x__path_rev_packed(fs, rev, PATH_PACKED, pool);
 }
 
 const char *
-path_revprops_shard(svn_fs_t *fs, svn_revnum_t rev, apr_pool_t *pool)
+svn_fs_x__path_revprops_shard(svn_fs_t *fs,
+                              svn_revnum_t rev,
+                              apr_pool_t *pool)
 {
-  fs_fs_data_t *ffd = fs->fsap_data;
+  fs_x_data_t *ffd = fs->fsap_data;
 
   assert(ffd->max_files_per_dir);
   return svn_dirent_join_many(pool, fs->path, PATH_REVPROPS_DIR,
@@ -222,9 +224,11 @@ path_revprops_shard(svn_fs_t *fs, svn_re
 }
 
 const char *
-path_revprops_pack_shard(svn_fs_t *fs, svn_revnum_t rev, apr_pool_t *pool)
+svn_fs_x__path_revprops_pack_shard(svn_fs_t *fs,
+                                   svn_revnum_t rev,
+                                   apr_pool_t *pool)
 {
-  fs_fs_data_t *ffd = fs->fsap_data;
+  fs_x_data_t *ffd = fs->fsap_data;
 
   assert(ffd->max_files_per_dir);
   return svn_dirent_join_many(pool, fs->path, PATH_REVPROPS_DIR,
@@ -234,13 +238,13 @@ path_revprops_pack_shard(svn_fs_t *fs, s
 }
 
 const char *
-path_revprops(svn_fs_t *fs, svn_revnum_t rev, apr_pool_t *pool)
+svn_fs_x__path_revprops(svn_fs_t *fs, svn_revnum_t rev, apr_pool_t *pool)
 {
-  fs_fs_data_t *ffd = fs->fsap_data;
+  fs_x_data_t *ffd = fs->fsap_data;
 
   if (ffd->max_files_per_dir)
     {
-      return svn_dirent_join(path_revprops_shard(fs, rev, pool),
+      return svn_dirent_join(svn_fs_x__path_revprops_shard(fs, rev, pool),
                              apr_psprintf(pool, "%ld", rev),
                              pool);
     }
@@ -253,18 +257,18 @@ path_revprops(svn_fs_t *fs, svn_revnum_t
  * Allocate the result in POOL.
  */
 static const char *
-combine_txn_id_string(const svn_fs_fs__id_part_t *txn_id,
+combine_txn_id_string(const svn_fs_x__id_part_t *txn_id,
                       const char *to_add,
                       apr_pool_t *pool)
 {
-  return apr_pstrcat(pool, svn_fs_fs__id_txn_unparse(txn_id, pool),
+  return apr_pstrcat(pool, svn_fs_x__id_txn_unparse(txn_id, pool),
                      to_add, (char *)NULL);
 }
 
 const char *
-path_txn_dir(svn_fs_t *fs,
-             const svn_fs_fs__id_part_t *txn_id,
-             apr_pool_t *pool)
+svn_fs_x__path_txn_dir(svn_fs_t *fs,
+                       const svn_fs_x__id_part_t *txn_id,
+                       apr_pool_t *pool)
 {
   SVN_ERR_ASSERT_NO_RETURN(txn_id != NULL);
   return svn_dirent_join_many(pool, fs->path, PATH_TXNS_DIR,
@@ -277,98 +281,102 @@ path_txn_dir(svn_fs_t *fs,
  * within FS for the given SHA1 checksum.  Use POOL for allocations.
  */
 const char *
-path_txn_sha1(svn_fs_t *fs,
-              const svn_fs_fs__id_part_t *txn_id,
-              const unsigned char *sha1,
-              apr_pool_t *pool)
+svn_fs_x__path_txn_sha1(svn_fs_t *fs,
+                        const svn_fs_x__id_part_t *txn_id,
+                        const unsigned char *sha1,
+                        apr_pool_t *pool)
 {
   svn_checksum_t checksum;
   checksum.digest = sha1;
   checksum.kind = svn_checksum_sha1;
   
-  return svn_dirent_join(path_txn_dir(fs, txn_id, pool),
+  return svn_dirent_join(svn_fs_x__path_txn_dir(fs, txn_id, pool),
                          svn_checksum_to_cstring(&checksum, pool),
                          pool);
 }
 
 const char *
-path_txn_changes(svn_fs_t *fs,
-                 const svn_fs_fs__id_part_t *txn_id,
-                 apr_pool_t *pool)
+svn_fs_x__path_txn_changes(svn_fs_t *fs,
+                           const svn_fs_x__id_part_t *txn_id,
+                           apr_pool_t *pool)
 {
-  return svn_dirent_join(path_txn_dir(fs, txn_id, pool), PATH_CHANGES, pool);
+  return svn_dirent_join(svn_fs_x__path_txn_dir(fs, txn_id, pool),
+                         PATH_CHANGES, pool);
 }
 
 const char *
-path_txn_props(svn_fs_t *fs,
-               const svn_fs_fs__id_part_t *txn_id,
-               apr_pool_t *pool)
+svn_fs_x__path_txn_props(svn_fs_t *fs,
+                         const svn_fs_x__id_part_t *txn_id,
+                         apr_pool_t *pool)
 {
-  return svn_dirent_join(path_txn_dir(fs, txn_id, pool), PATH_TXN_PROPS, pool);
+  return svn_dirent_join(svn_fs_x__path_txn_dir(fs, txn_id, pool),
+                         PATH_TXN_PROPS, pool);
 }
 
 const char*
-path_l2p_proto_index(svn_fs_t *fs,
-                     const svn_fs_fs__id_part_t *txn_id,
-                     apr_pool_t *pool)
+svn_fs_x__path_l2p_proto_index(svn_fs_t *fs,
+                               const svn_fs_x__id_part_t *txn_id,
+                               apr_pool_t *pool)
 {
-  return svn_dirent_join(path_txn_dir(fs, txn_id, pool),
+  return svn_dirent_join(svn_fs_x__path_txn_dir(fs, txn_id, pool),
                          PATH_INDEX PATH_EXT_L2P_INDEX, pool);
 }
 
 const char*
-path_p2l_proto_index(svn_fs_t *fs,
-                     const svn_fs_fs__id_part_t *txn_id,
-                     apr_pool_t *pool)
+svn_fs_x__path_p2l_proto_index(svn_fs_t *fs,
+                               const svn_fs_x__id_part_t *txn_id,
+                               apr_pool_t *pool)
 {
-  return svn_dirent_join(path_txn_dir(fs, txn_id, pool),
+  return svn_dirent_join(svn_fs_x__path_txn_dir(fs, txn_id, pool),
                          PATH_INDEX PATH_EXT_P2L_INDEX, pool);
 }
 
 const char *
-path_txn_next_ids(svn_fs_t *fs,
-                  const svn_fs_fs__id_part_t *txn_id,
-                  apr_pool_t *pool)
+svn_fs_x__path_txn_next_ids(svn_fs_t *fs,
+                            const svn_fs_x__id_part_t *txn_id,
+                            apr_pool_t *pool)
 {
-  return svn_dirent_join(path_txn_dir(fs, txn_id, pool), PATH_NEXT_IDS, pool);
+  return svn_dirent_join(svn_fs_x__path_txn_dir(fs, txn_id, pool),
+                         PATH_NEXT_IDS, pool);
 }
 
 const char *
-path_min_unpacked_rev(svn_fs_t *fs, apr_pool_t *pool)
+svn_fs_x__path_min_unpacked_rev(svn_fs_t *fs, apr_pool_t *pool)
 {
   return svn_dirent_join(fs->path, PATH_MIN_UNPACKED_REV, pool);
 }
 
 const char *
-path_txn_item_index(svn_fs_t *fs,
-                    const svn_fs_fs__id_part_t *txn_id,
-                    apr_pool_t *pool)
+svn_fs_x__path_txn_item_index(svn_fs_t *fs,
+                              const svn_fs_x__id_part_t *txn_id,
+                              apr_pool_t *pool)
 {
-  return svn_dirent_join(path_txn_dir(fs, txn_id, pool),
+  return svn_dirent_join(svn_fs_x__path_txn_dir(fs, txn_id, pool),
                          PATH_TXN_ITEM_INDEX, pool);
 }
 
 const char *
-path_txn_proto_rev(svn_fs_t *fs,
-                   const svn_fs_fs__id_part_t *txn_id,
-                   apr_pool_t *pool)
+svn_fs_x__path_txn_proto_rev(svn_fs_t *fs,
+                             const svn_fs_x__id_part_t *txn_id,
+                             apr_pool_t *pool)
 {
-  fs_fs_data_t *ffd = fs->fsap_data;
+  fs_x_data_t *ffd = fs->fsap_data;
   if (ffd->format >= SVN_FS_FS__MIN_PROTOREVS_DIR_FORMAT)
     return svn_dirent_join_many(pool, fs->path, PATH_TXN_PROTOS_DIR,
                                 combine_txn_id_string(txn_id, PATH_EXT_REV,
                                                       pool),
                                 NULL);
   else
-    return svn_dirent_join(path_txn_dir(fs, txn_id, pool), PATH_REV, pool);
+    return svn_dirent_join(svn_fs_x__path_txn_dir(fs, txn_id, pool),
+                           PATH_REV, pool);
 }
 
 const char *
-path_txn_proto_rev_lock(svn_fs_t *fs,
-                        const svn_fs_fs__id_part_t *txn_id,
-                        apr_pool_t *pool)
+svn_fs_x__path_txn_proto_rev_lock(svn_fs_t *fs,
+                                  const svn_fs_x__id_part_t *txn_id,
+                                  apr_pool_t *pool)
 {
-  fs_fs_data_t *ffd = fs->fsap_data;
+  fs_x_data_t *ffd = fs->fsap_data;
   if (ffd->format >= SVN_FS_FS__MIN_PROTOREVS_DIR_FORMAT)
     return svn_dirent_join_many(pool, fs->path, PATH_TXN_PROTOS_DIR,
                                 combine_txn_id_string(txn_id,
@@ -376,40 +384,45 @@ path_txn_proto_rev_lock(svn_fs_t *fs,
                                                       pool),
                                 NULL);
   else
-    return svn_dirent_join(path_txn_dir(fs, txn_id, pool), PATH_REV_LOCK,
-                           pool);
+    return svn_dirent_join(svn_fs_x__path_txn_dir(fs, txn_id, pool),
+                           PATH_REV_LOCK, pool);
 }
 
 const char *
-path_txn_node_rev(svn_fs_t *fs, const svn_fs_id_t *id, apr_pool_t *pool)
+svn_fs_x__path_txn_node_rev(svn_fs_t *fs,
+                            const svn_fs_id_t *id,
+                            apr_pool_t *pool)
 {
-  char *filename = (char *)svn_fs_fs__id_unparse(id, pool)->data;
+  char *filename = (char *)svn_fs_x__id_unparse(id, pool)->data;
   *strrchr(filename, '.') = '\0';
 
-  return svn_dirent_join(path_txn_dir(fs, svn_fs_fs__id_txn_id(id), pool),
+  return svn_dirent_join(svn_fs_x__path_txn_dir(fs, svn_fs_x__id_txn_id(id),
+                                                pool),
                          apr_psprintf(pool, PATH_PREFIX_NODE "%s",
                                       filename),
                          pool);
 }
 
 const char *
-path_txn_node_props(svn_fs_t *fs, const svn_fs_id_t *id, apr_pool_t *pool)
+svn_fs_x__path_txn_node_props(svn_fs_t *fs,
+                              const svn_fs_id_t *id,
+                              apr_pool_t *pool)
 {
-  return apr_pstrcat(pool, path_txn_node_rev(fs, id, pool), PATH_EXT_PROPS,
-                     (char *)NULL);
+  return apr_pstrcat(pool, svn_fs_x__path_txn_node_rev(fs, id, pool),
+                     PATH_EXT_PROPS, (char *)NULL);
 }
 
 const char *
-path_txn_node_children(svn_fs_t *fs, const svn_fs_id_t *id, apr_pool_t *pool)
+svn_fs_x__path_txn_node_children(svn_fs_t *fs, const svn_fs_id_t *id, apr_pool_t *pool)
 {
-  return apr_pstrcat(pool, path_txn_node_rev(fs, id, pool),
+  return apr_pstrcat(pool, svn_fs_x__path_txn_node_rev(fs, id, pool),
                      PATH_EXT_CHILDREN, (char *)NULL);
 }
 
 const char *
-path_node_origin(svn_fs_t *fs,
-                 const svn_fs_fs__id_part_t *node_id,
-                 apr_pool_t *pool)
+svn_fs_x__path_node_origin(svn_fs_t *fs,
+                           const svn_fs_x__id_part_t *node_id,
+                           apr_pool_t *pool)
 {
   char buffer[SVN_INT64_BUFFER_SIZE];
   apr_size_t len = svn__ui64tobase36(buffer, node_id->number);
@@ -429,9 +442,9 @@ path_node_origin(svn_fs_t *fs,
 
    Uses POOL for temporary allocation. */
 svn_error_t *
-check_file_buffer_numeric(const char *buf, apr_off_t offset,
-                          const char *path, const char *title,
-                          apr_pool_t *pool)
+svn_fs_x__check_file_buffer_numeric(const char *buf, apr_off_t offset,
+                                    const char *path, const char *title,
+                                    apr_pool_t *pool)
 {
   const char *p;
 
@@ -445,16 +458,16 @@ check_file_buffer_numeric(const char *bu
 }
 
 svn_error_t *
-read_min_unpacked_rev(svn_revnum_t *min_unpacked_rev,
-                      svn_fs_t *fs,
-                      apr_pool_t *pool)
+svn_fs_x__read_min_unpacked_rev(svn_revnum_t *min_unpacked_rev,
+                                svn_fs_t *fs,
+                                apr_pool_t *pool)
 {
   char buf[80];
   apr_file_t *file;
   apr_size_t len;
 
   SVN_ERR(svn_io_file_open(&file,
-                           path_min_unpacked_rev(fs, pool),
+                           svn_fs_x__path_min_unpacked_rev(fs, pool),
                            APR_READ | APR_BUFFERED,
                            APR_OS_DEFAULT,
                            pool));
@@ -467,13 +480,13 @@ read_min_unpacked_rev(svn_revnum_t *min_
 }
 
 svn_error_t *
-update_min_unpacked_rev(svn_fs_t *fs, apr_pool_t *pool)
+svn_fs_x__update_min_unpacked_rev(svn_fs_t *fs, apr_pool_t *pool)
 {
-  fs_fs_data_t *ffd = fs->fsap_data;
+  fs_x_data_t *ffd = fs->fsap_data;
 
   SVN_ERR_ASSERT(ffd->format >= SVN_FS_FS__MIN_PACKED_FORMAT);
 
-  return read_min_unpacked_rev(&ffd->min_unpacked_rev, fs, pool);
+  return svn_fs_x__read_min_unpacked_rev(&ffd->min_unpacked_rev, fs, pool);
 }
 
 /* Write a file FILENAME in directory FS_PATH, containing a single line
@@ -482,16 +495,16 @@ update_min_unpacked_rev(svn_fs_t *fs, ap
  *
  * Similar to write_current(). */
 svn_error_t *
-write_revnum_file(svn_fs_t *fs,
-                  svn_revnum_t revnum,
-                  apr_pool_t *scratch_pool)
+svn_fs_x__write_revnum_file(svn_fs_t *fs,
+                            svn_revnum_t revnum,
+                            apr_pool_t *scratch_pool)
 {
   const char *final_path;
   char buf[SVN_INT64_BUFFER_SIZE];
   apr_size_t len = svn__i64toa(buf, revnum);
   buf[len] = '\n';
 
-  final_path = path_min_unpacked_rev(fs, scratch_pool);
+  final_path = svn_fs_x__path_min_unpacked_rev(fs, scratch_pool);
 
   SVN_ERR(svn_io_write_atomic(final_path, buf, len + 1,
                               final_path /* copy_perms */, scratch_pool));
@@ -504,12 +517,13 @@ write_revnum_file(svn_fs_t *fs,
    ignored and may be NULL if the FS format does not use them.)
    Perform temporary allocations in POOL. */
 svn_error_t *
-write_current(svn_fs_t *fs, svn_revnum_t rev, apr_uint64_t next_node_id,
-              apr_uint64_t next_copy_id, apr_pool_t *pool)
+svn_fs_x__write_current(svn_fs_t *fs, svn_revnum_t rev,
+                        apr_uint64_t next_node_id,
+                        apr_uint64_t next_copy_id, apr_pool_t *pool)
 {
   char *buf;
   const char *tmp_name, *name;
-  fs_fs_data_t *ffd = fs->fsap_data;
+  fs_x_data_t *ffd = fs->fsap_data;
 
   /* Now we can just write out this line. */
   if (ffd->format >= SVN_FS_FS__MIN_NO_GLOBAL_IDS_FORMAT)
@@ -526,13 +540,13 @@ write_current(svn_fs_t *fs, svn_revnum_t
       buf = apr_psprintf(pool, "%ld %s %s\n", rev, node_id_str, copy_id_str);
     }
 
-  name = svn_fs_fs__path_current(fs, pool);
+  name = svn_fs_x__path_current(fs, pool);
   SVN_ERR(svn_io_write_unique(&tmp_name,
                               svn_dirent_dirname(name, pool),
                               buf, strlen(buf),
                               svn_io_file_del_none, pool));
 
-  return move_into_place(tmp_name, name, name, pool);
+  return svn_fs_x__move_into_place(tmp_name, name, name, pool);
 }
 
 
@@ -547,11 +561,11 @@ write_current(svn_fs_t *fs, svn_revnum_t
  * Use POOL for allocations.
  */
 svn_error_t *
-try_stringbuf_from_file(svn_stringbuf_t **content,
-                        svn_boolean_t *missing,
-                        const char *path,
-                        svn_boolean_t last_attempt,
-                        apr_pool_t *pool)
+svn_fs_x__try_stringbuf_from_file(svn_stringbuf_t **content,
+                                  svn_boolean_t *missing,
+                                  const char *path,
+                                  svn_boolean_t last_attempt,
+                                  apr_pool_t *pool)
 {
   svn_error_t *err = svn_stringbuf_from_file2(content, path, pool);
   if (missing)
@@ -589,7 +603,9 @@ try_stringbuf_from_file(svn_stringbuf_t 
 
 /* Fetch the current offset of FILE into *OFFSET_P. */
 svn_error_t *
-get_file_offset(apr_off_t *offset_p, apr_file_t *file, apr_pool_t *pool)
+svn_fs_x__get_file_offset(apr_off_t *offset_p,
+                          apr_file_t *file,
+                          apr_pool_t *pool)
 {
   apr_off_t offset;
 
@@ -605,13 +621,15 @@ get_file_offset(apr_off_t *offset_p, apr
 /* Read the 'current' file FNAME and store the contents in *BUF.
    Allocations are performed in POOL. */
 svn_error_t *
-read_content(svn_stringbuf_t **content, const char *fname, apr_pool_t *pool)
+svn_fs_x__read_content(svn_stringbuf_t **content,
+                       const char *fname,
+                       apr_pool_t *pool)
 {
   int i;
   *content = NULL;
 
   for (i = 0; !*content && (i < RECOVERABLE_RETRY_COUNT); ++i)
-    SVN_ERR(try_stringbuf_from_file(content, NULL,
+    SVN_ERR(svn_fs_x__try_stringbuf_from_file(content, NULL,
                                     fname, i + 1 < RECOVERABLE_RETRY_COUNT,
                                     pool));
 
@@ -630,10 +648,10 @@ read_content(svn_stringbuf_t **content, 
  * SCRATCH_POOL is used for temporary allocations.
  */
 svn_error_t *
-read_number_from_stream(apr_int64_t *result,
-                        svn_boolean_t *hit_eof,
-                        svn_stream_t *stream,
-                        apr_pool_t *scratch_pool)
+svn_fs_x__read_number_from_stream(apr_int64_t *result,
+                                  svn_boolean_t *hit_eof,
+                                  svn_stream_t *stream,
+                                  apr_pool_t *scratch_pool)
 {
   svn_stringbuf_t *sb;
   svn_boolean_t eof;
@@ -667,10 +685,10 @@ read_number_from_stream(apr_int64_t *res
    This function almost duplicates svn_io_file_move(), but it tries to
    guarantee a flush. */
 svn_error_t *
-move_into_place(const char *old_filename,
-                const char *new_filename,
-                const char *perms_reference,
-                apr_pool_t *pool)
+svn_fs_x__move_into_place(const char *old_filename,
+                          const char *new_filename,
+                          const char *perms_reference,
+                          apr_pool_t *pool)
 {
   svn_error_t *err;
 

Modified: subversion/branches/fsfs-format7/subversion/libsvn_fs_x/util.h
URL: http://svn.apache.org/viewvc/subversion/branches/fsfs-format7/subversion/libsvn_fs_x/util.h?rev=1498157&r1=1498156&r2=1498157&view=diff
==============================================================================
--- subversion/branches/fsfs-format7/subversion/libsvn_fs_x/util.h (original)
+++ subversion/branches/fsfs-format7/subversion/libsvn_fs_x/util.h Sun Jun 30 17:01:16 2013
@@ -70,166 +70,166 @@
 
 /* Return TRUE is REV is packed in FS, FALSE otherwise. */
 svn_boolean_t
-is_packed_rev(svn_fs_t *fs,
-              svn_revnum_t rev);
+svn_fs_x__is_packed_rev(svn_fs_t *fs,
+                        svn_revnum_t rev);
 
 /* Return TRUE is REV is packed in FS, FALSE otherwise. */
 svn_boolean_t
-is_packed_revprop(svn_fs_t *fs,
-                  svn_revnum_t rev);
+svn_fs_x__is_packed_revprop(svn_fs_t *fs,
+                            svn_revnum_t rev);
 
 /* Return the revision number of the pack / rev file in FS containing REV. */
 svn_revnum_t
-packed_base_rev(svn_fs_t *fs, svn_revnum_t rev);
+svn_fs_x__packed_base_rev(svn_fs_t *fs, svn_revnum_t rev);
 
 /* Return the number of revisions in the pack / rev file in FS that contains
  * revision REV. */
 svn_revnum_t
-pack_size(svn_fs_t *fs, svn_revnum_t rev);
+svn_fs_x__pack_size(svn_fs_t *fs, svn_revnum_t rev);
 
 const char *
-path_format(svn_fs_t *fs,
-            apr_pool_t *pool);
+svn_fs_x__path_format(svn_fs_t *fs,
+                      apr_pool_t *pool);
 
 const char *
-path_uuid(svn_fs_t *fs,
-          apr_pool_t *pool);
+svn_fs_x__path_uuid(svn_fs_t *fs,
+                    apr_pool_t *pool);
 
 const char *
-path_txn_current(svn_fs_t *fs,
-                 apr_pool_t *pool);
+svn_fs_x__path_txn_current(svn_fs_t *fs,
+                           apr_pool_t *pool);
 
 const char *
-path_txn_current_lock(svn_fs_t *fs,
-                      apr_pool_t *pool);
+svn_fs_x__path_txn_current_lock(svn_fs_t *fs,
+                                apr_pool_t *pool);
 
 const char *
-path_lock(svn_fs_t *fs,
-          apr_pool_t *pool);
+svn_fs_x__path_lock(svn_fs_t *fs,
+                    apr_pool_t *pool);
 
 const char *
-path_revprop_generation(svn_fs_t *fs,
-                        apr_pool_t *pool);
+svn_fs_x__path_revprop_generation(svn_fs_t *fs,
+                                  apr_pool_t *pool);
 
 const char *
-path_rev_packed(svn_fs_t *fs,
-                svn_revnum_t rev,
-                const char *kind,
-                apr_pool_t *pool);
+svn_fs_x__path_rev_packed(svn_fs_t *fs,
+                          svn_revnum_t rev,
+                          const char *kind,
+                          apr_pool_t *pool);
 
 const char *
-path_rev_shard(svn_fs_t *fs,
-               svn_revnum_t rev,
-               apr_pool_t *pool);
+svn_fs_x__path_rev_shard(svn_fs_t *fs,
+                         svn_revnum_t rev,
+                         apr_pool_t *pool);
 
 const char *
-path_rev(svn_fs_t *fs,
-         svn_revnum_t rev,
-         apr_pool_t *pool);
+svn_fs_x__path_rev(svn_fs_t *fs,
+                   svn_revnum_t rev,
+                   apr_pool_t *pool);
 
 const char *
-path_l2p_index(svn_fs_t *fs,
-               svn_revnum_t rev,
-               apr_pool_t *pool);
+svn_fs_x__path_l2p_index(svn_fs_t *fs,
+                         svn_revnum_t rev,
+                         apr_pool_t *pool);
 
 const char *
-path_p2l_index(svn_fs_t *fs,
-               svn_revnum_t rev,
-               apr_pool_t *pool);
+svn_fs_x__path_p2l_index(svn_fs_t *fs,
+                         svn_revnum_t rev,
+                         apr_pool_t *pool);
 
 const char *
-path_revprops_shard(svn_fs_t *fs,
-                    svn_revnum_t rev,
-                    apr_pool_t *pool);
+svn_fs_x__path_revprops_shard(svn_fs_t *fs,
+                              svn_revnum_t rev,
+                              apr_pool_t *pool);
 
 const char *
-path_revprops_pack_shard(svn_fs_t *fs,
-                         svn_revnum_t rev,
-                         apr_pool_t *pool);
+svn_fs_x__path_revprops_pack_shard(svn_fs_t *fs,
+                                   svn_revnum_t rev,
+                                   apr_pool_t *pool);
 
 const char *
-path_revprops(svn_fs_t *fs,
-              svn_revnum_t rev,
-              apr_pool_t *pool);
+svn_fs_x__path_revprops(svn_fs_t *fs,
+                        svn_revnum_t rev,
+                        apr_pool_t *pool);
 
 const char *
-path_txn_dir(svn_fs_t *fs,
-             const svn_fs_fs__id_part_t *txn_id,
-             apr_pool_t *pool);
+svn_fs_x__path_txn_dir(svn_fs_t *fs,
+                       const svn_fs_x__id_part_t *txn_id,
+                       apr_pool_t *pool);
 
 /* Return the name of the sha1->rep mapping file in transaction TXN_ID
  * within FS for the given SHA1 checksum.  Use POOL for allocations.
  */
 const char *
-path_txn_sha1(svn_fs_t *fs,
-              const svn_fs_fs__id_part_t *txn_id,
-              const unsigned char *sha1,
-              apr_pool_t *pool);
+svn_fs_x__path_txn_sha1(svn_fs_t *fs,
+                        const svn_fs_x__id_part_t *txn_id,
+                        const unsigned char *sha1,
+                        apr_pool_t *pool);
 
 const char *
-path_txn_changes(svn_fs_t *fs,
-                 const svn_fs_fs__id_part_t *txn_id,
-                 apr_pool_t *pool);
+svn_fs_x__path_txn_changes(svn_fs_t *fs,
+                           const svn_fs_x__id_part_t *txn_id,
+                           apr_pool_t *pool);
 
 const char*
-path_l2p_proto_index(svn_fs_t *fs,
-                     const svn_fs_fs__id_part_t *txn_id,
-                     apr_pool_t *pool);
+svn_fs_x__path_l2p_proto_index(svn_fs_t *fs,
+                               const svn_fs_x__id_part_t *txn_id,
+                               apr_pool_t *pool);
 
 const char*
-path_p2l_proto_index(svn_fs_t *fs,
-                     const svn_fs_fs__id_part_t *txn_id,
-                     apr_pool_t *pool);
+svn_fs_x__path_p2l_proto_index(svn_fs_t *fs,
+                               const svn_fs_x__id_part_t *txn_id,
+                               apr_pool_t *pool);
 
 const char *
-path_txn_props(svn_fs_t *fs,
-               const svn_fs_fs__id_part_t *txn_id,
-               apr_pool_t *pool);
+svn_fs_x__path_txn_props(svn_fs_t *fs,
+                         const svn_fs_x__id_part_t *txn_id,
+                         apr_pool_t *pool);
 
 const char *
-path_txn_next_ids(svn_fs_t *fs,
-                  const svn_fs_fs__id_part_t *txn_id,
-                  apr_pool_t *pool);
+svn_fs_x__path_txn_next_ids(svn_fs_t *fs,
+                            const svn_fs_x__id_part_t *txn_id,
+                            apr_pool_t *pool);
 
 const char *
-path_min_unpacked_rev(svn_fs_t *fs,
-                      apr_pool_t *pool);
+svn_fs_x__path_min_unpacked_rev(svn_fs_t *fs,
+                                apr_pool_t *pool);
 
 
 const char *
-path_txn_item_index(svn_fs_t *fs,
-                    const svn_fs_fs__id_part_t *txn_id,
-                    apr_pool_t *pool);
+svn_fs_x__path_txn_item_index(svn_fs_t *fs,
+                              const svn_fs_x__id_part_t *txn_id,
+                              apr_pool_t *pool);
 
 const char *
-path_txn_proto_rev(svn_fs_t *fs,
-                   const svn_fs_fs__id_part_t *txn_id,
-                   apr_pool_t *pool);
+svn_fs_x__path_txn_proto_rev(svn_fs_t *fs,
+                             const svn_fs_x__id_part_t *txn_id,
+                             apr_pool_t *pool);
 
 const char *
-path_txn_proto_rev_lock(svn_fs_t *fs,
-                        const svn_fs_fs__id_part_t *txn_id,
-                        apr_pool_t *pool);
+svn_fs_x__path_txn_proto_rev_lock(svn_fs_t *fs,
+                                  const svn_fs_x__id_part_t *txn_id,
+                                  apr_pool_t *pool);
 
 const char *
-path_txn_node_rev(svn_fs_t *fs,
-                  const svn_fs_id_t *id,
-                  apr_pool_t *pool);
+svn_fs_x__path_txn_node_rev(svn_fs_t *fs,
+                            const svn_fs_id_t *id,
+                            apr_pool_t *pool);
 
 const char *
-path_txn_node_props(svn_fs_t *fs,
-                    const svn_fs_id_t *id,
-                    apr_pool_t *pool);
+svn_fs_x__path_txn_node_props(svn_fs_t *fs,
+                              const svn_fs_id_t *id,
+                              apr_pool_t *pool);
 
 const char *
-path_txn_node_children(svn_fs_t *fs,
-                       const svn_fs_id_t *id,
-                       apr_pool_t *pool);
+svn_fs_x__path_txn_node_children(svn_fs_t *fs,
+                                 const svn_fs_id_t *id,
+                                 apr_pool_t *pool);
 
 const char *
-path_node_origin(svn_fs_t *fs,
-                 const svn_fs_fs__id_part_t *node_id,
-                 apr_pool_t *pool);
+svn_fs_x__path_node_origin(svn_fs_t *fs,
+                           const svn_fs_x__id_part_t *node_id,
+                           apr_pool_t *pool);
 
 /* Check that BUF, a nul-terminated buffer of text from file PATH,
    contains only digits at OFFSET and beyond, raising an error if not.
@@ -238,20 +238,20 @@ path_node_origin(svn_fs_t *fs,
 
    Uses POOL for temporary allocation. */
 svn_error_t *
-check_file_buffer_numeric(const char *buf,
-                          apr_off_t offset,
-                          const char *path,
-                          const char *title,
-                          apr_pool_t *pool);
+svn_fs_x__check_file_buffer_numeric(const char *buf,
+                                    apr_off_t offset,
+                                    const char *path,
+                                    const char *title,
+                                    apr_pool_t *pool);
 
 svn_error_t *
-read_min_unpacked_rev(svn_revnum_t *min_unpacked_rev,
-                      svn_fs_t *fs,
-                      apr_pool_t *pool);
+svn_fs_x__read_min_unpacked_rev(svn_revnum_t *min_unpacked_rev,
+                                svn_fs_t *fs,
+                                apr_pool_t *pool);
 
 svn_error_t *
-update_min_unpacked_rev(svn_fs_t *fs,
-                        apr_pool_t *pool);
+svn_fs_x__update_min_unpacked_rev(svn_fs_t *fs,
+                                  apr_pool_t *pool);
 
 /* Write a file FILENAME in directory FS_PATH, containing a single line
  * with the number REVNUM in ASCII decimal.  Move the file into place
@@ -259,20 +259,20 @@ update_min_unpacked_rev(svn_fs_t *fs,
  *
  * Similar to write_current(). */
 svn_error_t *
-write_revnum_file(svn_fs_t *fs,
-                  svn_revnum_t revnum,
-                  apr_pool_t *scratch_pool);
+svn_fs_x__write_revnum_file(svn_fs_t *fs,
+                            svn_revnum_t revnum,
+                            apr_pool_t *scratch_pool);
 
 /* Atomically update the 'current' file to hold the specifed REV,
    NEXT_NODE_ID, and NEXT_COPY_ID.  (The two next-ID parameters are
    ignored and may be 0 if the FS format does not use them.)
    Perform temporary allocations in POOL. */
 svn_error_t *
-write_current(svn_fs_t *fs,
-              svn_revnum_t rev,
-              apr_uint64_t next_node_id,
-              apr_uint64_t next_copy_id,
-              apr_pool_t *pool);
+svn_fs_x__write_current(svn_fs_t *fs,
+                        svn_revnum_t rev,
+                        apr_uint64_t next_node_id,
+                        apr_uint64_t next_copy_id,
+                        apr_pool_t *pool);
 
 /* Read the file at PATH and return its content in *CONTENT. *CONTENT will
  * not be modified unless the whole file was read successfully.
@@ -284,24 +284,24 @@ write_current(svn_fs_t *fs,
  * Use POOL for allocations.
  */
 svn_error_t *
-try_stringbuf_from_file(svn_stringbuf_t **content,
-                        svn_boolean_t *missing,
-                        const char *path,
-                        svn_boolean_t last_attempt,
-                        apr_pool_t *pool);
+svn_fs_x__try_stringbuf_from_file(svn_stringbuf_t **content,
+                                  svn_boolean_t *missing,
+                                  const char *path,
+                                  svn_boolean_t last_attempt,
+                                  apr_pool_t *pool);
 
 /* Fetch the current offset of FILE into *OFFSET_P. */
 svn_error_t *
-get_file_offset(apr_off_t *offset_p,
-                apr_file_t *file,
-                apr_pool_t *pool);
+svn_fs_x__get_file_offset(apr_off_t *offset_p,
+                          apr_file_t *file,
+                          apr_pool_t *pool);
 
 /* Read the file FNAME and store the contents in *BUF.
    Allocations are performed in POOL. */
 svn_error_t *
-read_content(svn_stringbuf_t **content,
-             const char *fname,
-             apr_pool_t *pool);
+svn_fs_x__read_content(svn_stringbuf_t **content,
+                       const char *fname,
+                       apr_pool_t *pool);
 
 /* Reads a line from STREAM and converts it to a 64 bit integer to be
  * returned in *RESULT.  If we encounter eof, set *HIT_EOF and leave
@@ -310,10 +310,10 @@ read_content(svn_stringbuf_t **content,
  * SCRATCH_POOL is used for temporary allocations.
  */
 svn_error_t *
-read_number_from_stream(apr_int64_t *result,
-                        svn_boolean_t *hit_eof,
-                        svn_stream_t *stream,
-                        apr_pool_t *scratch_pool);
+svn_fs_x__read_number_from_stream(apr_int64_t *result,
+                                  svn_boolean_t *hit_eof,
+                                  svn_stream_t *stream,
+                                  apr_pool_t *scratch_pool);
 
 /* Move a file into place from OLD_FILENAME in the transactions
    directory to its final location NEW_FILENAME in the repository.  On
@@ -323,9 +323,9 @@ read_number_from_stream(apr_int64_t *res
    This function almost duplicates svn_io_file_move(), but it tries to
    guarantee a flush. */
 svn_error_t *
-move_into_place(const char *old_filename,
-                const char *new_filename,
-                const char *perms_reference,
-                apr_pool_t *pool);
+svn_fs_x__move_into_place(const char *old_filename,
+                          const char *new_filename,
+                          const char *perms_reference,
+                          apr_pool_t *pool);
 
 #endif
\ No newline at end of file

Modified: subversion/branches/fsfs-format7/subversion/libsvn_fs_x/verify.c
URL: http://svn.apache.org/viewvc/subversion/branches/fsfs-format7/subversion/libsvn_fs_x/verify.c?rev=1498157&r1=1498156&r2=1498157&view=diff
==============================================================================
--- subversion/branches/fsfs-format7/subversion/libsvn_fs_x/verify.c (original)
+++ subversion/branches/fsfs-format7/subversion/libsvn_fs_x/verify.c Sun Jun 30 17:01:16 2013
@@ -56,15 +56,15 @@ typedef struct verify_walker_baton_t
   /* remember the last revision for which we called notify_func */
   svn_revnum_t last_notified_revision;
 
-  /* cached hint for successive calls to svn_fs_fs__check_rep() */
+  /* cached hint for successive calls to svn_fs_x__check_rep() */
   void *hint;
 
   /* pool to use for the file handles etc. */
   apr_pool_t *pool;
 } verify_walker_baton_t;
 
-/* Used by svn_fs_fs__verify().
-   Implements svn_fs_fs__walk_rep_reference().walker.  */
+/* Used by svn_fs_x__verify().
+   Implements svn_fs_x__walk_rep_reference().walker.  */
 static svn_error_t *
 verify_walker(representation_t *rep,
               void *baton,
@@ -96,7 +96,7 @@ verify_walker(representation_t *rep,
 
   /* access the repo data */
   previous_hint = walker_baton->hint;
-  SVN_ERR(svn_fs_fs__check_rep(rep, fs, &walker_baton->hint,
+  SVN_ERR(svn_fs_x__check_rep(rep, fs, &walker_baton->hint,
                                walker_baton->pool));
 
   /* update resource usage counters */
@@ -108,7 +108,7 @@ verify_walker(representation_t *rep,
 }
 
 /* Verify the rep cache DB's consistency with our rev / pack data.
- * The function signature is similar to svn_fs_fs__verify.
+ * The function signature is similar to svn_fs_x__verify.
  * The values of START and END have already been auto-selected and
  * verified.
  */
@@ -125,7 +125,7 @@ verify_rep_cache(svn_fs_t *fs,
   svn_boolean_t exists;
 
   /* rep-cache verification. */
-  SVN_ERR(svn_fs_fs__exists_rep_cache(&exists, fs, pool));
+  SVN_ERR(svn_fs_x__exists_rep_cache(&exists, fs, pool));
   if (exists)
     {
       /* provide a baton to allow the reuse of open file handles between
@@ -143,10 +143,10 @@ verify_rep_cache(svn_fs_t *fs,
       /* Do not attempt to walk the rep-cache database if its file does
          not exist,  since doing so would create it --- which may confuse
          the administrator.   Don't take any lock. */
-      SVN_ERR(svn_fs_fs__walk_rep_reference(fs, start, end,
-                                            verify_walker, baton,
-                                            cancel_func, cancel_baton,
-                                            pool));
+      SVN_ERR(svn_fs_x__walk_rep_reference(fs, start, end,
+                                           verify_walker, baton,
+                                           cancel_func, cancel_baton,
+                                           pool));
 
       /* walker resource cleanup */
       svn_pool_destroy(baton->pool);
@@ -173,7 +173,7 @@ compare_l2p_to_p2l_index(svn_fs_t *fs,
   apr_array_header_t *max_ids;
 
   /* determine the range of items to check for each revision */
-  SVN_ERR(svn_fs_fs__l2p_get_max_ids(&max_ids, fs, start, count, pool));
+  SVN_ERR(svn_fs_x__l2p_get_max_ids(&max_ids, fs, start, count, pool));
 
   /* check all items in all revisions if the given range */
   for (i = 0; i < max_ids->nelts; ++i)
@@ -186,17 +186,17 @@ compare_l2p_to_p2l_index(svn_fs_t *fs,
         {
           apr_off_t offset;
           apr_uint32_t sub_item;
-          svn_fs_fs__id_part_t *p2l_item;
+          svn_fs_x__id_part_t *p2l_item;
 
           /* get L2P entry.  Ignore unused entries. */
-          SVN_ERR(svn_fs_fs__item_offset(&offset, &sub_item, fs,
-                                         revision, NULL, k, iterpool));
+          SVN_ERR(svn_fs_x__item_offset(&offset, &sub_item, fs,
+                                        revision, NULL, k, iterpool));
           if (offset == -1)
             continue;
 
           /* find the corresponding P2L entry */
-          SVN_ERR(svn_fs_fs__p2l_item_lookup(&p2l_item, fs, start,
-                                             offset, sub_item, iterpool));
+          SVN_ERR(svn_fs_x__p2l_item_lookup(&p2l_item, fs, start,
+                                            offset, sub_item, iterpool));
 
           if (p2l_item == NULL)
             return svn_error_createf(SVN_ERR_FS_ITEM_INDEX_INCONSISTENT,
@@ -250,19 +250,19 @@ compare_p2l_to_l2p_index(svn_fs_t *fs,
   apr_off_t offset = 0;
 
   /* get the size of the rev / pack file as covered by the P2L index */
-  SVN_ERR(svn_fs_fs__p2l_get_max_offset(&max_offset, fs, start, pool));
+  SVN_ERR(svn_fs_x__p2l_get_max_offset(&max_offset, fs, start, pool));
 
   /* for all offsets in the file, get the P2L index entries and check
      them against the L2P index */
   for (offset = 0; offset < max_offset; )
     {
       apr_array_header_t *entries;
-      svn_fs_fs__p2l_entry_t *last_entry;
+      svn_fs_x__p2l_entry_t *last_entry;
       int i;
 
       /* get all entries for the current block */
-      SVN_ERR(svn_fs_fs__p2l_index_lookup(&entries, fs, start, offset,
-                                          iterpool));
+      SVN_ERR(svn_fs_x__p2l_index_lookup(&entries, fs, start, offset,
+                                         iterpool));
       if (entries->nelts == 0)
         return svn_error_createf(SVN_ERR_FS_ITEM_INDEX_CORRUPTION,
                                  NULL,
@@ -272,25 +272,25 @@ compare_p2l_to_l2p_index(svn_fs_t *fs,
 
       /* process all entries (and later continue with the next block) */
       last_entry
-        = &APR_ARRAY_IDX(entries, entries->nelts-1, svn_fs_fs__p2l_entry_t);
+        = &APR_ARRAY_IDX(entries, entries->nelts-1, svn_fs_x__p2l_entry_t);
       offset = last_entry->offset + last_entry->size;
       
       for (i = 0; i < entries->nelts; ++i)
         {
           apr_uint32_t k;
-          svn_fs_fs__p2l_entry_t *entry
-            = &APR_ARRAY_IDX(entries, i, svn_fs_fs__p2l_entry_t);
+          svn_fs_x__p2l_entry_t *entry
+            = &APR_ARRAY_IDX(entries, i, svn_fs_x__p2l_entry_t);
 
           /* check all sub-items for consist entries in the L2P index */
           for (k = 0; k < entry->item_count; ++k)
             {
               apr_off_t l2p_offset;
               apr_uint32_t sub_item;
-              svn_fs_fs__id_part_t *p2l_item = &entry->items[k];
+              svn_fs_x__id_part_t *p2l_item = &entry->items[k];
 
-              SVN_ERR(svn_fs_fs__item_offset(&l2p_offset, &sub_item, fs,
-                                             p2l_item->revision, NULL,
-                                             p2l_item->number, iterpool));
+              SVN_ERR(svn_fs_x__item_offset(&l2p_offset, &sub_item, fs,
+                                            p2l_item->revision, NULL,
+                                            p2l_item->number, iterpool));
 
               if (sub_item != k || l2p_offset != entry->offset)
                 return svn_error_createf(SVN_ERR_FS_ITEM_INDEX_INCONSISTENT,
@@ -320,7 +320,7 @@ compare_p2l_to_l2p_index(svn_fs_t *fs,
 
 /* Verify that the log-to-phys indexes and phys-to-log indexes are
  * consistent with each other.  The function signature is similar to
- * svn_fs_fs__verify.
+ * svn_fs_x__verify.
  *
  * The values of START and END have already been auto-selected and
  * verified.  You may call this for format7 or higher repos.
@@ -335,14 +335,14 @@ verify_index_consistency(svn_fs_t *fs,
                          void *cancel_baton,
                          apr_pool_t *pool)
 {
-  fs_fs_data_t *ffd = fs->fsap_data;
+  fs_x_data_t *ffd = fs->fsap_data;
   svn_revnum_t revision, pack_start, pack_end;
   apr_pool_t *iterpool = svn_pool_create(pool);
 
   for (revision = start; revision <= end; revision = pack_end)
     {
-      pack_start = packed_base_rev(fs, revision);
-      pack_end = pack_start + pack_size(fs, revision);
+      pack_start = svn_fs_x__packed_base_rev(fs, revision);
+      pack_end = pack_start + svn_fs_x__pack_size(fs, revision);
 
       if (notify_func && (pack_start % ffd->max_files_per_dir == 0))
         notify_func(pack_start, notify_baton, iterpool);
@@ -362,16 +362,16 @@ verify_index_consistency(svn_fs_t *fs,
 }
 
 svn_error_t *
-svn_fs_fs__verify(svn_fs_t *fs,
-                  svn_revnum_t start,
-                  svn_revnum_t end,
-                  svn_fs_progress_notify_func_t notify_func,
-                  void *notify_baton,
-                  svn_cancel_func_t cancel_func,
-                  void *cancel_baton,
-                  apr_pool_t *pool)
+svn_fs_x__verify(svn_fs_t *fs,
+                 svn_revnum_t start,
+                 svn_revnum_t end,
+                 svn_fs_progress_notify_func_t notify_func,
+                 void *notify_baton,
+                 svn_cancel_func_t cancel_func,
+                 void *cancel_baton,
+                 apr_pool_t *pool)
 {
-  fs_fs_data_t *ffd = fs->fsap_data;
+  fs_x_data_t *ffd = fs->fsap_data;
   svn_revnum_t youngest = ffd->youngest_rev_cache; /* cache is current */
 
   /* Input validation. */
@@ -379,8 +379,8 @@ svn_fs_fs__verify(svn_fs_t *fs,
     start = 0;
   if (! SVN_IS_VALID_REVNUM(end))
     end = youngest;
-  SVN_ERR(svn_fs_fs__ensure_revision_exists(start, fs, pool));
-  SVN_ERR(svn_fs_fs__ensure_revision_exists(end, fs, pool));
+  SVN_ERR(svn_fs_x__ensure_revision_exists(start, fs, pool));
+  SVN_ERR(svn_fs_x__ensure_revision_exists(end, fs, pool));
 
   /* log/phys index consistency.  We need to check them first to make
      sure we can access the rev / pack files in format7. */

Modified: subversion/branches/fsfs-format7/subversion/libsvn_fs_x/verify.h
URL: http://svn.apache.org/viewvc/subversion/branches/fsfs-format7/subversion/libsvn_fs_x/verify.h?rev=1498157&r1=1498156&r2=1498157&view=diff
==============================================================================
--- subversion/branches/fsfs-format7/subversion/libsvn_fs_x/verify.h (original)
+++ subversion/branches/fsfs-format7/subversion/libsvn_fs_x/verify.h Sun Jun 30 17:01:16 2013
@@ -30,13 +30,13 @@
  * NOTIFY_FUNC callback using NOTIFY_BATON.  The optional CANCEL_FUNC
  * will periodically be called with CANCEL_BATON to allow for preemption.
  * Use POOL for temporary allocations. */
-svn_error_t *svn_fs_fs__verify(svn_fs_t *fs,
-                               svn_revnum_t start,
-                               svn_revnum_t end,
-                               svn_fs_progress_notify_func_t notify_func,
-                               void *notify_baton,
-                               svn_cancel_func_t cancel_func,
-                               void *cancel_baton,
-                               apr_pool_t *pool);
+svn_error_t *svn_fs_x__verify(svn_fs_t *fs,
+                              svn_revnum_t start,
+                              svn_revnum_t end,
+                              svn_fs_progress_notify_func_t notify_func,
+                              void *notify_baton,
+                              svn_cancel_func_t cancel_func,
+                              void *cancel_baton,
+                              apr_pool_t *pool);
 
 #endif

Modified: subversion/branches/fsfs-format7/subversion/tests/libsvn_fs_x/fs-x-pack-test.c
URL: http://svn.apache.org/viewvc/subversion/branches/fsfs-format7/subversion/tests/libsvn_fs_x/fs-x-pack-test.c?rev=1498157&r1=1498156&r2=1498157&view=diff
==============================================================================
--- subversion/branches/fsfs-format7/subversion/tests/libsvn_fs_x/fs-x-pack-test.c (original)
+++ subversion/branches/fsfs-format7/subversion/tests/libsvn_fs_x/fs-x-pack-test.c Sun Jun 30 17:01:16 2013
@@ -272,7 +272,7 @@ huge_log(svn_revnum_t rev, apr_pool_t *p
 /*** Tests ***/
 
 /* ------------------------------------------------------------------------ */
-#define REPO_NAME "test-repo-fsfs-pack"
+#define REPO_NAME "test-repo-fsx-pack"
 #define SHARD_SIZE 7
 #define MAX_REV 53
 static svn_error_t *
@@ -287,7 +287,7 @@ pack_filesystem(const svn_test_opts_t *o
   apr_size_t len;
 
   /* Bail (with success) on known-untestable scenarios */
-  if ((strcmp(opts->fs_type, "fsfs") != 0)
+  if ((strcmp(opts->fs_type, "fsx") != 0)
       || (opts->server_minor_version && (opts->server_minor_version < 6)))
     return SVN_NO_ERROR;
 
@@ -379,7 +379,7 @@ pack_filesystem(const svn_test_opts_t *o
 #undef MAX_REV
 
 /* ------------------------------------------------------------------------ */
-#define REPO_NAME "test-repo-fsfs-pack-even"
+#define REPO_NAME "test-repo-fsx-pack-even"
 #define SHARD_SIZE 4
 #define MAX_REV 11
 static svn_error_t *
@@ -390,7 +390,7 @@ pack_even_filesystem(const svn_test_opts
   const char *path;
 
   /* Bail (with success) on known-untestable scenarios */
-  if ((strcmp(opts->fs_type, "fsfs") != 0)
+  if ((strcmp(opts->fs_type, "fsx") != 0)
       || (opts->server_minor_version && (opts->server_minor_version < 6)))
     return SVN_NO_ERROR;
 
@@ -423,7 +423,7 @@ read_packed_fs(const svn_test_opts_t *op
   svn_revnum_t i;
 
   /* Bail (with success) on known-untestable scenarios */
-  if ((strcmp(opts->fs_type, "fsfs") != 0)
+  if ((strcmp(opts->fs_type, "fsx") != 0)
       || (opts->server_minor_version && (opts->server_minor_version < 6)))
     return SVN_NO_ERROR;
 
@@ -470,7 +470,7 @@ commit_packed_fs(const svn_test_opts_t *
   svn_revnum_t after_rev;
 
   /* Bail (with success) on known-untestable scenarios */
-  if ((strcmp(opts->fs_type, "fsfs") != 0)
+  if ((strcmp(opts->fs_type, "fsx") != 0)
       || (opts->server_minor_version && (opts->server_minor_version < 6)))
     return SVN_NO_ERROR;
 
@@ -505,7 +505,7 @@ get_set_revprop_packed_fs(const svn_test
   svn_string_t *prop_value;
 
   /* Bail (with success) on known-untestable scenarios */
-  if ((strcmp(opts->fs_type, "fsfs") != 0)
+  if ((strcmp(opts->fs_type, "fsx") != 0)
       || (opts->server_minor_version && (opts->server_minor_version < 7)))
     return SVN_NO_ERROR;
 
@@ -562,7 +562,7 @@ get_set_large_revprop_packed_fs(const sv
   svn_revnum_t rev;
 
   /* Bail (with success) on known-untestable scenarios */
-  if ((strcmp(opts->fs_type, "fsfs") != 0)
+  if ((strcmp(opts->fs_type, "fsx") != 0)
       || (opts->server_minor_version && (opts->server_minor_version < 7)))
     return SVN_NO_ERROR;
 
@@ -635,7 +635,7 @@ get_set_huge_revprop_packed_fs(const svn
   svn_revnum_t rev;
 
   /* Bail (with success) on known-untestable scenarios */
-  if ((strcmp(opts->fs_type, "fsfs") != 0)
+  if ((strcmp(opts->fs_type, "fsx") != 0)
       || (opts->server_minor_version && (opts->server_minor_version < 7)))
     return SVN_NO_ERROR;
 
@@ -708,7 +708,7 @@ recover_fully_packed(const svn_test_opts
   svn_error_t *err;
 
   /* Bail (with success) on known-untestable scenarios */
-  if ((strcmp(opts->fs_type, "fsfs") != 0)
+  if ((strcmp(opts->fs_type, "fsx") != 0)
       || (opts->server_minor_version && (opts->server_minor_version < 7)))
     return SVN_NO_ERROR;
 
@@ -771,7 +771,7 @@ file_hint_at_shard_boundary(const svn_te
   svn_error_t *err = SVN_NO_ERROR;
 
   /* Bail (with success) on known-untestable scenarios */
-  if ((strcmp(opts->fs_type, "fsfs") != 0)
+  if ((strcmp(opts->fs_type, "fsx") != 0)
       || (opts->server_minor_version && (opts->server_minor_version < 8)))
     return SVN_NO_ERROR;
 
@@ -808,7 +808,7 @@ file_hint_at_shard_boundary(const svn_te
 #undef SHARD_SIZE
 
 /* ------------------------------------------------------------------------ */
-#define REPO_NAME "test-repo-fsfs-info"
+#define REPO_NAME "test-repo-fsx-info"
 #define SHARD_SIZE 3
 #define MAX_REV 5
 static svn_error_t *
@@ -829,7 +829,7 @@ test_info(const svn_test_opts_t *opts,
   SVN_TEST_STRING_ASSERT(opts->fs_type, info->fs_type);
 
   /* Bail (with success) on known-untestable scenarios */
-  if (strcmp(opts->fs_type, "fsfs") != 0)
+  if (strcmp(opts->fs_type, "fsx") != 0)
     return SVN_NO_ERROR;
 
   fsfs_info = (const void *)info;
@@ -852,7 +852,7 @@ test_info(const svn_test_opts_t *opts,
 #undef MAX_REV
 
 /* ------------------------------------------------------------------------ */
-#define REPO_NAME "test-repo-fsfs-rev-container"
+#define REPO_NAME "test-repo-fsx-rev-container"
 #define SHARD_SIZE 3
 #define MAX_REV 5
 static svn_error_t *
@@ -860,8 +860,8 @@ test_reps(const svn_test_opts_t *opts,
           apr_pool_t *pool)
 {
   svn_fs_t *fs = NULL;
-  svn_fs_fs__reps_builder_t *builder;
-  svn_fs_fs__reps_t *container;
+  svn_fs_x__reps_builder_t *builder;
+  svn_fs_x__reps_t *container;
   svn_stringbuf_t *serialized;
   svn_stream_t *stream;
   svn_stringbuf_t *contents = svn_stringbuf_create_ensure(10000, pool);
@@ -881,22 +881,22 @@ test_reps(const svn_test_opts_t *opts,
 
   SVN_ERR(svn_fs_open(&fs, REPO_NAME, NULL, pool));
 
-  builder = svn_fs_fs__reps_builder_create(fs, pool);
+  builder = svn_fs_x__reps_builder_create(fs, pool);
   for (i = 10000; i > 10; --i)
     {
       svn_string_t string;
       string.data = contents->data;
       string.len = i;
 
-      svn_fs_fs__reps_add(builder, &string);
+      svn_fs_x__reps_add(builder, &string);
     }
 
   serialized = svn_stringbuf_create_empty(pool);
   stream = svn_stream_from_stringbuf(serialized, pool);
-  SVN_ERR(svn_fs_fs__write_reps_container(stream, builder, pool));
+  SVN_ERR(svn_fs_x__write_reps_container(stream, builder, pool));
 
   SVN_ERR(svn_stream_reset(stream));
-  SVN_ERR(svn_fs_fs__read_reps_container(&container, stream, pool, pool));
+  SVN_ERR(svn_fs_x__read_reps_container(&container, stream, pool, pool));
   SVN_ERR(svn_stream_close(stream));
 
   return SVN_NO_ERROR;
@@ -907,7 +907,7 @@ test_reps(const svn_test_opts_t *opts,
 #undef MAX_REV
 
 /* ------------------------------------------------------------------------ */
-#define REPO_NAME "test-repo-fsfs-pack-shard-size-one"
+#define REPO_NAME "test-repo-fsx-pack-shard-size-one"
 #define SHARD_SIZE 1
 #define MAX_REV 4
 static svn_error_t *
@@ -918,7 +918,7 @@ pack_shard_size_one(const svn_test_opts_
   svn_fs_t *fs;
 
   /* Bail (with success) on known-untestable scenarios */
-  if ((strcmp(opts->fs_type, "fsfs") != 0)
+  if ((strcmp(opts->fs_type, "fsx") != 0)
       || (opts->server_minor_version && (opts->server_minor_version < 6)))
     return SVN_NO_ERROR;
 

Modified: subversion/branches/fsfs-format7/subversion/tests/libsvn_fs_x/string-table-test.c
URL: http://svn.apache.org/viewvc/subversion/branches/fsfs-format7/subversion/tests/libsvn_fs_x/string-table-test.c?rev=1498157&r1=1498156&r2=1498157&view=diff
==============================================================================
--- subversion/branches/fsfs-format7/subversion/tests/libsvn_fs_x/string-table-test.c (original)
+++ subversion/branches/fsfs-format7/subversion/tests/libsvn_fs_x/string-table-test.c Sun Jun 30 17:01:16 2013
@@ -61,7 +61,7 @@ generate_string(apr_uint64_t key, apr_si
     {
       apr_size_t idx;
       apr_size_t add_len;
-      
+
       if (temp == 0)
         {
           temp = key;
@@ -88,13 +88,13 @@ store_and_load_table(string_table_t **ta
   svn_stream_t *stream;
 
   stream = svn_stream_from_stringbuf(stream_buffer, pool);
-  SVN_ERR(svn_fs_fs__write_string_table(stream, *table, pool));
+  SVN_ERR(svn_fs_x__write_string_table(stream, *table, pool));
   SVN_ERR(svn_stream_close(stream));
 
   *table = NULL;
 
   stream = svn_stream_from_stringbuf(stream_buffer, pool);
-  SVN_ERR(svn_fs_fs__read_string_table(table, stream, pool, pool));
+  SVN_ERR(svn_fs_x__read_string_table(table, stream, pool, pool));
   SVN_ERR(svn_stream_close(stream));
 
   return SVN_NO_ERROR;
@@ -105,16 +105,16 @@ create_empty_table_body(svn_boolean_t do
                         apr_pool_t *pool)
 {
   string_table_builder_t *builder
-    = svn_fs_fs__string_table_builder_create(pool);
+    = svn_fs_x__string_table_builder_create(pool);
   string_table_t *table
-    = svn_fs_fs__string_table_create(builder, pool);
+    = svn_fs_x__string_table_create(builder, pool);
 
-  SVN_TEST_STRING_ASSERT(svn_fs_fs__string_table_get(table, 0, NULL, pool), "");
+  SVN_TEST_STRING_ASSERT(svn_fs_x__string_table_get(table, 0, NULL, pool), "");
 
   if (do_load_store)
     SVN_ERR(store_and_load_table(&table, pool));
 
-  SVN_TEST_STRING_ASSERT(svn_fs_fs__string_table_get(table, 0, NULL, pool), "");
+  SVN_TEST_STRING_ASSERT(svn_fs_x__string_table_get(table, 0, NULL, pool), "");
 
   return SVN_NO_ERROR;
 }
@@ -129,11 +129,11 @@ short_string_table_body(svn_boolean_t do
   string_table_t *table;
   int i;
   
-  builder = svn_fs_fs__string_table_builder_create(pool);
+  builder = svn_fs_x__string_table_builder_create(pool);
   for (i = 0; i < STRING_COUNT; ++i)
-    indexes[i] = svn_fs_fs__string_table_builder_add(builder, basic_strings[i], 0);
+    indexes[i] = svn_fs_x__string_table_builder_add(builder, basic_strings[i], 0);
   
-  table = svn_fs_fs__string_table_create(builder, pool);
+  table = svn_fs_x__string_table_create(builder, pool);
   if (do_load_store)
     SVN_ERR(store_and_load_table(&table, pool));
   
@@ -142,15 +142,15 @@ short_string_table_body(svn_boolean_t do
     {
       apr_size_t len;
       const char *string
-        = svn_fs_fs__string_table_get(table, indexes[i], &len, pool);
+        = svn_fs_x__string_table_get(table, indexes[i], &len, pool);
 
       SVN_TEST_STRING_ASSERT(string, basic_strings[i]);
       SVN_TEST_ASSERT(len == strlen(string));
       SVN_TEST_ASSERT(len == strlen(basic_strings[i]));
     }
 
-  SVN_TEST_STRING_ASSERT(svn_fs_fs__string_table_get(table, STRING_COUNT,
-                                                     NULL, pool), "");
+  SVN_TEST_STRING_ASSERT(svn_fs_x__string_table_get(table, STRING_COUNT,
+                                                    NULL, pool), "");
 
   return SVN_NO_ERROR;
 }
@@ -168,14 +168,14 @@ large_string_table_body(svn_boolean_t do
   string_table_t *table;
   int i;
 
-  builder = svn_fs_fs__string_table_builder_create(pool);
+  builder = svn_fs_x__string_table_builder_create(pool);
   for (i = 0; i < COUNT; ++i)
     {
       strings[i] = generate_string(0x1234567876543210ull * (i + 1), 73000 + 1000 * i,  pool);
-      indexes[i] = svn_fs_fs__string_table_builder_add(builder, strings[i]->data, strings[i]->len);
+      indexes[i] = svn_fs_x__string_table_builder_add(builder, strings[i]->data, strings[i]->len);
     }
 
-  table = svn_fs_fs__string_table_create(builder, pool);
+  table = svn_fs_x__string_table_create(builder, pool);
   if (do_load_store)
     SVN_ERR(store_and_load_table(&table, pool));
 
@@ -183,7 +183,7 @@ large_string_table_body(svn_boolean_t do
     {
       apr_size_t len;
       const char *string
-        = svn_fs_fs__string_table_get(table, indexes[i], &len, pool);
+        = svn_fs_x__string_table_get(table, indexes[i], &len, pool);
 
       SVN_TEST_STRING_ASSERT(string, strings[i]->data);
       SVN_TEST_ASSERT(len == strlen(string));
@@ -207,14 +207,17 @@ many_strings_table_body(svn_boolean_t do
   string_table_t *table;
   int i;
 
-  builder = svn_fs_fs__string_table_builder_create(pool);
+  builder = svn_fs_x__string_table_builder_create(pool);
   for (i = 0; i < COUNT; ++i)
     {
-      strings[i] = generate_string(0x1234567876543210ull * (i + 1), (i * i) % 23000,  pool);
-      indexes[i] = svn_fs_fs__string_table_builder_add(builder, strings[i]->data, strings[i]->len);
+      strings[i] = generate_string(0x1234567876543210ull * (i + 1),
+                                   (i * i) % 23000,  pool);
+      indexes[i] = svn_fs_x__string_table_builder_add(builder,
+                                                      strings[i]->data,
+                                                      strings[i]->len);
     }
 
-  table = svn_fs_fs__string_table_create(builder, pool);
+  table = svn_fs_x__string_table_create(builder, pool);
   if (do_load_store)
     SVN_ERR(store_and_load_table(&table, pool));
 
@@ -222,7 +225,7 @@ many_strings_table_body(svn_boolean_t do
     {
       apr_size_t len;
       const char *string
-        = svn_fs_fs__string_table_get(table, indexes[i], &len, pool);
+        = svn_fs_x__string_table_get(table, indexes[i], &len, pool);
 
       SVN_TEST_STRING_ASSERT(string, strings[i]->data);
       SVN_TEST_ASSERT(len == strlen(string));



Mime
View raw message