subversion-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From hwri...@apache.org
Subject svn commit: r1154262 [2/4] - in /subversion/branches/fs-py: ./ subversion/libsvn_fs_py/
Date Fri, 05 Aug 2011 15:20:24 GMT
Modified: subversion/branches/fs-py/subversion/libsvn_fs_py/fs_fs.c
URL: http://svn.apache.org/viewvc/subversion/branches/fs-py/subversion/libsvn_fs_py/fs_fs.c?rev=1154262&r1=1154224&r2=1154262&view=diff
==============================================================================
--- subversion/branches/fs-py/subversion/libsvn_fs_py/fs_fs.c (original)
+++ subversion/branches/fs-py/subversion/libsvn_fs_py/fs_fs.c Fri Aug  5 15:20:23 2011
@@ -128,13 +128,13 @@ are likely some errors because of that.
 
 /* The vtable associated with an open transaction object. */
 static txn_vtable_t txn_vtable = {
-  svn_fs_fs__commit_txn,
-  svn_fs_fs__abort_txn,
-  svn_fs_fs__txn_prop,
-  svn_fs_fs__txn_proplist,
-  svn_fs_fs__change_txn_prop,
-  svn_fs_fs__txn_root,
-  svn_fs_fs__change_txn_props
+  svn_fs_py__commit_txn,
+  svn_fs_py__abort_txn,
+  svn_fs_py__txn_prop,
+  svn_fs_py__txn_proplist,
+  svn_fs_py__change_txn_prop,
+  svn_fs_py__txn_root,
+  svn_fs_py__change_txn_props
 };
 
 /* Declarations. */
@@ -184,7 +184,7 @@ path_uuid(svn_fs_t *fs, apr_pool_t *pool
 }
 
 const char *
-svn_fs_fs__path_current(svn_fs_t *fs, apr_pool_t *pool)
+svn_fs_py__path_current(svn_fs_t *fs, apr_pool_t *pool)
 {
   return svn_dirent_join(fs->path, PATH_CURRENT, pool);
 }
@@ -253,7 +253,7 @@ path_rev(svn_fs_t *fs, svn_revnum_t rev,
 }
 
 svn_error_t *
-svn_fs_fs__path_rev_absolute(const char **path,
+svn_fs_py__path_rev_absolute(const char **path,
                              svn_fs_t *fs,
                              svn_revnum_t rev,
                              apr_pool_t *pool)
@@ -366,9 +366,9 @@ path_txn_proto_rev_lock(svn_fs_t *fs, co
 static const char *
 path_txn_node_rev(svn_fs_t *fs, const svn_fs_id_t *id, apr_pool_t *pool)
 {
-  const char *txn_id = svn_fs_fs__id_txn_id(id);
-  const char *node_id = svn_fs_fs__id_node_id(id);
-  const char *copy_id = svn_fs_fs__id_copy_id(id);
+  const char *txn_id = svn_fs_py__id_txn_id(id);
+  const char *node_id = svn_fs_py__id_node_id(id);
+  const char *copy_id = svn_fs_py__id_copy_id(id);
   const char *name = apr_psprintf(pool, PATH_PREFIX_NODE "%s.%s",
                                   node_id, copy_id);
 
@@ -611,7 +611,7 @@ with_some_lock(svn_fs_t *fs,
 }
 
 svn_error_t *
-svn_fs_fs__with_write_lock(svn_fs_t *fs,
+svn_fs_py__with_write_lock(svn_fs_t *fs,
                            svn_error_t *(*body)(void *baton,
                                                 apr_pool_t *pool),
                            void *baton,
@@ -868,7 +868,7 @@ purge_shared_txn_body(svn_fs_t *fs, cons
   const char *txn_id = baton;
 
   free_shared_txn(fs, txn_id);
-  svn_fs_fs__reset_txn_caches(fs);
+  svn_fs_py__reset_txn_caches(fs);
 
   return SVN_NO_ERROR;
 }
@@ -1087,7 +1087,7 @@ check_format(int format)
 }
 
 svn_boolean_t
-svn_fs_fs__fs_supports_mergeinfo(svn_fs_t *fs)
+svn_fs_py__fs_supports_mergeinfo(svn_fs_t *fs)
 {
   fs_fs_data_t *ffd = fs->fsap_data;
   return ffd->format >= SVN_FS_FS__MIN_MERGEINFO_FORMAT;
@@ -1201,7 +1201,7 @@ static svn_error_t *
 get_youngest(svn_revnum_t *youngest_p, const char *fs_path, apr_pool_t *pool);
 
 svn_error_t *
-svn_fs_fs__open(svn_fs_t *fs, const char *path, apr_pool_t *pool)
+svn_fs_py__open(svn_fs_t *fs, const char *path, apr_pool_t *pool)
 {
   fs_fs_data_t *ffd = fs->fsap_data;
   apr_file_t *uuid_file;
@@ -1320,9 +1320,9 @@ upgrade_body(void *baton, apr_pool_t *po
 
 
 svn_error_t *
-svn_fs_fs__upgrade(svn_fs_t *fs, apr_pool_t *pool)
+svn_fs_py__upgrade(svn_fs_t *fs, apr_pool_t *pool)
 {
-  return svn_fs_fs__with_write_lock(fs, upgrade_body, (void *)fs, pool);
+  return svn_fs_py__with_write_lock(fs, upgrade_body, (void *)fs, pool);
 }
 
 
@@ -1468,7 +1468,7 @@ get_youngest(svn_revnum_t *youngest_p,
 }
 
 svn_error_t *
-svn_fs_fs__hotcopy(const char *src_path,
+svn_fs_py__hotcopy(const char *src_path,
                    const char *dst_path,
                    apr_pool_t *pool)
 {
@@ -1701,7 +1701,7 @@ svn_fs_fs__hotcopy(const char *src_path,
 }
 
 svn_error_t *
-svn_fs_fs__youngest_rev(svn_revnum_t *youngest_p,
+svn_fs_py__youngest_rev(svn_revnum_t *youngest_p,
                         svn_fs_t *fs,
                         apr_pool_t *pool)
 {
@@ -1836,7 +1836,7 @@ open_pack_or_rev_file(apr_file_t **file,
 
   do
     {
-      err = svn_fs_fs__path_rev_absolute(&path, fs, rev, pool);
+      err = svn_fs_py__path_rev_absolute(&path, fs, rev, pool);
 
       /* open the revision file in buffered r/o mode */
       if (! err)
@@ -1895,7 +1895,7 @@ get_packed_offset(apr_off_t *rev_offset,
      in the cache */
   SVN_ERR(svn_cache__get_partial((void **) rev_offset, &is_cached,
                                  ffd->packed_offset_cache, &shard,
-                                 svn_fs_fs__get_sharded_offset, &shard_pos,
+                                 svn_fs_py__get_sharded_offset, &shard_pos,
                                  pool));
 
   if (is_cached)
@@ -2117,7 +2117,7 @@ read_rep_offsets(representation_t **rep_
   const char *txn_id;
 
   if (noderev_id)
-    txn_id = svn_fs_fs__id_txn_id(noderev_id);
+    txn_id = svn_fs_py__id_txn_id(noderev_id);
   else
     txn_id = NULL;
 
@@ -2125,7 +2125,7 @@ read_rep_offsets(representation_t **rep_
                               pool);
   if (err)
     {
-      const svn_string_t *id_unparsed = svn_fs_fs__id_unparse(noderev_id, pool);
+      const svn_string_t *id_unparsed = svn_fs_py__id_unparse(noderev_id, pool);
       const char *where;
       where = apr_psprintf(pool,
                            _("While reading representation offsets "
@@ -2141,7 +2141,7 @@ read_rep_offsets(representation_t **rep_
 static svn_error_t *
 err_dangling_id(svn_fs_t *fs, const svn_fs_id_t *id)
 {
-  svn_string_t *id_str = svn_fs_fs__id_unparse(id, fs->pool);
+  svn_string_t *id_str = svn_fs_py__id_unparse(id, fs->pool);
   return svn_error_createf
     (SVN_ERR_FS_ID_NOT_FOUND, 0,
      _("Reference to non-existent node '%s' in filesystem '%s'"),
@@ -2154,7 +2154,7 @@ err_dangling_id(svn_fs_t *fs, const svn_
 static const char *
 get_noderev_cache_key(const svn_fs_id_t *id, apr_pool_t *pool)
 {
-  const svn_string_t *id_unparsed = svn_fs_fs__id_unparse(id, pool);
+  const svn_string_t *id_unparsed = svn_fs_py__id_unparse(id, pool);
   return id_unparsed->data;
 }
 
@@ -2172,7 +2172,7 @@ get_cached_node_revision_body(node_revis
                               apr_pool_t *pool)
 {
   fs_fs_data_t *ffd = fs->fsap_data;
-  if (! ffd->node_revision_cache || svn_fs_fs__id_txn_id(id))
+  if (! ffd->node_revision_cache || svn_fs_py__id_txn_id(id))
     *is_cached = FALSE;
   else
     SVN_ERR(svn_cache__get((void **) noderev_p,
@@ -2197,7 +2197,7 @@ set_cached_node_revision_body(node_revis
 {
   fs_fs_data_t *ffd = fs->fsap_data;
 
-  if (ffd->node_revision_cache && !svn_fs_fs__id_txn_id(id))
+  if (ffd->node_revision_cache && !svn_fs_py__id_txn_id(id))
     return svn_cache__set(ffd->node_revision_cache,
                           get_noderev_cache_key(id, scratch_pool),
                           noderev_p,
@@ -2208,7 +2208,7 @@ set_cached_node_revision_body(node_revis
 
 /* Get the node-revision for the node ID in FS.
    Set *NODEREV_P to the new node-revision structure, allocated in POOL.
-   See svn_fs_fs__get_node_revision, which wraps this and adds another
+   See svn_fs_py__get_node_revision, which wraps this and adds another
    error. */
 static svn_error_t *
 get_node_revision_body(node_revision_t **noderev_p,
@@ -2225,7 +2225,7 @@ get_node_revision_body(node_revision_t *
   if (is_cached)
     return SVN_NO_ERROR;
 
-  if (svn_fs_fs__id_txn_id(id))
+  if (svn_fs_py__id_txn_id(id))
     {
       /* This is a transaction node-rev. */
       err = svn_io_file_open(&revision_file, path_txn_node_rev(fs, id, pool),
@@ -2235,8 +2235,8 @@ get_node_revision_body(node_revision_t *
     {
       /* This is a revision node-rev. */
       err = open_and_seek_revision(&revision_file, fs,
-                                   svn_fs_fs__id_rev(id),
-                                   svn_fs_fs__id_offset(id),
+                                   svn_fs_py__id_rev(id),
+                                   svn_fs_py__id_offset(id),
                                    pool);
     }
 
@@ -2251,7 +2251,7 @@ get_node_revision_body(node_revision_t *
       return svn_error_trace(err);
     }
 
-  SVN_ERR(svn_fs_fs__read_noderev(noderev_p,
+  SVN_ERR(svn_fs_py__read_noderev(noderev_p,
                                   svn_stream_from_aprfile2(revision_file, FALSE,
                                                            pool),
                                   pool));
@@ -2261,7 +2261,7 @@ get_node_revision_body(node_revision_t *
 }
 
 svn_error_t *
-svn_fs_fs__read_noderev(node_revision_t **noderev_p,
+svn_fs_py__read_noderev(node_revision_t **noderev_p,
                         svn_stream_t *stream,
                         apr_pool_t *pool)
 {
@@ -2283,7 +2283,7 @@ svn_fs_fs__read_noderev(node_revision_t 
 
   SVN_ERR(svn_stream_close(stream));
 
-  noderev->id = svn_fs_fs__id_parse(value, strlen(value), pool);
+  noderev->id = svn_fs_py__id_parse(value, strlen(value), pool);
   noderev_id = value; /* for error messages later */
 
   /* Read the type. */
@@ -2339,7 +2339,7 @@ svn_fs_fs__read_noderev(node_revision_t 
   /* Get the predecessor ID. */
   value = apr_hash_get(headers, HEADER_PRED, APR_HASH_KEY_STRING);
   if (value)
-    noderev->predecessor_id = svn_fs_fs__id_parse(value, strlen(value),
+    noderev->predecessor_id = svn_fs_py__id_parse(value, strlen(value),
                                                   pool);
 
   /* Get the copyroot. */
@@ -2347,7 +2347,7 @@ svn_fs_fs__read_noderev(node_revision_t 
   if (value == NULL)
     {
       noderev->copyroot_path = apr_pstrdup(pool, noderev->created_path);
-      noderev->copyroot_rev = svn_fs_fs__id_rev(noderev->id);
+      noderev->copyroot_rev = svn_fs_py__id_rev(noderev->id);
     }
   else
     {
@@ -2415,7 +2415,7 @@ svn_fs_fs__read_noderev(node_revision_t 
 }
 
 svn_error_t *
-svn_fs_fs__get_node_revision(node_revision_t **noderev_p,
+svn_fs_py__get_node_revision(node_revision_t **noderev_p,
                              svn_fs_t *fs,
                              const svn_fs_id_t *id,
                              apr_pool_t *pool)
@@ -2423,7 +2423,7 @@ svn_fs_fs__get_node_revision(node_revisi
   svn_error_t *err = get_node_revision_body(noderev_p, fs, id, pool);
   if (err && err->apr_err == SVN_ERR_FS_CORRUPT)
     {
-      svn_string_t *id_string = svn_fs_fs__id_unparse(id, pool);
+      svn_string_t *id_string = svn_fs_py__id_unparse(id, pool);
       return svn_error_createf(SVN_ERR_FS_CORRUPT, err,
                                "Corrupt node-revision '%s'",
                                id_string->data);
@@ -2467,14 +2467,14 @@ representation_string(representation_t *
 
 
 svn_error_t *
-svn_fs_fs__write_noderev(svn_stream_t *outfile,
+svn_fs_py__write_noderev(svn_stream_t *outfile,
                          node_revision_t *noderev,
                          int format,
                          svn_boolean_t include_mergeinfo,
                          apr_pool_t *pool)
 {
   SVN_ERR(svn_stream_printf(outfile, pool, HEADER_ID ": %s\n",
-                            svn_fs_fs__id_unparse(noderev->id,
+                            svn_fs_py__id_unparse(noderev->id,
                                                   pool)->data));
 
   SVN_ERR(svn_stream_printf(outfile, pool, HEADER_TYPE ": %s\n",
@@ -2483,7 +2483,7 @@ svn_fs_fs__write_noderev(svn_stream_t *o
 
   if (noderev->predecessor_id)
     SVN_ERR(svn_stream_printf(outfile, pool, HEADER_PRED ": %s\n",
-                              svn_fs_fs__id_unparse(noderev->predecessor_id,
+                              svn_fs_py__id_unparse(noderev->predecessor_id,
                                                     pool)->data));
 
   SVN_ERR(svn_stream_printf(outfile, pool, HEADER_COUNT ": %d\n",
@@ -2511,7 +2511,7 @@ svn_fs_fs__write_noderev(svn_stream_t *o
                               noderev->copyfrom_rev,
                               noderev->copyfrom_path));
 
-  if ((noderev->copyroot_rev != svn_fs_fs__id_rev(noderev->id)) ||
+  if ((noderev->copyroot_rev != svn_fs_py__id_rev(noderev->id)) ||
       (strcmp(noderev->copyroot_path, noderev->created_path) != 0))
     SVN_ERR(svn_stream_printf(outfile, pool, HEADER_COPYROOT ": %ld"
                               " %s\n",
@@ -2536,7 +2536,7 @@ svn_fs_fs__write_noderev(svn_stream_t *o
 }
 
 svn_error_t *
-svn_fs_fs__put_node_revision(svn_fs_t *fs,
+svn_fs_py__put_node_revision(svn_fs_t *fs,
                              const svn_fs_id_t *id,
                              node_revision_t *noderev,
                              svn_boolean_t fresh_txn_root,
@@ -2544,23 +2544,23 @@ svn_fs_fs__put_node_revision(svn_fs_t *f
 {
   fs_fs_data_t *ffd = fs->fsap_data;
   apr_file_t *noderev_file;
-  const char *txn_id = svn_fs_fs__id_txn_id(id);
+  const char *txn_id = svn_fs_py__id_txn_id(id);
 
   noderev->is_fresh_txn_root = fresh_txn_root;
 
   if (! txn_id)
     return svn_error_createf(SVN_ERR_FS_CORRUPT, NULL,
                              _("Attempted to write to non-transaction '%s'"),
-                             svn_fs_fs__id_unparse(id, pool)->data);
+                             svn_fs_py__id_unparse(id, pool)->data);
 
   SVN_ERR(svn_io_file_open(&noderev_file, path_txn_node_rev(fs, id, pool),
                            APR_WRITE | APR_CREATE | APR_TRUNCATE
                            | APR_BUFFERED, APR_OS_DEFAULT, pool));
 
-  SVN_ERR(svn_fs_fs__write_noderev(svn_stream_from_aprfile2(noderev_file, TRUE,
+  SVN_ERR(svn_fs_py__write_noderev(svn_stream_from_aprfile2(noderev_file, TRUE,
                                                             pool),
                                    noderev, ffd->format,
-                                   svn_fs_fs__fs_supports_mergeinfo(fs),
+                                   svn_fs_py__fs_supports_mergeinfo(fs),
                                    pool));
 
   return svn_io_file_close(noderev_file, pool);
@@ -2681,7 +2681,7 @@ get_fs_id_at_offset(svn_fs_id_t **id_p,
                              rev,
                              apr_psprintf(pool, "%" APR_OFF_T_FMT, offset));
 
-  id = svn_fs_fs__id_parse(node_id_str, strlen(node_id_str), pool);
+  id = svn_fs_py__id_parse(node_id_str, strlen(node_id_str), pool);
 
   if (id == NULL)
     return svn_error_createf(SVN_ERR_FS_CORRUPT, NULL,
@@ -2901,7 +2901,7 @@ move_into_place(const char *old_filename
 }
 
 svn_error_t *
-svn_fs_fs__rev_get_root(svn_fs_id_t **root_id_p,
+svn_fs_py__rev_get_root(svn_fs_id_t **root_id_p,
                         svn_fs_t *fs,
                         svn_revnum_t rev,
                         apr_pool_t *pool)
@@ -2964,7 +2964,7 @@ set_revision_proplist(svn_fs_t *fs,
          because when setting revprops for the first time, the revprop
          file won't exist and therefore can't serve as its own reference.
          (Whereas the rev file should already exist at this point.) */
-      SVN_ERR(svn_fs_fs__path_rev_absolute(&perms_reference, fs, rev, pool));
+      SVN_ERR(svn_fs_py__path_rev_absolute(&perms_reference, fs, rev, pool));
       SVN_ERR(move_into_place(tmp_path, final_path, perms_reference, pool));
 
       return SVN_NO_ERROR;
@@ -3043,7 +3043,7 @@ revision_proplist(apr_hash_t **proplist_
 }
 
 svn_error_t *
-svn_fs_fs__revision_proplist(apr_hash_t **proplist_p,
+svn_fs_py__revision_proplist(apr_hash_t **proplist_p,
                              svn_fs_t *fs,
                              svn_revnum_t rev,
                              apr_pool_t *pool)
@@ -3321,7 +3321,7 @@ get_window_key(struct rep_state *rs, apr
    * non-packed ones: keys for packed rev file content ends with a dot
    * for non-packed rev files they end with a digit. */
   name = apr_pstrndup(pool, last_part + 1, name_last - last_part);
-  return svn_fs_fs__combine_number_and_string(offset, name, pool);
+  return svn_fs_py__combine_number_and_string(offset, name, pool);
 }
 
 /* Read the WINDOW_P for the rep state RS from the current FSFS session's
@@ -3347,7 +3347,7 @@ get_cached_window(svn_txdelta_window_t *
   else
     {
       /* ask the cache for the desired txdelta window */
-      svn_fs_fs__txdelta_cached_window_t *cached_window;
+      svn_fs_py__txdelta_cached_window_t *cached_window;
       SVN_ERR(svn_cache__get((void **) &cached_window,
                              is_cached,
                              rs->window_cache,
@@ -3383,7 +3383,7 @@ set_cached_window(svn_txdelta_window_t *
   if (rs->window_cache)
     {
       /* store the window and the first offset _past_ it */
-      svn_fs_fs__txdelta_cached_window_t cached_window = { window, rs->off };
+      svn_fs_py__txdelta_cached_window_t cached_window = { window, rs->off };
 
       /* but key it with the start offset because that is the known state
        * when we will look it up */
@@ -3758,7 +3758,7 @@ read_representation(svn_stream_t **conte
 }
 
 svn_error_t *
-svn_fs_fs__get_contents(svn_stream_t **contents_p,
+svn_fs_py__get_contents(svn_stream_t **contents_p,
                         svn_fs_t *fs,
                         node_revision_t *noderev,
                         apr_pool_t *pool)
@@ -3802,7 +3802,7 @@ delta_read_md5_digest(void *baton)
 }
 
 svn_error_t *
-svn_fs_fs__get_file_delta_stream(svn_txdelta_stream_t **stream_p,
+svn_fs_py__get_file_delta_stream(svn_txdelta_stream_t **stream_p,
                                  svn_fs_t *fs,
                                  node_revision_t *source,
                                  node_revision_t *target,
@@ -3892,7 +3892,7 @@ unparse_dir_entry(svn_node_kind_t kind, 
 {
   return apr_psprintf(pool, "%s %s",
                       (kind == svn_node_file) ? KIND_FILE : KIND_DIR,
-                      svn_fs_fs__id_unparse(id, pool)->data);
+                      svn_fs_py__id_unparse(id, pool)->data);
 }
 
 /* Given a hash ENTRIES of dirent structions, return a hash in
@@ -3976,7 +3976,7 @@ parse_dir_entries(apr_hash_t **entries_p
                                    _("Directory entry corrupt in '%s'"),
                                    unparsed_id);
 
-      dirent->id = svn_fs_fs__id_parse(str, strlen(str), pool);
+      dirent->id = svn_fs_py__id_parse(str, strlen(str), pool);
 
       apr_hash_set(*entries_p, dirent->name, APR_HASH_KEY_STRING, dirent);
     }
@@ -3991,13 +3991,13 @@ locate_dir_cache(svn_fs_t *fs,
                  node_revision_t *noderev)
 {
   fs_fs_data_t *ffd = fs->fsap_data;
-  return svn_fs_fs__id_txn_id(noderev->id)
+  return svn_fs_py__id_txn_id(noderev->id)
       ? ffd->txn_dir_cache
       : ffd->dir_cache;
 }
 
 svn_error_t *
-svn_fs_fs__rep_contents_dir(apr_hash_t **entries_p,
+svn_fs_py__rep_contents_dir(apr_hash_t **entries_p,
                             svn_fs_t *fs,
                             node_revision_t *noderev,
                             apr_pool_t *pool)
@@ -4011,7 +4011,7 @@ svn_fs_fs__rep_contents_dir(apr_hash_t *
     {
       svn_boolean_t found;
 
-      unparsed_id = svn_fs_fs__id_unparse(noderev->id, pool)->data;
+      unparsed_id = svn_fs_py__id_unparse(noderev->id, pool)->data;
       SVN_ERR(svn_cache__get((void **) entries_p, &found, cache,
                              unparsed_id, pool));
       if (found)
@@ -4033,7 +4033,7 @@ svn_fs_fs__rep_contents_dir(apr_hash_t *
 }
 
 svn_error_t *
-svn_fs_fs__rep_contents_dir_entry(svn_fs_dirent_t **dirent,
+svn_fs_py__rep_contents_dir_entry(svn_fs_dirent_t **dirent,
                                   svn_fs_t *fs,
                                   node_revision_t *noderev,
                                   const char *name,
@@ -4046,14 +4046,14 @@ svn_fs_fs__rep_contents_dir_entry(svn_fs
   if (cache)
     {
       const char *unparsed_id =
-        svn_fs_fs__id_unparse(noderev->id, pool)->data;
+        svn_fs_py__id_unparse(noderev->id, pool)->data;
 
       /* Cache lookup. */
       SVN_ERR(svn_cache__get_partial((void **)dirent,
                                      &found,
                                      cache,
                                      unparsed_id,
-                                     svn_fs_fs__extract_dir_entry,
+                                     svn_fs_py__extract_dir_entry,
                                      (void*)name,
                                      pool));
     }
@@ -4074,7 +4074,7 @@ svn_fs_fs__rep_contents_dir_entry(svn_fs
 
       /* read the dir from the file system. It will probably be put it
          into the cache for faster lookup in future calls. */
-      SVN_ERR(svn_fs_fs__rep_contents_dir(&entries, fs, noderev, sub_pool));
+      SVN_ERR(svn_fs_py__rep_contents_dir(&entries, fs, noderev, sub_pool));
 
       /* find desired entry and return a copy in POOL, if found */
       entry = apr_hash_get(entries, name, APR_HASH_KEY_STRING);
@@ -4082,7 +4082,7 @@ svn_fs_fs__rep_contents_dir_entry(svn_fs
         {
           entry_copy = apr_palloc(pool, sizeof(*entry_copy));
           entry_copy->name = apr_pstrdup(pool, entry->name);
-          entry_copy->id = svn_fs_fs__id_copy(entry->id, pool);
+          entry_copy->id = svn_fs_py__id_copy(entry->id, pool);
           entry_copy->kind = entry->kind;
         }
 
@@ -4094,7 +4094,7 @@ svn_fs_fs__rep_contents_dir_entry(svn_fs
 }
 
 svn_error_t *
-svn_fs_fs__get_proplist(apr_hash_t **proplist_p,
+svn_fs_py__get_proplist(apr_hash_t **proplist_p,
                         svn_fs_t *fs,
                         node_revision_t *noderev,
                         apr_pool_t *pool)
@@ -4125,7 +4125,7 @@ svn_fs_fs__get_proplist(apr_hash_t **pro
 }
 
 svn_error_t *
-svn_fs_fs__file_length(svn_filesize_t *length,
+svn_fs_py__file_length(svn_filesize_t *length,
                        node_revision_t *noderev,
                        apr_pool_t *pool)
 {
@@ -4138,7 +4138,7 @@ svn_fs_fs__file_length(svn_filesize_t *l
 }
 
 svn_boolean_t
-svn_fs_fs__noderev_same_rep_key(representation_t *a,
+svn_fs_py__noderev_same_rep_key(representation_t *a,
                                 representation_t *b)
 {
   if (a == b)
@@ -4163,7 +4163,7 @@ svn_fs_fs__noderev_same_rep_key(represen
 }
 
 svn_error_t *
-svn_fs_fs__file_checksum(svn_checksum_t **checksum,
+svn_fs_py__file_checksum(svn_checksum_t **checksum,
                          node_revision_t *noderev,
                          svn_checksum_kind_t kind,
                          apr_pool_t *pool)
@@ -4191,7 +4191,7 @@ svn_fs_fs__file_checksum(svn_checksum_t 
 }
 
 representation_t *
-svn_fs_fs__rep_copy(representation_t *rep,
+svn_fs_py__rep_copy(representation_t *rep,
                     apr_pool_t *pool)
 {
   representation_t *rep_new;
@@ -4238,7 +4238,7 @@ fold_change(apr_hash_t *changes,
          revision ID as our last change except where the last change
          was a deletion. */
       if (change->noderev_id
-          && (! svn_fs_fs__id_eq(old_change->node_rev_id, change->noderev_id))
+          && (! svn_fs_py__id_eq(old_change->node_rev_id, change->noderev_id))
           && (old_change->change_kind != svn_fs_path_change_delete))
         return svn_error_create
           (SVN_ERR_FS_CORRUPT, NULL,
@@ -4297,7 +4297,7 @@ fold_change(apr_hash_t *changes,
           /* An add at this point must be following a previous delete,
              so treat it just like a replace. */
           old_change->change_kind = svn_fs_path_change_replace;
-          old_change->node_rev_id = svn_fs_fs__id_copy(change->noderev_id,
+          old_change->node_rev_id = svn_fs_py__id_copy(change->noderev_id,
                                                        pool);
           old_change->text_mod = change->text_mod;
           old_change->prop_mod = change->prop_mod;
@@ -4332,7 +4332,7 @@ fold_change(apr_hash_t *changes,
          structure from the internal one (in the hash's pool), and dup
          the path into the hash's pool, too. */
       new_change = apr_pcalloc(pool, sizeof(*new_change));
-      new_change->node_rev_id = svn_fs_fs__id_copy(change->noderev_id, pool);
+      new_change->node_rev_id = svn_fs_py__id_copy(change->noderev_id, pool);
       new_change->change_kind = change->kind;
       new_change->text_mod = change->text_mod;
       new_change->prop_mod = change->prop_mod;
@@ -4433,7 +4433,7 @@ read_change(change_t **change_p,
     return svn_error_create(SVN_ERR_FS_CORRUPT, NULL,
                             _("Invalid changes line in rev-file"));
 
-  change->noderev_id = svn_fs_fs__id_parse(str, strlen(str), pool);
+  change->noderev_id = svn_fs_py__id_parse(str, strlen(str), pool);
   if (change->noderev_id == NULL)
     return svn_error_create(SVN_ERR_FS_CORRUPT, NULL,
                             _("Invalid changes line in rev-file"));
@@ -4633,7 +4633,7 @@ fetch_all_changes(apr_hash_t *changed_pa
 }
 
 svn_error_t *
-svn_fs_fs__txn_changes_fetch(apr_hash_t **changed_paths_p,
+svn_fs_py__txn_changes_fetch(apr_hash_t **changed_paths_p,
                              svn_fs_t *fs,
                              const char *txn_id,
                              apr_pool_t *pool)
@@ -4654,7 +4654,7 @@ svn_fs_fs__txn_changes_fetch(apr_hash_t 
 }
 
 svn_error_t *
-svn_fs_fs__paths_changed(apr_hash_t **changed_paths_p,
+svn_fs_py__paths_changed(apr_hash_t **changed_paths_p,
                          svn_fs_t *fs,
                          svn_revnum_t rev,
                          apr_hash_t *copyfrom_cache,
@@ -4698,9 +4698,9 @@ create_new_txn_noderev_from_rev(svn_fs_t
   node_revision_t *noderev;
   const char *node_id, *copy_id;
 
-  SVN_ERR(svn_fs_fs__get_node_revision(&noderev, fs, src, pool));
+  SVN_ERR(svn_fs_py__get_node_revision(&noderev, fs, src, pool));
 
-  if (svn_fs_fs__id_txn_id(noderev->id))
+  if (svn_fs_py__id_txn_id(noderev->id))
     return svn_error_create(SVN_ERR_FS_CORRUPT, NULL,
                             _("Copying from transactions not allowed"));
 
@@ -4711,11 +4711,11 @@ create_new_txn_noderev_from_rev(svn_fs_t
 
   /* For the transaction root, the copyroot never changes. */
 
-  node_id = svn_fs_fs__id_node_id(noderev->id);
-  copy_id = svn_fs_fs__id_copy_id(noderev->id);
-  noderev->id = svn_fs_fs__id_txn_create(node_id, copy_id, txn_id, pool);
+  node_id = svn_fs_py__id_node_id(noderev->id);
+  copy_id = svn_fs_py__id_copy_id(noderev->id);
+  noderev->id = svn_fs_py__id_txn_create(node_id, copy_id, txn_id, pool);
 
-  return svn_fs_fs__put_node_revision(fs, noderev->id, noderev, TRUE, pool);
+  return svn_fs_py__put_node_revision(fs, noderev->id, noderev, TRUE, pool);
 }
 
 /* A structure used by get_and_increment_txn_key_body(). */
@@ -4770,7 +4770,7 @@ get_and_increment_txn_key_body(void *bat
 
   /* Increment the key and add a trailing \n to the string so the
      txn-current file has a newline in it. */
-  svn_fs_fs__next_key(cb->txn_id, &len, next_txn_id);
+  svn_fs_py__next_key(cb->txn_id, &len, next_txn_id);
   next_txn_id[len] = '\n';
   ++len;
   next_txn_id[len] = '\0';
@@ -4865,7 +4865,7 @@ create_txn_dir_pre_1_5(const char **id_p
 }
 
 svn_error_t *
-svn_fs_fs__create_txn(svn_fs_txn_t **txn_p,
+svn_fs_py__create_txn(svn_fs_txn_t **txn_p,
                       svn_fs_t *fs,
                       svn_revnum_t rev,
                       apr_pool_t *pool)
@@ -4889,7 +4889,7 @@ svn_fs_fs__create_txn(svn_fs_txn_t **txn
   *txn_p = txn;
 
   /* Create a new root node for this transaction. */
-  SVN_ERR(svn_fs_fs__rev_get_root(&root_id, fs, rev, pool));
+  SVN_ERR(svn_fs_py__rev_get_root(&root_id, fs, rev, pool));
   SVN_ERR(create_new_txn_noderev_from_rev(fs, txn->id, root_id, pool));
 
   /* Create an empty rev file. */
@@ -4937,7 +4937,7 @@ get_txn_proplist(apr_hash_t *proplist,
 }
 
 svn_error_t *
-svn_fs_fs__change_txn_prop(svn_fs_txn_t *txn,
+svn_fs_py__change_txn_prop(svn_fs_txn_t *txn,
                            const char *name,
                            const svn_string_t *value,
                            apr_pool_t *pool)
@@ -4949,11 +4949,11 @@ svn_fs_fs__change_txn_prop(svn_fs_txn_t 
   prop.value = value;
   APR_ARRAY_PUSH(props, svn_prop_t) = prop;
 
-  return svn_fs_fs__change_txn_props(txn, props, pool);
+  return svn_fs_py__change_txn_props(txn, props, pool);
 }
 
 svn_error_t *
-svn_fs_fs__change_txn_props(svn_fs_txn_t *txn,
+svn_fs_py__change_txn_props(svn_fs_txn_t *txn,
                             const apr_array_header_t *props,
                             apr_pool_t *pool)
 {
@@ -4999,7 +4999,7 @@ svn_fs_fs__change_txn_props(svn_fs_txn_t
 }
 
 svn_error_t *
-svn_fs_fs__get_txn(transaction_t **txn_p,
+svn_fs_py__get_txn(transaction_t **txn_p,
                    svn_fs_t *fs,
                    const char *txn_id,
                    apr_pool_t *pool)
@@ -5012,12 +5012,12 @@ svn_fs_fs__get_txn(transaction_t **txn_p
   txn->proplist = apr_hash_make(pool);
 
   SVN_ERR(get_txn_proplist(txn->proplist, fs, txn_id, pool));
-  root_id = svn_fs_fs__id_txn_create("0", "0", txn_id, pool);
+  root_id = svn_fs_py__id_txn_create("0", "0", txn_id, pool);
 
-  SVN_ERR(svn_fs_fs__get_node_revision(&noderev, fs, root_id, pool));
+  SVN_ERR(svn_fs_py__get_node_revision(&noderev, fs, root_id, pool));
 
-  txn->root_id = svn_fs_fs__id_copy(noderev->id, pool);
-  txn->base_id = svn_fs_fs__id_copy(noderev->predecessor_id, pool);
+  txn->root_id = svn_fs_py__id_copy(noderev->id, pool);
+  txn->base_id = svn_fs_py__id_copy(noderev->predecessor_id, pool);
   txn->copies = NULL;
 
   *txn_p = txn;
@@ -5116,7 +5116,7 @@ get_new_txn_node_id(const char **node_id
   node_id = apr_pcalloc(pool, strlen(cur_node_id) + 2);
 
   len = strlen(cur_node_id);
-  svn_fs_fs__next_key(cur_node_id, &len, node_id);
+  svn_fs_py__next_key(cur_node_id, &len, node_id);
 
   SVN_ERR(write_next_ids(fs, txn_id, node_id, cur_copy_id, pool));
 
@@ -5126,7 +5126,7 @@ get_new_txn_node_id(const char **node_id
 }
 
 svn_error_t *
-svn_fs_fs__create_node(const svn_fs_id_t **id_p,
+svn_fs_py__create_node(const svn_fs_id_t **id_p,
                        svn_fs_t *fs,
                        node_revision_t *noderev,
                        const char *copy_id,
@@ -5139,11 +5139,11 @@ svn_fs_fs__create_node(const svn_fs_id_t
   /* Get a new node-id for this node. */
   SVN_ERR(get_new_txn_node_id(&node_id, fs, txn_id, pool));
 
-  id = svn_fs_fs__id_txn_create(node_id, copy_id, txn_id, pool);
+  id = svn_fs_py__id_txn_create(node_id, copy_id, txn_id, pool);
 
   noderev->id = id;
 
-  SVN_ERR(svn_fs_fs__put_node_revision(fs, noderev->id, noderev, FALSE, pool));
+  SVN_ERR(svn_fs_py__put_node_revision(fs, noderev->id, noderev, FALSE, pool));
 
   *id_p = id;
 
@@ -5151,7 +5151,7 @@ svn_fs_fs__create_node(const svn_fs_id_t
 }
 
 svn_error_t *
-svn_fs_fs__purge_txn(svn_fs_t *fs,
+svn_fs_py__purge_txn(svn_fs_t *fs,
                      const char *txn_id,
                      apr_pool_t *pool)
 {
@@ -5178,13 +5178,13 @@ svn_fs_fs__purge_txn(svn_fs_t *fs,
 
 
 svn_error_t *
-svn_fs_fs__abort_txn(svn_fs_txn_t *txn,
+svn_fs_py__abort_txn(svn_fs_txn_t *txn,
                      apr_pool_t *pool)
 {
   SVN_ERR(svn_fs__check_fs(txn->fs, TRUE));
 
   /* Now, purge the transaction. */
-  SVN_ERR_W(svn_fs_fs__purge_txn(txn->fs, txn->id, pool),
+  SVN_ERR_W(svn_fs_py__purge_txn(txn->fs, txn->id, pool),
             apr_psprintf(pool, _("Transaction '%s' cleanup failed"),
                          txn->id));
 
@@ -5193,7 +5193,7 @@ svn_fs_fs__abort_txn(svn_fs_txn_t *txn,
 
 
 svn_error_t *
-svn_fs_fs__set_entry(svn_fs_t *fs,
+svn_fs_py__set_entry(svn_fs_t *fs,
                      const char *txn_id,
                      node_revision_t *parent_noderev,
                      const char *name,
@@ -5217,7 +5217,7 @@ svn_fs_fs__set_entry(svn_fs_t *fs,
 
         /* Before we can modify the directory, we need to dump its old
            contents into a mutable representation file. */
-        SVN_ERR(svn_fs_fs__rep_contents_dir(&entries, fs, parent_noderev,
+        SVN_ERR(svn_fs_py__rep_contents_dir(&entries, fs, parent_noderev,
                                             subpool));
         SVN_ERR(unparse_dir_entries(&entries, entries, subpool));
         SVN_ERR(svn_io_file_open(&file, filename,
@@ -5236,7 +5236,7 @@ svn_fs_fs__set_entry(svn_fs_t *fs,
       SVN_ERR(get_new_txn_node_id(&unique_suffix, fs, txn_id, pool));
       rep->uniquifier = apr_psprintf(pool, "%s/%s", txn_id, unique_suffix);
       parent_noderev->data_rep = rep;
-      SVN_ERR(svn_fs_fs__put_node_revision(fs, parent_noderev->id,
+      SVN_ERR(svn_fs_py__put_node_revision(fs, parent_noderev->id,
                                            parent_noderev, FALSE, pool));
     }
   else
@@ -5254,7 +5254,7 @@ svn_fs_fs__set_entry(svn_fs_t *fs,
 
       /* build parameters: (name, new entry) pair */
       const char *key =
-          svn_fs_fs__id_unparse(parent_noderev->id, subpool)->data;
+          svn_fs_py__id_unparse(parent_noderev->id, subpool)->data;
       replace_baton_t baton = {name, NULL};
 
       if (id)
@@ -5266,7 +5266,7 @@ svn_fs_fs__set_entry(svn_fs_t *fs,
         }
 
       /* actually update the cached directory (if cached) */
-      SVN_ERR(svn_cache__set_partial(ffd->txn_dir_cache, key, svn_fs_fs__replace_dir_entry, &baton, subpool));
+      SVN_ERR(svn_cache__set_partial(ffd->txn_dir_cache, key, svn_fs_py__replace_dir_entry, &baton, subpool));
 
       svn_pool_destroy(subpool);
     }
@@ -5329,7 +5329,7 @@ write_change_entry(apr_file_t *file,
     }
 
   if (change->node_rev_id)
-    idstr = svn_fs_fs__id_unparse(change->node_rev_id, pool)->data;
+    idstr = svn_fs_py__id_unparse(change->node_rev_id, pool)->data;
   else
     idstr = ACTION_RESET;
 
@@ -5360,7 +5360,7 @@ write_change_entry(apr_file_t *file,
 }
 
 svn_error_t *
-svn_fs_fs__add_change(svn_fs_t *fs,
+svn_fs_py__add_change(svn_fs_t *fs,
                       const char *txn_id,
                       const char *path,
                       const svn_fs_id_t *id,
@@ -5486,7 +5486,7 @@ choose_delta_base(representation_t **rep
      walk back two predecessors.) */
   base = noderev;
   while ((count++) < noderev->predecessor_count)
-    SVN_ERR(svn_fs_fs__get_node_revision(&base, fs,
+    SVN_ERR(svn_fs_py__get_node_revision(&base, fs,
                                          base->predecessor_id, pool));
 
   *rep = base->data_rep;
@@ -5527,7 +5527,7 @@ rep_write_get_baton(struct rep_write_bat
 
   /* Open the prototype rev file and seek to its end. */
   SVN_ERR(get_writable_proto_rev(&file, &b->lockcookie,
-                                 fs, svn_fs_fs__id_txn_id(noderev->id),
+                                 fs, svn_fs_py__id_txn_id(noderev->id),
                                  b->pool));
 
   b->file = file;
@@ -5599,7 +5599,7 @@ rep_write_contents_close(void *baton)
 
   /* Fill in the rest of the representation field. */
   rep->expanded_size = b->rep_size;
-  rep->txn_id = svn_fs_fs__id_txn_id(b->noderev->id);
+  rep->txn_id = svn_fs_py__id_txn_id(b->noderev->id);
   SVN_ERR(get_new_txn_node_id(&unique_suffix, b->fs, rep->txn_id, b->pool));
   rep->uniquifier = apr_psprintf(b->parent_pool, "%s/%s", rep->txn_id,
                                  unique_suffix);
@@ -5616,7 +5616,7 @@ rep_write_contents_close(void *baton)
   if (ffd->rep_sharing_allowed)
     {
       svn_error_t *err;
-      err = svn_fs_fs__get_rep_reference(&old_rep, b->fs, rep->sha1_checksum,
+      err = svn_fs_py__get_rep_reference(&old_rep, b->fs, rep->sha1_checksum,
                                          b->parent_pool);
       /* ### Other error codes that we shouldn't mask out? */
       if (err == SVN_NO_ERROR
@@ -5665,7 +5665,7 @@ rep_write_contents_close(void *baton)
     }
 
   /* Write out the new node-rev information. */
-  SVN_ERR(svn_fs_fs__put_node_revision(b->fs, b->noderev->id, b->noderev, FALSE,
+  SVN_ERR(svn_fs_py__put_node_revision(b->fs, b->noderev->id, b->noderev, FALSE,
                                        b->pool));
 
   SVN_ERR(svn_io_file_close(b->file, b->pool));
@@ -5688,10 +5688,10 @@ set_representation(svn_stream_t **conten
 {
   struct rep_write_baton *wb;
 
-  if (! svn_fs_fs__id_txn_id(noderev->id))
+  if (! svn_fs_py__id_txn_id(noderev->id))
     return svn_error_createf(SVN_ERR_FS_CORRUPT, NULL,
                              _("Attempted to write to non-transaction '%s'"),
-                             svn_fs_fs__id_unparse(noderev->id, pool)->data);
+                             svn_fs_py__id_unparse(noderev->id, pool)->data);
 
   SVN_ERR(rep_write_get_baton(&wb, fs, noderev, pool));
 
@@ -5703,7 +5703,7 @@ set_representation(svn_stream_t **conten
 }
 
 svn_error_t *
-svn_fs_fs__set_contents(svn_stream_t **stream,
+svn_fs_py__set_contents(svn_stream_t **stream,
                         svn_fs_t *fs,
                         node_revision_t *noderev,
                         apr_pool_t *pool)
@@ -5716,7 +5716,7 @@ svn_fs_fs__set_contents(svn_stream_t **s
 }
 
 svn_error_t *
-svn_fs_fs__create_successor(const svn_fs_id_t **new_id_p,
+svn_fs_py__create_successor(const svn_fs_id_t **new_id_p,
                             svn_fs_t *fs,
                             const svn_fs_id_t *old_idp,
                             node_revision_t *new_noderev,
@@ -5727,8 +5727,8 @@ svn_fs_fs__create_successor(const svn_fs
   const svn_fs_id_t *id;
 
   if (! copy_id)
-    copy_id = svn_fs_fs__id_copy_id(old_idp);
-  id = svn_fs_fs__id_txn_create(svn_fs_fs__id_node_id(old_idp), copy_id,
+    copy_id = svn_fs_py__id_copy_id(old_idp);
+  id = svn_fs_py__id_txn_create(svn_fs_py__id_node_id(old_idp), copy_id,
                                 txn_id, pool);
 
   new_noderev->id = id;
@@ -5737,10 +5737,10 @@ svn_fs_fs__create_successor(const svn_fs
     {
       new_noderev->copyroot_path = apr_pstrdup(pool,
                                                new_noderev->created_path);
-      new_noderev->copyroot_rev = svn_fs_fs__id_rev(new_noderev->id);
+      new_noderev->copyroot_rev = svn_fs_py__id_rev(new_noderev->id);
     }
 
-  SVN_ERR(svn_fs_fs__put_node_revision(fs, new_noderev->id, new_noderev, FALSE,
+  SVN_ERR(svn_fs_py__put_node_revision(fs, new_noderev->id, new_noderev, FALSE,
                                        pool));
 
   *new_id_p = id;
@@ -5749,7 +5749,7 @@ svn_fs_fs__create_successor(const svn_fs
 }
 
 svn_error_t *
-svn_fs_fs__set_proplist(svn_fs_t *fs,
+svn_fs_py__set_proplist(svn_fs_t *fs,
                         node_revision_t *noderev,
                         apr_hash_t *proplist,
                         apr_pool_t *pool)
@@ -5770,8 +5770,8 @@ svn_fs_fs__set_proplist(svn_fs_t *fs,
   if (!noderev->prop_rep || !noderev->prop_rep->txn_id)
     {
       noderev->prop_rep = apr_pcalloc(pool, sizeof(*noderev->prop_rep));
-      noderev->prop_rep->txn_id = svn_fs_fs__id_txn_id(noderev->id);
-      SVN_ERR(svn_fs_fs__put_node_revision(fs, noderev->id, noderev, FALSE, pool));
+      noderev->prop_rep->txn_id = svn_fs_py__id_txn_id(noderev->id);
+      SVN_ERR(svn_fs_py__put_node_revision(fs, noderev->id, noderev, FALSE, pool));
     }
 
   return SVN_NO_ERROR;
@@ -5789,7 +5789,7 @@ get_next_revision_ids(const char **node_
   char *buf;
   char *str, *last_str;
 
-  SVN_ERR(read_current(svn_fs_fs__path_current(fs, pool), &buf, pool));
+  SVN_ERR(read_current(svn_fs_py__path_current(fs, pool), &buf, pool));
 
   str = apr_strtok(buf, " ", &last_str);
   if (! str)
@@ -5916,10 +5916,10 @@ write_final_rev(const svn_fs_id_t **new_
   *new_id_p = NULL;
 
   /* Check to see if this is a transaction node. */
-  if (! svn_fs_fs__id_txn_id(id))
+  if (! svn_fs_py__id_txn_id(id))
     return SVN_NO_ERROR;
 
-  SVN_ERR(svn_fs_fs__get_node_revision(&noderev, fs, id, pool));
+  SVN_ERR(svn_fs_py__get_node_revision(&noderev, fs, id, pool));
 
   if (noderev->kind == svn_node_dir)
     {
@@ -5930,7 +5930,7 @@ write_final_rev(const svn_fs_id_t **new_
       /* This is a directory.  Write out all the children first. */
       subpool = svn_pool_create(pool);
 
-      SVN_ERR(svn_fs_fs__rep_contents_dir(&entries, fs, noderev, pool));
+      SVN_ERR(svn_fs_py__rep_contents_dir(&entries, fs, noderev, pool));
 
       for (hi = apr_hash_first(pool, entries); hi; hi = apr_hash_next(hi))
         {
@@ -5941,8 +5941,8 @@ write_final_rev(const svn_fs_id_t **new_
                                   start_node_id, start_copy_id, initial_offset,
                                   reps_to_cache, reps_pool,
                                   subpool));
-          if (new_id && (svn_fs_fs__id_rev(new_id) == rev))
-            dirent->id = svn_fs_fs__id_copy(new_id, pool);
+          if (new_id && (svn_fs_py__id_rev(new_id) == rev))
+            dirent->id = svn_fs_py__id_copy(new_id, pool);
         }
       svn_pool_destroy(subpool);
 
@@ -5986,7 +5986,7 @@ write_final_rev(const svn_fs_id_t **new_
     {
       apr_hash_t *proplist;
 
-      SVN_ERR(svn_fs_fs__get_proplist(&proplist, fs, noderev, pool));
+      SVN_ERR(svn_fs_py__get_proplist(&proplist, fs, noderev, pool));
       SVN_ERR(get_file_offset(&noderev->prop_rep->offset, file, pool));
       SVN_ERR(write_hash_rep(&noderev->prop_rep->size,
                              &noderev->prop_rep->md5_checksum, file,
@@ -6000,28 +6000,28 @@ write_final_rev(const svn_fs_id_t **new_
   /* Convert our temporary ID into a permanent revision one. */
   SVN_ERR(get_file_offset(&my_offset, file, pool));
 
-  node_id = svn_fs_fs__id_node_id(noderev->id);
+  node_id = svn_fs_py__id_node_id(noderev->id);
   if (*node_id == '_')
     {
       if (ffd->format >= SVN_FS_FS__MIN_NO_GLOBAL_IDS_FORMAT)
         my_node_id = apr_psprintf(pool, "%s-%ld", node_id + 1, rev);
       else
         {
-          svn_fs_fs__add_keys(start_node_id, node_id + 1, my_node_id_buf);
+          svn_fs_py__add_keys(start_node_id, node_id + 1, my_node_id_buf);
           my_node_id = my_node_id_buf;
         }
     }
   else
     my_node_id = node_id;
 
-  copy_id = svn_fs_fs__id_copy_id(noderev->id);
+  copy_id = svn_fs_py__id_copy_id(noderev->id);
   if (*copy_id == '_')
     {
       if (ffd->format >= SVN_FS_FS__MIN_NO_GLOBAL_IDS_FORMAT)
         my_copy_id = apr_psprintf(pool, "%s-%ld", copy_id + 1, rev);
       else
         {
-          svn_fs_fs__add_keys(start_copy_id, copy_id + 1, my_copy_id_buf);
+          svn_fs_py__add_keys(start_copy_id, copy_id + 1, my_copy_id_buf);
           my_copy_id = my_copy_id_buf;
         }
     }
@@ -6031,15 +6031,15 @@ write_final_rev(const svn_fs_id_t **new_
   if (noderev->copyroot_rev == SVN_INVALID_REVNUM)
     noderev->copyroot_rev = rev;
 
-  new_id = svn_fs_fs__id_rev_create(my_node_id, my_copy_id, rev, my_offset,
+  new_id = svn_fs_py__id_rev_create(my_node_id, my_copy_id, rev, my_offset,
                                     pool);
 
   noderev->id = new_id;
 
   /* Write out our new node-revision. */
-  SVN_ERR(svn_fs_fs__write_noderev(svn_stream_from_aprfile2(file, TRUE, pool),
+  SVN_ERR(svn_fs_py__write_noderev(svn_stream_from_aprfile2(file, TRUE, pool),
                                    noderev, ffd->format,
-                                   svn_fs_fs__fs_supports_mergeinfo(fs),
+                                   svn_fs_py__fs_supports_mergeinfo(fs),
                                    pool));
 
   /* Save the data representation's hash in the rep cache. */
@@ -6049,7 +6049,7 @@ write_final_rev(const svn_fs_id_t **new_
     {
       SVN_ERR_ASSERT(reps_to_cache && reps_pool);
       APR_ARRAY_PUSH(reps_to_cache, representation_t *)
-        = svn_fs_fs__rep_copy(noderev->data_rep, reps_pool);
+        = svn_fs_py__rep_copy(noderev->data_rep, reps_pool);
     }
 
   /* Return our ID that references the revision file. */
@@ -6079,7 +6079,7 @@ write_final_changed_path_info(apr_off_t 
 
   SVN_ERR(get_file_offset(&offset, file, pool));
 
-  SVN_ERR(svn_fs_fs__txn_changes_fetch(&changed_paths, fs, txn_id, pool));
+  SVN_ERR(svn_fs_py__txn_changes_fetch(&changed_paths, fs, txn_id, pool));
 
   /* Iterate through the changed paths one at a time, and convert the
      temporary node-id into a permanent one for each change entry. */
@@ -6101,9 +6101,9 @@ write_final_changed_path_info(apr_off_t 
          leave the change entry pointing to the non-existent temporary
          node, since it will never be used. */
       if ((change->change_kind != svn_fs_path_change_delete) &&
-          (! svn_fs_fs__id_txn_id(id)))
+          (! svn_fs_py__id_txn_id(id)))
         {
-          SVN_ERR(svn_fs_fs__get_node_revision(&noderev, fs, id, iterpool));
+          SVN_ERR(svn_fs_py__get_node_revision(&noderev, fs, id, iterpool));
 
           /* noderev has the permanent node-id at this point, so we just
              substitute it for the temporary one. */
@@ -6140,7 +6140,7 @@ write_current(svn_fs_t *fs, svn_revnum_t
   else
     buf = apr_psprintf(pool, "%ld %s %s\n", rev, next_node_id, next_copy_id);
 
-  name = svn_fs_fs__path_current(fs, pool);
+  name = svn_fs_py__path_current(fs, pool);
   SVN_ERR(svn_io_write_unique(&tmp_name,
                               svn_dirent_dirname(name, pool),
                               buf, strlen(buf),
@@ -6172,8 +6172,8 @@ write_final_current(svn_fs_t *fs,
      the 'current' file, to the next ids from the transaction file. */
   SVN_ERR(read_next_ids(&txn_node_id, &txn_copy_id, fs, txn_id, pool));
 
-  svn_fs_fs__add_keys(start_node_id, txn_node_id, new_node_id);
-  svn_fs_fs__add_keys(start_copy_id, txn_copy_id, new_copy_id);
+  svn_fs_py__add_keys(start_node_id, txn_node_id, new_node_id);
+  svn_fs_py__add_keys(start_copy_id, txn_copy_id, new_copy_id);
 
   return write_current(fs, rev, new_node_id, new_copy_id, pool);
 }
@@ -6194,7 +6194,7 @@ verify_locks(svn_fs_t *fs,
   int i;
 
   /* Fetch the changes for this transaction. */
-  SVN_ERR(svn_fs_fs__txn_changes_fetch(&changes, fs, txn_name, pool));
+  SVN_ERR(svn_fs_py__txn_changes_fetch(&changes, fs, txn_name, pool));
 
   /* Make an array of the changed paths, and sort them depth-first-ily.  */
   changed_paths = apr_array_make(pool, apr_hash_count(changes) + 1,
@@ -6236,7 +6236,7 @@ verify_locks(svn_fs_t *fs,
          recursive check on deleted paths regardless of their kind.  */
       if (change->change_kind == svn_fs_path_change_modify)
         recurse = FALSE;
-      SVN_ERR(svn_fs_fs__allow_locked_operation(path, fs, recurse, TRUE,
+      SVN_ERR(svn_fs_py__allow_locked_operation(path, fs, recurse, TRUE,
                                                 subpool));
 
       /* If we just did a recursive check, remember the path we
@@ -6262,8 +6262,8 @@ struct commit_baton {
   apr_pool_t *reps_pool;
 };
 
-/* The work-horse for svn_fs_fs__commit, called with the FS write lock.
-   This implements the svn_fs_fs__with_write_lock() 'body' callback
+/* The work-horse for svn_fs_py__commit, called with the FS write lock.
+   This implements the svn_fs_py__with_write_lock() 'body' callback
    type.  BATON is a 'struct commit_baton *'. */
 static svn_error_t *
 commit_body(void *baton, apr_pool_t *pool)
@@ -6285,7 +6285,7 @@ commit_body(void *baton, apr_pool_t *poo
   svn_string_t date;
 
   /* Get the current youngest revision. */
-  SVN_ERR(svn_fs_fs__youngest_rev(&old_rev, cb->fs, pool));
+  SVN_ERR(svn_fs_py__youngest_rev(&old_rev, cb->fs, pool));
 
   /* Check to make sure this transaction is based off the most recent
      revision. */
@@ -6313,7 +6313,7 @@ commit_body(void *baton, apr_pool_t *poo
   SVN_ERR(get_file_offset(&initial_offset, proto_file, pool));
 
   /* Write out all the node-revisions and directory contents. */
-  root_id = svn_fs_fs__id_txn_create("0", "0", cb->txn->id, pool);
+  root_id = svn_fs_py__id_txn_create("0", "0", cb->txn->id, pool);
   SVN_ERR(write_final_rev(&new_root_id, proto_file, new_rev, cb->fs, root_id,
                           start_node_id, start_copy_id, initial_offset,
                           cb->reps_to_cache, cb->reps_pool,
@@ -6325,7 +6325,7 @@ commit_body(void *baton, apr_pool_t *poo
 
   /* Write the final line. */
   buf = apr_psprintf(pool, "\n%" APR_OFF_T_FMT " %" APR_OFF_T_FMT "\n",
-                     svn_fs_fs__id_offset(new_root_id),
+                     svn_fs_py__id_offset(new_root_id),
                      changed_path_offset);
   SVN_ERR(svn_io_file_write_full(proto_file, buf, strlen(buf), NULL,
                                  pool));
@@ -6337,7 +6337,7 @@ commit_body(void *baton, apr_pool_t *poo
      before we commit it. */
 
   /* Remove any temporary txn props representing 'flags'. */
-  SVN_ERR(svn_fs_fs__txn_proplist(&txnprops, cb->txn, pool));
+  SVN_ERR(svn_fs_py__txn_proplist(&txnprops, cb->txn, pool));
   txnprop_list = apr_array_make(pool, 3, sizeof(svn_prop_t));
   prop.value = NULL;
 
@@ -6355,7 +6355,7 @@ commit_body(void *baton, apr_pool_t *poo
     }
 
   if (! apr_is_empty_array(txnprop_list))
-    SVN_ERR(svn_fs_fs__change_txn_props(cb->txn, txnprop_list, pool));
+    SVN_ERR(svn_fs_py__change_txn_props(cb->txn, txnprop_list, pool));
 
   /* Create the shard for the rev and revprop file, if we're sharding and
      this is the first revision of a new shard.  We don't care if this
@@ -6391,7 +6391,7 @@ commit_body(void *baton, apr_pool_t *poo
     }
 
   /* Move the finished rev file into place. */
-  SVN_ERR(svn_fs_fs__path_rev_absolute(&old_rev_filename,
+  SVN_ERR(svn_fs_py__path_rev_absolute(&old_rev_filename,
                                        cb->fs, old_rev, pool));
   rev_filename = path_rev(cb->fs, new_rev, pool);
   proto_filename = path_txn_proto_rev(cb->fs, cb->txn->id, pool);
@@ -6408,7 +6408,7 @@ commit_body(void *baton, apr_pool_t *poo
   date.data = svn_time_to_cstring(apr_time_now(), pool);
   date.len = strlen(date.data);
 
-  SVN_ERR(svn_fs_fs__change_txn_prop(cb->txn, SVN_PROP_REVISION_DATE,
+  SVN_ERR(svn_fs_py__change_txn_prop(cb->txn, SVN_PROP_REVISION_DATE,
                                      &date, pool));
 
   /* Move the revprops file into place. */
@@ -6432,7 +6432,7 @@ commit_body(void *baton, apr_pool_t *poo
   ffd->youngest_rev_cache = new_rev;
 
   /* Remove this transaction directory. */
-  SVN_ERR(svn_fs_fs__purge_txn(cb->fs, cb->txn->id, pool));
+  SVN_ERR(svn_fs_py__purge_txn(cb->fs, cb->txn->id, pool));
 
   return SVN_NO_ERROR;
 }
@@ -6452,7 +6452,7 @@ write_reps_to_cache(svn_fs_t *fs,
 
       /* FALSE because we don't care if another parallel commit happened to
        * collide with us.  (Non-parallel collisions will not be detected.) */
-      SVN_ERR(svn_fs_fs__set_rep_reference(fs, rep, FALSE, scratch_pool));
+      SVN_ERR(svn_fs_py__set_rep_reference(fs, rep, FALSE, scratch_pool));
     }
 
   return SVN_NO_ERROR;
@@ -6476,7 +6476,7 @@ commit_sqlite_txn_callback(void *baton, 
 }
 
 svn_error_t *
-svn_fs_fs__commit(svn_revnum_t *new_rev_p,
+svn_fs_py__commit(svn_revnum_t *new_rev_p,
                   svn_fs_t *fs,
                   svn_fs_txn_t *txn,
                   apr_pool_t *pool)
@@ -6499,13 +6499,13 @@ svn_fs_fs__commit(svn_revnum_t *new_rev_
       cb.reps_pool = NULL;
     }
 
-  SVN_ERR(svn_fs_fs__with_write_lock(fs, commit_body, &cb, pool));
+  SVN_ERR(svn_fs_py__with_write_lock(fs, commit_body, &cb, pool));
 
   if (ffd->rep_sharing_allowed)
     {
       /* At this point, *NEW_REV_P has been set, so errors here won't affect
          the success of the commit.  (See svn_fs_commit_txn().)  */
-      SVN_ERR(svn_fs_fs__open_rep_cache(fs, pool));
+      SVN_ERR(svn_fs_py__open_rep_cache(fs, pool));
       SVN_ERR(svn_sqlite__with_transaction(ffd->rep_cache_db,
                                            commit_sqlite_txn_callback,
                                            &cb, pool));
@@ -6516,7 +6516,7 @@ svn_fs_fs__commit(svn_revnum_t *new_rev_
 
 
 svn_error_t *
-svn_fs_fs__reserve_copy_id(const char **copy_id_p,
+svn_fs_py__reserve_copy_id(const char **copy_id_p,
                            svn_fs_t *fs,
                            const char *txn_id,
                            apr_pool_t *pool)
@@ -6531,7 +6531,7 @@ svn_fs_fs__reserve_copy_id(const char **
   copy_id = apr_pcalloc(pool, strlen(cur_copy_id) + 2);
 
   len = strlen(cur_copy_id);
-  svn_fs_fs__next_key(cur_copy_id, &len, copy_id);
+  svn_fs_py__next_key(cur_copy_id, &len, copy_id);
 
   SVN_ERR(write_next_ids(fs, txn_id, cur_node_id, copy_id, pool));
 
@@ -6569,7 +6569,7 @@ write_revision_zero(svn_fs_t *fs)
 }
 
 svn_error_t *
-svn_fs_fs__create(svn_fs_t *fs,
+svn_fs_py__create(svn_fs_t *fs,
                   const char *path,
                   apr_pool_t *pool)
 {
@@ -6626,12 +6626,12 @@ svn_fs_fs__create(svn_fs_t *fs,
                                         pool));
 
   /* Create the 'current' file. */
-  SVN_ERR(svn_io_file_create(svn_fs_fs__path_current(fs, pool),
+  SVN_ERR(svn_io_file_create(svn_fs_py__path_current(fs, pool),
                              (format >= SVN_FS_FS__MIN_NO_GLOBAL_IDS_FORMAT
                               ? "0\n" : "0 1 1\n"),
                              pool));
   SVN_ERR(svn_io_file_create(path_lock(fs, pool), "", pool));
-  SVN_ERR(svn_fs_fs__set_uuid(fs, NULL, pool));
+  SVN_ERR(svn_fs_py__set_uuid(fs, NULL, pool));
 
   SVN_ERR(write_revision_zero(fs));
 
@@ -6869,24 +6869,24 @@ recover_find_max_ids(svn_fs_t *fs, svn_r
         return svn_error_create(SVN_ERR_FS_CORRUPT, NULL,
                                 _("Directory entry corrupt"));
 
-      id = svn_fs_fs__id_parse(str, strlen(str), iterpool);
+      id = svn_fs_py__id_parse(str, strlen(str), iterpool);
 
-      if (svn_fs_fs__id_rev(id) != rev)
+      if (svn_fs_py__id_rev(id) != rev)
         {
           /* If the node wasn't modified in this revision, we've already
              checked the node and copy id. */
           continue;
         }
 
-      node_id = svn_fs_fs__id_node_id(id);
-      copy_id = svn_fs_fs__id_copy_id(id);
+      node_id = svn_fs_py__id_node_id(id);
+      copy_id = svn_fs_py__id_copy_id(id);
 
-      if (svn_fs_fs__key_compare(node_id, max_node_id) > 0)
+      if (svn_fs_py__key_compare(node_id, max_node_id) > 0)
         {
           SVN_ERR_ASSERT(strlen(node_id) < MAX_KEY_SIZE);
           apr_cpystrn(max_node_id, node_id, MAX_KEY_SIZE);
         }
-      if (svn_fs_fs__key_compare(copy_id, max_copy_id) > 0)
+      if (svn_fs_py__key_compare(copy_id, max_copy_id) > 0)
         {
           SVN_ERR_ASSERT(strlen(copy_id) < MAX_KEY_SIZE);
           apr_cpystrn(max_copy_id, copy_id, MAX_KEY_SIZE);
@@ -6895,7 +6895,7 @@ recover_find_max_ids(svn_fs_t *fs, svn_r
       if (kind == svn_node_file)
         continue;
 
-      child_dir_offset = svn_fs_fs__id_offset(id);
+      child_dir_offset = svn_fs_py__id_offset(id);
       SVN_ERR(recover_find_max_ids(fs, rev, rev_file, child_dir_offset,
                                    max_node_id, max_copy_id, iterpool));
     }
@@ -6911,8 +6911,8 @@ struct recover_baton {
   void *cancel_baton;
 };
 
-/* The work-horse for svn_fs_fs__recover, called with the FS
-   write lock.  This implements the svn_fs_fs__with_write_lock()
+/* The work-horse for svn_fs_py__recover, called with the FS
+   write lock.  This implements the svn_fs_py__with_write_lock()
    'body' callback type.  BATON is a 'struct recover_baton *'. */
 static svn_error_t *
 recover_body(void *baton, apr_pool_t *pool)
@@ -7004,10 +7004,10 @@ recover_body(void *baton, apr_pool_t *po
       /* Now that we finally have the maximum revision, node-id and copy-id, we
          can bump the two ids to get the next of each. */
       len = strlen(max_node_id);
-      svn_fs_fs__next_key(max_node_id, &len, next_node_id_buf);
+      svn_fs_py__next_key(max_node_id, &len, next_node_id_buf);
       next_node_id = next_node_id_buf;
       len = strlen(max_copy_id);
-      svn_fs_fs__next_key(max_copy_id, &len, next_copy_id_buf);
+      svn_fs_py__next_key(max_copy_id, &len, next_copy_id_buf);
       next_copy_id = next_copy_id_buf;
     }
 
@@ -7040,7 +7040,7 @@ recover_body(void *baton, apr_pool_t *po
 
 /* This implements the fs_library_vtable_t.recover() API. */
 svn_error_t *
-svn_fs_fs__recover(svn_fs_t *fs,
+svn_fs_py__recover(svn_fs_t *fs,
                    svn_cancel_func_t cancel_func, void *cancel_baton,
                    apr_pool_t *pool)
 {
@@ -7053,11 +7053,11 @@ svn_fs_fs__recover(svn_fs_t *fs,
   b.fs = fs;
   b.cancel_func = cancel_func;
   b.cancel_baton = cancel_baton;
-  return svn_fs_fs__with_write_lock(fs, recover_body, &b, pool);
+  return svn_fs_py__with_write_lock(fs, recover_body, &b, pool);
 }
 
 svn_error_t *
-svn_fs_fs__get_uuid(svn_fs_t *fs,
+svn_fs_py__get_uuid(svn_fs_t *fs,
                     const char **uuid_p,
                     apr_pool_t *pool)
 {
@@ -7068,7 +7068,7 @@ svn_fs_fs__get_uuid(svn_fs_t *fs,
 }
 
 svn_error_t *
-svn_fs_fs__set_uuid(svn_fs_t *fs,
+svn_fs_py__set_uuid(svn_fs_t *fs,
                     const char *uuid,
                     apr_pool_t *pool)
 {
@@ -7093,7 +7093,7 @@ svn_fs_fs__set_uuid(svn_fs_t *fs,
   /* We use the permissions of the 'current' file, because the 'uuid'
      file does not exist during repository creation. */
   SVN_ERR(move_into_place(tmp_path, uuid_path,
-                          svn_fs_fs__path_current(fs, pool), pool));
+                          svn_fs_py__path_current(fs, pool), pool));
 
   /* Remove the newline we added, and stash the UUID. */
   my_uuid[my_uuid_len - 1] = '\0';
@@ -7107,7 +7107,7 @@ svn_fs_fs__set_uuid(svn_fs_t *fs,
 /* If directory PATH does not exist, create it and give it the same
    permissions as FS->path.*/
 svn_error_t *
-svn_fs_fs__ensure_dir_exists(const char *path,
+svn_fs_py__ensure_dir_exists(const char *path,
                              const char *fs_path,
                              apr_pool_t *pool)
 {
@@ -7153,7 +7153,7 @@ get_node_origins_from_file(svn_fs_t *fs,
 }
 
 svn_error_t *
-svn_fs_fs__get_node_origin(const svn_fs_id_t **origin_id,
+svn_fs_py__get_node_origin(const svn_fs_id_t **origin_id,
                            svn_fs_t *fs,
                            const char *node_id,
                            apr_pool_t *pool)
@@ -7169,14 +7169,14 @@ svn_fs_fs__get_node_origin(const svn_fs_
       svn_string_t *origin_id_str =
         apr_hash_get(node_origins, node_id, APR_HASH_KEY_STRING);
       if (origin_id_str)
-        *origin_id = svn_fs_fs__id_parse(origin_id_str->data,
+        *origin_id = svn_fs_py__id_parse(origin_id_str->data,
                                          origin_id_str->len, pool);
     }
   return SVN_NO_ERROR;
 }
 
 
-/* Helper for svn_fs_fs__set_node_origin.  Takes a NODE_ID/NODE_REV_ID
+/* Helper for svn_fs_py__set_node_origin.  Takes a NODE_ID/NODE_REV_ID
    pair and adds it to the NODE_ORIGINS_PATH file.  */
 static svn_error_t *
 set_node_origins_for_file(svn_fs_t *fs,
@@ -7190,7 +7190,7 @@ set_node_origins_for_file(svn_fs_t *fs,
   apr_hash_t *origins_hash;
   svn_string_t *old_node_rev_id;
 
-  SVN_ERR(svn_fs_fs__ensure_dir_exists(svn_dirent_join(fs->path,
+  SVN_ERR(svn_fs_py__ensure_dir_exists(svn_dirent_join(fs->path,
                                                        PATH_NODE_ORIGINS_DIR,
                                                        pool),
                                        fs->path, pool));
@@ -7233,7 +7233,7 @@ set_node_origins_for_file(svn_fs_t *fs,
 
 
 svn_error_t *
-svn_fs_fs__set_node_origin(svn_fs_t *fs,
+svn_fs_py__set_node_origin(svn_fs_t *fs,
                            const char *node_id,
                            const svn_fs_id_t *node_rev_id,
                            apr_pool_t *pool)
@@ -7243,7 +7243,7 @@ svn_fs_fs__set_node_origin(svn_fs_t *fs,
 
   err = set_node_origins_for_file(fs, filename,
                                   node_id,
-                                  svn_fs_fs__id_unparse(node_rev_id, pool),
+                                  svn_fs_py__id_unparse(node_rev_id, pool),
                                   pool);
   if (err && APR_STATUS_IS_EACCES(err->apr_err))
     {
@@ -7256,7 +7256,7 @@ svn_fs_fs__set_node_origin(svn_fs_t *fs,
 
 
 svn_error_t *
-svn_fs_fs__list_transactions(apr_array_header_t **names_p,
+svn_fs_py__list_transactions(apr_array_header_t **names_p,
                              svn_fs_t *fs,
                              apr_pool_t *pool)
 {
@@ -7297,7 +7297,7 @@ svn_fs_fs__list_transactions(apr_array_h
 }
 
 svn_error_t *
-svn_fs_fs__open_txn(svn_fs_txn_t **txn_p,
+svn_fs_py__open_txn(svn_fs_txn_t **txn_p,
                     svn_fs_t *fs,
                     const char *name,
                     apr_pool_t *pool)
@@ -7321,9 +7321,9 @@ svn_fs_fs__open_txn(svn_fs_txn_t **txn_p
   txn->id = apr_pstrdup(pool, name);
   txn->fs = fs;
 
-  SVN_ERR(svn_fs_fs__get_txn(&local_txn, fs, name, pool));
+  SVN_ERR(svn_fs_py__get_txn(&local_txn, fs, name, pool));
 
-  txn->base_rev = svn_fs_fs__id_rev(local_txn->base_id);
+  txn->base_rev = svn_fs_py__id_rev(local_txn->base_id);
 
   txn->vtable = &txn_vtable;
   *txn_p = txn;
@@ -7332,7 +7332,7 @@ svn_fs_fs__open_txn(svn_fs_txn_t **txn_p
 }
 
 svn_error_t *
-svn_fs_fs__txn_proplist(apr_hash_t **table_p,
+svn_fs_py__txn_proplist(apr_hash_t **table_p,
                         svn_fs_txn_t *txn,
                         apr_pool_t *pool)
 {
@@ -7344,13 +7344,13 @@ svn_fs_fs__txn_proplist(apr_hash_t **tab
 }
 
 svn_error_t *
-svn_fs_fs__delete_node_revision(svn_fs_t *fs,
+svn_fs_py__delete_node_revision(svn_fs_t *fs,
                                 const svn_fs_id_t *id,
                                 apr_pool_t *pool)
 {
   node_revision_t *noderev;
 
-  SVN_ERR(svn_fs_fs__get_node_revision(&noderev, fs, id, pool));
+  SVN_ERR(svn_fs_py__get_node_revision(&noderev, fs, id, pool));
 
   /* Delete any mutable property representation. */
   if (noderev->prop_rep && noderev->prop_rep->txn_id)
@@ -7368,7 +7368,7 @@ svn_fs_fs__delete_node_revision(svn_fs_t
       /* remove the corresponding entry from the cache, if such exists */
       if (ffd->txn_dir_cache)
         {
-          const char *key = svn_fs_fs__id_unparse(id, pool)->data;
+          const char *key = svn_fs_py__id_unparse(id, pool)->data;
           SVN_ERR(svn_cache__set(ffd->txn_dir_cache, key, NULL, pool));
         }
     }
@@ -7381,7 +7381,7 @@ svn_fs_fs__delete_node_revision(svn_fs_t
 /*** Revisions ***/
 
 svn_error_t *
-svn_fs_fs__revision_prop(svn_string_t **value_p,
+svn_fs_py__revision_prop(svn_string_t **value_p,
                          svn_fs_t *fs,
                          svn_revnum_t rev,
                          const char *propname,
@@ -7390,7 +7390,7 @@ svn_fs_fs__revision_prop(svn_string_t **
   apr_hash_t *table;
 
   SVN_ERR(svn_fs__check_fs(fs, TRUE));
-  SVN_ERR(svn_fs_fs__revision_proplist(&table, fs, rev, pool));
+  SVN_ERR(svn_fs_py__revision_proplist(&table, fs, rev, pool));
 
   *value_p = apr_hash_get(table, propname, APR_HASH_KEY_STRING);
 
@@ -7407,8 +7407,8 @@ struct change_rev_prop_baton {
   const svn_string_t *value;
 };
 
-/* The work-horse for svn_fs_fs__change_rev_prop, called with the FS
-   write lock.  This implements the svn_fs_fs__with_write_lock()
+/* The work-horse for svn_fs_py__change_rev_prop, called with the FS
+   write lock.  This implements the svn_fs_py__with_write_lock()
    'body' callback type.  BATON is a 'struct change_rev_prop_baton *'. */
 
 static svn_error_t *
@@ -7417,7 +7417,7 @@ change_rev_prop_body(void *baton, apr_po
   struct change_rev_prop_baton *cb = baton;
   apr_hash_t *table;
 
-  SVN_ERR(svn_fs_fs__revision_proplist(&table, cb->fs, cb->rev, pool));
+  SVN_ERR(svn_fs_py__revision_proplist(&table, cb->fs, cb->rev, pool));
 
   if (cb->old_value_p)
     {
@@ -7442,7 +7442,7 @@ change_rev_prop_body(void *baton, apr_po
 }
 
 svn_error_t *
-svn_fs_fs__change_rev_prop(svn_fs_t *fs,
+svn_fs_py__change_rev_prop(svn_fs_t *fs,
                            svn_revnum_t rev,
                            const char *name,
                            const svn_string_t *const *old_value_p,
@@ -7459,7 +7459,7 @@ svn_fs_fs__change_rev_prop(svn_fs_t *fs,
   cb.old_value_p = old_value_p;
   cb.value = value;
 
-  return svn_fs_fs__with_write_lock(fs, change_rev_prop_body, &cb, pool);
+  return svn_fs_py__with_write_lock(fs, change_rev_prop_body, &cb, pool);
 }
 
 
@@ -7467,14 +7467,14 @@ svn_fs_fs__change_rev_prop(svn_fs_t *fs,
 /*** Transactions ***/
 
 svn_error_t *
-svn_fs_fs__get_txn_ids(const svn_fs_id_t **root_id_p,
+svn_fs_py__get_txn_ids(const svn_fs_id_t **root_id_p,
                        const svn_fs_id_t **base_root_id_p,
                        svn_fs_t *fs,
                        const char *txn_name,
                        apr_pool_t *pool)
 {
   transaction_t *txn;
-  SVN_ERR(svn_fs_fs__get_txn(&txn, fs, txn_name, pool));
+  SVN_ERR(svn_fs_py__get_txn(&txn, fs, txn_name, pool));
   *root_id_p = txn->root_id;
   *base_root_id_p = txn->base_id;
   return SVN_NO_ERROR;
@@ -7484,7 +7484,7 @@ svn_fs_fs__get_txn_ids(const svn_fs_id_t
 /* Generic transaction operations.  */
 
 svn_error_t *
-svn_fs_fs__txn_prop(svn_string_t **value_p,
+svn_fs_py__txn_prop(svn_string_t **value_p,
                     svn_fs_txn_t *txn,
                     const char *propname,
                     apr_pool_t *pool)
@@ -7493,7 +7493,7 @@ svn_fs_fs__txn_prop(svn_string_t **value
   svn_fs_t *fs = txn->fs;
 
   SVN_ERR(svn_fs__check_fs(fs, TRUE));
-  SVN_ERR(svn_fs_fs__txn_proplist(&table, txn, pool));
+  SVN_ERR(svn_fs_py__txn_proplist(&table, txn, pool));
 
   *value_p = apr_hash_get(table, propname, APR_HASH_KEY_STRING);
 
@@ -7501,7 +7501,7 @@ svn_fs_fs__txn_prop(svn_string_t **value
 }
 
 svn_error_t *
-svn_fs_fs__begin_txn(svn_fs_txn_t **txn_p,
+svn_fs_py__begin_txn(svn_fs_txn_t **txn_p,
                      svn_fs_t *fs,
                      svn_revnum_t rev,
                      apr_uint32_t flags,
@@ -7513,7 +7513,7 @@ svn_fs_fs__begin_txn(svn_fs_txn_t **txn_
 
   SVN_ERR(svn_fs__check_fs(fs, TRUE));
 
-  SVN_ERR(svn_fs_fs__create_txn(txn_p, fs, rev, pool));
+  SVN_ERR(svn_fs_py__create_txn(txn_p, fs, rev, pool));
 
   /* Put a datestamp on the newly created txn, so we always know
      exactly how old it is.  (This will help sysadmins identify
@@ -7543,7 +7543,7 @@ svn_fs_fs__begin_txn(svn_fs_txn_t **txn_
       APR_ARRAY_PUSH(props, svn_prop_t) = prop;
     }
 
-  return svn_fs_fs__change_txn_props(*txn_p, props, pool);
+  return svn_fs_py__change_txn_props(*txn_p, props, pool);
 }
 
 
@@ -7689,8 +7689,8 @@ struct pack_baton
 };
 
 
-/* The work-horse for svn_fs_fs__pack, called with the FS write lock.
-   This implements the svn_fs_fs__with_write_lock() 'body' callback
+/* The work-horse for svn_fs_py__pack, called with the FS write lock.
+   This implements the svn_fs_py__with_write_lock() 'body' callback
    type.  BATON is a 'struct pack_baton *'.
 
    WARNING: if you add a call to this function, please note:
@@ -7698,7 +7698,7 @@ struct pack_baton
      the write-lock set can rely on the ffd->min_unpacked_rev and
      ffd->min_unpacked_revprop caches to be up-to-date (and, by
      extension, on not having to use a retry when calling
-     svn_fs_fs__path_rev_absolute() and friends).  If you add a call
+     svn_fs_py__path_rev_absolute() and friends).  If you add a call
      to this function, consider whether you have to call
      update_min_unpacked_rev() and update_min_unpacked_revprop()
      afterwards.
@@ -7763,7 +7763,7 @@ pack_body(void *baton,
 }
 
 svn_error_t *
-svn_fs_fs__pack(svn_fs_t *fs,
+svn_fs_py__pack(svn_fs_t *fs,
                 svn_fs_pack_notify_t notify_func,
                 void *notify_baton,
                 svn_cancel_func_t cancel_func,
@@ -7776,14 +7776,14 @@ svn_fs_fs__pack(svn_fs_t *fs,
   pb.notify_baton = notify_baton;
   pb.cancel_func = cancel_func;
   pb.cancel_baton = cancel_baton;
-  return svn_fs_fs__with_write_lock(fs, pack_body, &pb, pool);
+  return svn_fs_py__with_write_lock(fs, pack_body, &pb, pool);
 }
 
 
 /** Verifying. **/
 
-/* Body of svn_fs_fs__verify().
-   Implements svn_fs_fs__walk_rep_reference().walker.  */
+/* Body of svn_fs_py__verify().
+   Implements svn_fs_py__walk_rep_reference().walker.  */
 static svn_error_t *
 verify_walker(representation_t *rep,
               void *baton,
@@ -7800,7 +7800,7 @@ verify_walker(representation_t *rep,
 }
 
 svn_error_t *
-svn_fs_fs__verify(svn_fs_t *fs,
+svn_fs_py__verify(svn_fs_t *fs,
                   svn_cancel_func_t cancel_func,
                   void *cancel_baton,
                   apr_pool_t *pool)
@@ -7813,10 +7813,10 @@ svn_fs_fs__verify(svn_fs_t *fs,
 
   /* Do not attempt to walk the rep-cache database if its file does not exists,
      since doing so would create it --- which may confuse the administrator. */
-  SVN_ERR(svn_fs_fs__exists_rep_cache(&exists, fs, pool));
+  SVN_ERR(svn_fs_py__exists_rep_cache(&exists, fs, pool));
   if (exists)
     /* Don't take any lock. */
-    SVN_ERR(svn_fs_fs__walk_rep_reference(fs, verify_walker, NULL,
+    SVN_ERR(svn_fs_py__walk_rep_reference(fs, verify_walker, NULL,
                                           cancel_func, cancel_baton,
                                           pool));
 



Mime
View raw message