subversion-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From hwri...@apache.org
Subject svn commit: r1154262 [4/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/tree.c
URL: http://svn.apache.org/viewvc/subversion/branches/fs-py/subversion/libsvn_fs_py/tree.c?rev=1154262&r1=1154224&r2=1154262&view=diff
==============================================================================
--- subversion/branches/fs-py/subversion/libsvn_fs_py/tree.c (original)
+++ subversion/branches/fs-py/subversion/libsvn_fs_py/tree.c Fri Aug  5 15:20:23 2011
@@ -181,7 +181,7 @@ dag_node_cache_get(dag_node_t **node_p,
     {
       /* Patch up the FS, since this might have come from an old FS
        * object. */
-      svn_fs_fs__dag_set_fs(node, root->fs);
+      svn_fs_py__dag_set_fs(node, root->fs);
       *node_p = node;
     }
   else
@@ -276,7 +276,7 @@ dag_node_cache_invalidate(svn_fs_root_t 
 /* Creating transaction and revision root nodes.  */
 
 svn_error_t *
-svn_fs_fs__txn_root(svn_fs_root_t **root_p,
+svn_fs_py__txn_root(svn_fs_root_t **root_p,
                     svn_fs_txn_t *txn,
                     apr_pool_t *pool)
 {
@@ -284,7 +284,7 @@ svn_fs_fs__txn_root(svn_fs_root_t **root
   apr_hash_t *txnprops;
 
   /* Look for the temporary txn props representing 'flags'. */
-  SVN_ERR(svn_fs_fs__txn_proplist(&txnprops, txn, pool));
+  SVN_ERR(svn_fs_py__txn_proplist(&txnprops, txn, pool));
   if (txnprops)
     {
       if (apr_hash_get(txnprops, SVN_FS__PROP_TXN_CHECK_OOD,
@@ -301,7 +301,7 @@ svn_fs_fs__txn_root(svn_fs_root_t **root
 
 
 svn_error_t *
-svn_fs_fs__revision_root(svn_fs_root_t **root_p,
+svn_fs_py__revision_root(svn_fs_root_t **root_p,
                          svn_fs_t *fs,
                          svn_revnum_t rev,
                          apr_pool_t *pool)
@@ -310,7 +310,7 @@ svn_fs_fs__revision_root(svn_fs_root_t *
 
   SVN_ERR(svn_fs__check_fs(fs, TRUE));
 
-  SVN_ERR(svn_fs_fs__dag_revision_root(&root_dir, fs, rev, pool));
+  SVN_ERR(svn_fs_py__dag_revision_root(&root_dir, fs, rev, pool));
 
   *root_p = make_revision_root(fs, rev, root_dir, pool);
 
@@ -332,14 +332,14 @@ root_node(dag_node_t **node_p,
   if (root->is_txn_root)
     {
       /* It's a transaction root.  Open a fresh copy.  */
-      return svn_fs_fs__dag_txn_root(node_p, root->fs, root->txn, pool);
+      return svn_fs_py__dag_txn_root(node_p, root->fs, root->txn, pool);
     }
   else
     {
       /* It's a revision root, so we already have its root directory
          opened.  */
       fs_rev_root_data_t *frd = root->fsap_data;
-      *node_p = svn_fs_fs__dag_dup(frd->root_dir, pool);
+      *node_p = svn_fs_py__dag_dup(frd->root_dir, pool);
       return SVN_NO_ERROR;
     }
 }
@@ -355,7 +355,7 @@ mutable_root_node(dag_node_t **node_p,
                   apr_pool_t *pool)
 {
   if (root->is_txn_root)
-    return svn_fs_fs__dag_clone_root(node_p, root->fs, root->txn, pool);
+    return svn_fs_py__dag_clone_root(node_p, root->fs, root->txn, pool);
   else
     /* If it's not a transaction root, we can't change its contents.  */
     return SVN_FS__ERR_NOT_MUTABLE(root->fs, root->rev, error_path, pool);
@@ -464,13 +464,13 @@ get_copy_inheritance(copy_id_inherit_t *
   SVN_ERR_ASSERT(child && child->parent && txn_id);
 
   /* Initialize some convenience variables. */
-  child_id = svn_fs_fs__dag_get_id(child->node);
-  parent_id = svn_fs_fs__dag_get_id(child->parent->node);
-  child_copy_id = svn_fs_fs__id_copy_id(child_id);
-  parent_copy_id = svn_fs_fs__id_copy_id(parent_id);
+  child_id = svn_fs_py__dag_get_id(child->node);
+  parent_id = svn_fs_py__dag_get_id(child->parent->node);
+  child_copy_id = svn_fs_py__id_copy_id(child_id);
+  parent_copy_id = svn_fs_py__id_copy_id(parent_id);
 
   /* If this child is already mutable, we have nothing to do. */
-  if (svn_fs_fs__id_txn_id(child_id))
+  if (svn_fs_py__id_txn_id(child_id))
     {
       *inherit_p = copy_id_inherit_self;
       *copy_src_path = NULL;
@@ -491,7 +491,7 @@ get_copy_inheritance(copy_id_inherit_t *
      the same, then the child is already on the same branch as the
      parent, and should use the same mutability copy ID that the
      parent will use. */
-  if (svn_fs_fs__key_compare(child_copy_id, parent_copy_id) == 0)
+  if (svn_fs_py__key_compare(child_copy_id, parent_copy_id) == 0)
     return SVN_NO_ERROR;
 
   /* If the child is on the same branch that the parent is on, the
@@ -501,18 +501,18 @@ get_copy_inheritance(copy_id_inherit_t *
      branch as its parent if the child itself is not a branch point,
      or if it is a branch point that we are accessing via its original
      copy destination path. */
-  SVN_ERR(svn_fs_fs__dag_get_copyroot(&copyroot_rev, &copyroot_path,
+  SVN_ERR(svn_fs_py__dag_get_copyroot(&copyroot_rev, &copyroot_path,
                                       child->node,pool));
-  SVN_ERR(svn_fs_fs__revision_root(&copyroot_root, fs, copyroot_rev, pool));
+  SVN_ERR(svn_fs_py__revision_root(&copyroot_root, fs, copyroot_rev, pool));
   SVN_ERR(get_dag(&copyroot_node, copyroot_root, copyroot_path, pool));
-  copyroot_id = svn_fs_fs__dag_get_id(copyroot_node);
+  copyroot_id = svn_fs_py__dag_get_id(copyroot_node);
 
-  if (svn_fs_fs__id_compare(copyroot_id, child_id) == -1)
+  if (svn_fs_py__id_compare(copyroot_id, child_id) == -1)
     return SVN_NO_ERROR;
 
   /* Determine if we are looking at the child via its original path or
      as a subtree item of a copied tree. */
-  id_path = svn_fs_fs__dag_get_created_path(child->node);
+  id_path = svn_fs_py__dag_get_created_path(child->node);
   if (strcmp(id_path, parent_path_path(child, pool)) == 0)
     {
       *inherit_p = copy_id_inherit_self;
@@ -642,7 +642,7 @@ open_path(parent_path_t **parent_path_p,
           if (cached_node)
             child = cached_node;
           else
-            err = svn_fs_fs__dag_open(&child, here, entry, pool);
+            err = svn_fs_py__dag_open(&child, here, entry, pool);
 
           /* "file not found" requires special handling.  */
           if (err && err->apr_err == SVN_ERR_FS_NOT_FOUND)
@@ -662,7 +662,7 @@ open_path(parent_path_t **parent_path_p,
                 }
               else
                 {
-                  /* Build a better error message than svn_fs_fs__dag_open
+                  /* Build a better error message than svn_fs_py__dag_open
                      can provide, giving the root and full path name.  */
                   return SVN_FS__NOT_FOUND(root, path);
                 }
@@ -691,7 +691,7 @@ open_path(parent_path_t **parent_path_p,
         break;
 
       /* The path isn't finished yet; we'd better be in a directory.  */
-      if (svn_fs_fs__dag_node_kind(child) != svn_node_dir)
+      if (svn_fs_py__dag_node_kind(child) != svn_node_dir)
         SVN_ERR_W(SVN_FS__ERR_NOT_DIRECTORY(fs, path_so_far, pool),
                   apr_psprintf(pool, _("Failure opening '%s'"), path));
 
@@ -719,7 +719,7 @@ make_path_mutable(svn_fs_root_t *root,
   const char *txn_id = root->txn;
 
   /* Is the node mutable already?  */
-  if (svn_fs_fs__dag_check_mutable(parent_path->node))
+  if (svn_fs_py__dag_check_mutable(parent_path->node))
     return SVN_NO_ERROR;
 
   /* Are we trying to clone the root, or somebody's child node?  */
@@ -742,12 +742,12 @@ make_path_mutable(svn_fs_root_t *root,
       switch (inherit)
         {
         case copy_id_inherit_parent:
-          parent_id = svn_fs_fs__dag_get_id(parent_path->parent->node);
-          copy_id = svn_fs_fs__id_copy_id(parent_id);
+          parent_id = svn_fs_py__dag_get_id(parent_path->parent->node);
+          copy_id = svn_fs_py__id_copy_id(parent_id);
           break;
 
         case copy_id_inherit_new:
-          SVN_ERR(svn_fs_fs__reserve_copy_id(&copy_id, root->fs, txn_id,
+          SVN_ERR(svn_fs_py__reserve_copy_id(&copy_id, root->fs, txn_id,
                                              pool));
           break;
 
@@ -762,21 +762,21 @@ make_path_mutable(svn_fs_root_t *root,
         }
 
       /* Determine what copyroot our new child node should use. */
-      SVN_ERR(svn_fs_fs__dag_get_copyroot(&copyroot_rev, &copyroot_path,
+      SVN_ERR(svn_fs_py__dag_get_copyroot(&copyroot_rev, &copyroot_path,
                                           parent_path->node, pool));
-      SVN_ERR(svn_fs_fs__revision_root(&copyroot_root, root->fs,
+      SVN_ERR(svn_fs_py__revision_root(&copyroot_root, root->fs,
                                        copyroot_rev, pool));
       SVN_ERR(get_dag(&copyroot_node, copyroot_root, copyroot_path, pool));
 
-      child_id = svn_fs_fs__dag_get_id(parent_path->node);
-      copyroot_id = svn_fs_fs__dag_get_id(copyroot_node);
-      if (strcmp(svn_fs_fs__id_node_id(child_id),
-                 svn_fs_fs__id_node_id(copyroot_id)) != 0)
+      child_id = svn_fs_py__dag_get_id(parent_path->node);
+      copyroot_id = svn_fs_py__dag_get_id(copyroot_node);
+      if (strcmp(svn_fs_py__id_node_id(child_id),
+                 svn_fs_py__id_node_id(copyroot_id)) != 0)
         is_parent_copyroot = TRUE;
 
       /* Now make this node mutable.  */
       clone_path = parent_path_path(parent_path->parent, pool);
-      SVN_ERR(svn_fs_fs__dag_clone_child(&clone,
+      SVN_ERR(svn_fs_py__dag_clone_child(&clone,
                                          parent_path->parent->node,
                                          clone_path,
                                          parent_path->entry,
@@ -857,7 +857,7 @@ add_change(svn_fs_t *fs,
            const char *copyfrom_path,
            apr_pool_t *pool)
 {
-  return svn_fs_fs__add_change(fs, txn_id,
+  return svn_fs_py__add_change(fs, txn_id,
                                svn_fs__canonicalize_abspath(path, pool),
                                noderev_id, change_kind, text_mod, prop_mod,
                                node_kind, copyfrom_rev, copyfrom_path,
@@ -884,21 +884,21 @@ fs_node_id(const svn_fs_id_t **id_p,
          svn_fs_root_t object, and never changes when it's a revision
          root, so we can just reach in and grab it directly. */
       fs_rev_root_data_t *frd = root->fsap_data;
-      *id_p = svn_fs_fs__id_copy(svn_fs_fs__dag_get_id(frd->root_dir), pool);
+      *id_p = svn_fs_py__id_copy(svn_fs_py__dag_get_id(frd->root_dir), pool);
     }
   else
     {
       dag_node_t *node;
 
       SVN_ERR(get_dag(&node, root, path, pool));
-      *id_p = svn_fs_fs__id_copy(svn_fs_fs__dag_get_id(node), pool);
+      *id_p = svn_fs_py__id_copy(svn_fs_py__dag_get_id(node), pool);
     }
   return SVN_NO_ERROR;
 }
 
 
 svn_error_t *
-svn_fs_fs__node_created_rev(svn_revnum_t *revision,
+svn_fs_py__node_created_rev(svn_revnum_t *revision,
                             svn_fs_root_t *root,
                             const char *path,
                             apr_pool_t *pool)
@@ -906,7 +906,7 @@ svn_fs_fs__node_created_rev(svn_revnum_t
   dag_node_t *node;
 
   SVN_ERR(get_dag(&node, root, path, pool));
-  return svn_fs_fs__dag_get_revision(revision, node, pool);
+  return svn_fs_py__dag_get_revision(revision, node, pool);
 }
 
 
@@ -921,7 +921,7 @@ fs_node_created_path(const char **create
   dag_node_t *node;
 
   SVN_ERR(get_dag(&node, root, path, pool));
-  *created_path = svn_fs_fs__dag_get_created_path(node);
+  *created_path = svn_fs_py__dag_get_created_path(node);
 
   return SVN_NO_ERROR;
 }
@@ -942,8 +942,8 @@ node_kind(svn_node_kind_t *kind_p,
   SVN_ERR(fs_node_id(&node_id, root, path, pool));
 
   /* Use the node id to get the real kind. */
-  SVN_ERR(svn_fs_fs__dag_get_node(&node, root->fs, node_id, pool));
-  *kind_p = svn_fs_fs__dag_node_kind(node);
+  SVN_ERR(svn_fs_py__dag_get_node(&node, root->fs, node_id, pool));
+  *kind_p = svn_fs_py__dag_node_kind(node);
 
   return SVN_NO_ERROR;
 }
@@ -953,7 +953,7 @@ node_kind(svn_node_kind_t *kind_p,
    PATH does not exist under ROOT, set *KIND_P to svn_node_none.  Use
    POOL for temporary allocation. */
 svn_error_t *
-svn_fs_fs__check_path(svn_node_kind_t *kind_p,
+svn_fs_py__check_path(svn_node_kind_t *kind_p,
                       svn_fs_root_t *root,
                       const char *path,
                       apr_pool_t *pool)
@@ -985,7 +985,7 @@ fs_node_prop(svn_string_t **value_p,
   apr_hash_t *proplist;
 
   SVN_ERR(get_dag(&node, root, path, pool));
-  SVN_ERR(svn_fs_fs__dag_get_proplist(&proplist, node, pool));
+  SVN_ERR(svn_fs_py__dag_get_proplist(&proplist, node, pool));
   *value_p = NULL;
   if (proplist)
     *value_p = apr_hash_get(proplist, propname, APR_HASH_KEY_STRING);
@@ -1008,7 +1008,7 @@ fs_node_proplist(apr_hash_t **table_p,
   dag_node_t *node;
 
   SVN_ERR(get_dag(&node, root, path, pool));
-  SVN_ERR(svn_fs_fs__dag_get_proplist(&table, node, pool));
+  SVN_ERR(svn_fs_py__dag_get_proplist(&table, node, pool));
   *table_p = table ? table : apr_hash_make(pool);
 
   return SVN_NO_ERROR;
@@ -1021,7 +1021,7 @@ increment_mergeinfo_up_tree(parent_path_
                             apr_pool_t *pool)
 {
   for (; pp; pp = pp->parent)
-    SVN_ERR(svn_fs_fs__dag_increment_mergeinfo_count(pp->node,
+    SVN_ERR(svn_fs_py__dag_increment_mergeinfo_count(pp->node,
                                                      increment,
                                                      pool));
 
@@ -1053,11 +1053,11 @@ fs_change_node_prop(svn_fs_root_t *root,
   /* Check (non-recursively) to see if path is locked; if so, check
      that we can use it. */
   if (root->txn_flags & SVN_FS_TXN_CHECK_LOCKS)
-    SVN_ERR(svn_fs_fs__allow_locked_operation(path, root->fs, FALSE, FALSE,
+    SVN_ERR(svn_fs_py__allow_locked_operation(path, root->fs, FALSE, FALSE,
                                               pool));
 
   SVN_ERR(make_path_mutable(root, parent_path, path, pool));
-  SVN_ERR(svn_fs_fs__dag_get_proplist(&proplist, parent_path->node, pool));
+  SVN_ERR(svn_fs_py__dag_get_proplist(&proplist, parent_path->node, pool));
 
   /* If there's no proplist, but we're just deleting a property, exit now. */
   if ((! proplist) && (! value))
@@ -1067,12 +1067,12 @@ fs_change_node_prop(svn_fs_root_t *root,
   if (! proplist)
     proplist = apr_hash_make(pool);
 
-  if (svn_fs_fs__fs_supports_mergeinfo(root->fs)
+  if (svn_fs_py__fs_supports_mergeinfo(root->fs)
       && strcmp (name, SVN_PROP_MERGEINFO) == 0)
     {
       apr_int64_t increment = 0;
       svn_boolean_t had_mergeinfo;
-      SVN_ERR(svn_fs_fs__dag_has_mergeinfo(&had_mergeinfo, parent_path->node,
+      SVN_ERR(svn_fs_py__dag_has_mergeinfo(&had_mergeinfo, parent_path->node,
                                            pool));
 
       if (value && !had_mergeinfo)
@@ -1083,7 +1083,7 @@ fs_change_node_prop(svn_fs_root_t *root,
       if (increment != 0)
         {
           SVN_ERR(increment_mergeinfo_up_tree(parent_path, increment, pool));
-          SVN_ERR(svn_fs_fs__dag_set_has_mergeinfo(parent_path->node,
+          SVN_ERR(svn_fs_py__dag_set_has_mergeinfo(parent_path->node,
                                                    (value != NULL), pool));
         }
     }
@@ -1092,14 +1092,14 @@ fs_change_node_prop(svn_fs_root_t *root,
   apr_hash_set(proplist, name, APR_HASH_KEY_STRING, value);
 
   /* Overwrite the node's proplist. */
-  SVN_ERR(svn_fs_fs__dag_set_proplist(parent_path->node, proplist,
+  SVN_ERR(svn_fs_py__dag_set_proplist(parent_path->node, proplist,
                                       pool));
 
   /* Make a record of this modification in the changes table. */
   return add_change(root->fs, txn_id, path,
-                    svn_fs_fs__dag_get_id(parent_path->node),
+                    svn_fs_py__dag_get_id(parent_path->node),
                     svn_fs_path_change_modify, FALSE, TRUE,
-                    svn_fs_fs__dag_node_kind(parent_path->node),
+                    svn_fs_py__dag_node_kind(parent_path->node),
                     SVN_INVALID_REVNUM, NULL, pool);
 }
 
@@ -1126,7 +1126,7 @@ fs_props_changed(svn_boolean_t *changed_
 
   SVN_ERR(get_dag(&node1, root1, path1, pool));
   SVN_ERR(get_dag(&node2, root2, path2, pool));
-  return svn_fs_fs__dag_things_different(changed_p, NULL,
+  return svn_fs_py__dag_things_different(changed_p, NULL,
                                          node1, node2, pool);
 }
 
@@ -1152,17 +1152,17 @@ update_ancestry(svn_fs_t *fs,
 {
   node_revision_t *noderev;
 
-  if (svn_fs_fs__id_txn_id(target_id) == NULL)
+  if (svn_fs_py__id_txn_id(target_id) == NULL)
     return svn_error_createf
       (SVN_ERR_FS_NOT_MUTABLE, NULL,
        _("Unexpected immutable node at '%s'"), target_path);
 
-  SVN_ERR(svn_fs_fs__get_node_revision(&noderev, fs, target_id, pool));
+  SVN_ERR(svn_fs_py__get_node_revision(&noderev, fs, target_id, pool));
   noderev->predecessor_id = source_id;
   noderev->predecessor_count = source_pred_count;
   if (noderev->predecessor_count != -1)
     noderev->predecessor_count++;
-  return svn_fs_fs__put_node_revision(fs, target_id, noderev, FALSE, pool);
+  return svn_fs_py__put_node_revision(fs, target_id, noderev, FALSE, pool);
 }
 
 
@@ -1221,9 +1221,9 @@ merge(svn_stringbuf_t *conflict_p,
   apr_int64_t mergeinfo_increment = 0;
 
   /* Make sure everyone comes from the same filesystem. */
-  fs = svn_fs_fs__dag_get_fs(ancestor);
-  if ((fs != svn_fs_fs__dag_get_fs(source))
-      || (fs != svn_fs_fs__dag_get_fs(target)))
+  fs = svn_fs_py__dag_get_fs(ancestor);
+  if ((fs != svn_fs_py__dag_get_fs(source))
+      || (fs != svn_fs_py__dag_get_fs(target)))
     {
       return svn_error_create
         (SVN_ERR_FS_CORRUPT, NULL,
@@ -1233,14 +1233,14 @@ merge(svn_stringbuf_t *conflict_p,
   /* We have the same fs, now check it. */
   SVN_ERR(svn_fs__check_fs(fs, TRUE));
 
-  source_id   = svn_fs_fs__dag_get_id(source);
-  target_id   = svn_fs_fs__dag_get_id(target);
-  ancestor_id = svn_fs_fs__dag_get_id(ancestor);
+  source_id   = svn_fs_py__dag_get_id(source);
+  target_id   = svn_fs_py__dag_get_id(target);
+  ancestor_id = svn_fs_py__dag_get_id(ancestor);
 
   /* It's improper to call this function with ancestor == target. */
-  if (svn_fs_fs__id_eq(ancestor_id, target_id))
+  if (svn_fs_py__id_eq(ancestor_id, target_id))
     {
-      svn_string_t *id_str = svn_fs_fs__id_unparse(target_id, pool);
+      svn_string_t *id_str = svn_fs_py__id_unparse(target_id, pool);
       return svn_error_createf
         (SVN_ERR_FS_GENERAL, NULL,
          _("Bad merge; target '%s' has id '%s', same as ancestor"),
@@ -1253,8 +1253,8 @@ merge(svn_stringbuf_t *conflict_p,
    * Either no change made in source, or same change as made in target.
    * Both mean nothing to merge here.
    */
-  if (svn_fs_fs__id_eq(ancestor_id, source_id)
-      || (svn_fs_fs__id_eq(source_id, target_id)))
+  if (svn_fs_py__id_eq(ancestor_id, source_id)
+      || (svn_fs_py__id_eq(source_id, target_id)))
     return SVN_NO_ERROR;
 
   /* Else proceed, knowing all three are distinct node revisions.
@@ -1321,9 +1321,9 @@ merge(svn_stringbuf_t *conflict_p,
    * directory TARGET, update TARGET's predecessor to be SOURCE.
    */
 
-  if ((svn_fs_fs__dag_node_kind(source) != svn_node_dir)
-      || (svn_fs_fs__dag_node_kind(target) != svn_node_dir)
-      || (svn_fs_fs__dag_node_kind(ancestor) != svn_node_dir))
+  if ((svn_fs_py__dag_node_kind(source) != svn_node_dir)
+      || (svn_fs_py__dag_node_kind(target) != svn_node_dir)
+      || (svn_fs_py__dag_node_kind(ancestor) != svn_node_dir))
     {
       return conflict_err(conflict_p, target_path);
     }
@@ -1343,9 +1343,9 @@ merge(svn_stringbuf_t *conflict_p,
     node_revision_t *tgt_nr, *anc_nr, *src_nr;
 
     /* Get node revisions for our id's. */
-    SVN_ERR(svn_fs_fs__get_node_revision(&tgt_nr, fs, target_id, pool));
-    SVN_ERR(svn_fs_fs__get_node_revision(&anc_nr, fs, ancestor_id, pool));
-    SVN_ERR(svn_fs_fs__get_node_revision(&src_nr, fs, source_id, pool));
+    SVN_ERR(svn_fs_py__get_node_revision(&tgt_nr, fs, target_id, pool));
+    SVN_ERR(svn_fs_py__get_node_revision(&anc_nr, fs, ancestor_id, pool));
+    SVN_ERR(svn_fs_py__get_node_revision(&src_nr, fs, source_id, pool));
 
     /* Now compare the prop-keys of the skels.  Note that just because
        the keys are different -doesn't- mean the proplists have
@@ -1353,18 +1353,18 @@ merge(svn_stringbuf_t *conflict_p,
        it doesn't do a brute-force comparison on textual contents, so
        it won't do that here either.  Checking to see if the propkey
        atoms are `equal' is enough. */
-    if (! svn_fs_fs__noderev_same_rep_key(tgt_nr->prop_rep, anc_nr->prop_rep))
+    if (! svn_fs_py__noderev_same_rep_key(tgt_nr->prop_rep, anc_nr->prop_rep))
       return conflict_err(conflict_p, target_path);
-    if (! svn_fs_fs__noderev_same_rep_key(src_nr->prop_rep, anc_nr->prop_rep))
+    if (! svn_fs_py__noderev_same_rep_key(src_nr->prop_rep, anc_nr->prop_rep))
       return conflict_err(conflict_p, target_path);
   }
 
   /* ### todo: it would be more efficient to simply check for a NULL
      entries hash where necessary below than to allocate an empty hash
      here, but another day, another day... */
-  SVN_ERR(svn_fs_fs__dag_dir_entries(&s_entries, source, pool, pool));
-  SVN_ERR(svn_fs_fs__dag_dir_entries(&t_entries, target, pool, pool));
-  SVN_ERR(svn_fs_fs__dag_dir_entries(&a_entries, ancestor, pool, pool));
+  SVN_ERR(svn_fs_py__dag_dir_entries(&s_entries, source, pool, pool));
+  SVN_ERR(svn_fs_py__dag_dir_entries(&t_entries, target, pool, pool));
+  SVN_ERR(svn_fs_py__dag_dir_entries(&a_entries, ancestor, pool, pool));
 
   /* for each entry E in a_entries... */
   iterpool = svn_pool_create(pool);
@@ -1387,20 +1387,20 @@ merge(svn_stringbuf_t *conflict_p,
 
       /* No changes were made to this entry while the transaction was
          in progress, so do nothing to the target. */
-      if (s_entry && svn_fs_fs__id_eq(a_entry->id, s_entry->id))
+      if (s_entry && svn_fs_py__id_eq(a_entry->id, s_entry->id))
         goto end;
 
       /* A change was made to this entry while the transaction was in
          process, but the transaction did not touch this entry. */
-      else if (t_entry && svn_fs_fs__id_eq(a_entry->id, t_entry->id))
+      else if (t_entry && svn_fs_py__id_eq(a_entry->id, t_entry->id))
         {
           dag_node_t *t_ent_node;
-          SVN_ERR(svn_fs_fs__dag_get_node(&t_ent_node, fs,
+          SVN_ERR(svn_fs_py__dag_get_node(&t_ent_node, fs,
                                           t_entry->id, iterpool));
-          if (svn_fs_fs__fs_supports_mergeinfo(fs))
+          if (svn_fs_py__fs_supports_mergeinfo(fs))
             {
               apr_int64_t mergeinfo_start;
-              SVN_ERR(svn_fs_fs__dag_get_mergeinfo_count(&mergeinfo_start,
+              SVN_ERR(svn_fs_py__dag_get_mergeinfo_count(&mergeinfo_start,
                                                          t_ent_node,
                                                          iterpool));
               mergeinfo_increment -= mergeinfo_start;
@@ -1409,19 +1409,19 @@ merge(svn_stringbuf_t *conflict_p,
           if (s_entry)
             {
               dag_node_t *s_ent_node;
-              SVN_ERR(svn_fs_fs__dag_get_node(&s_ent_node, fs,
+              SVN_ERR(svn_fs_py__dag_get_node(&s_ent_node, fs,
                                               s_entry->id, iterpool));
 
-              if (svn_fs_fs__fs_supports_mergeinfo(fs))
+              if (svn_fs_py__fs_supports_mergeinfo(fs))
                 {
                   apr_int64_t mergeinfo_end;
-                  SVN_ERR(svn_fs_fs__dag_get_mergeinfo_count(&mergeinfo_end,
+                  SVN_ERR(svn_fs_py__dag_get_mergeinfo_count(&mergeinfo_end,
                                                              s_ent_node,
                                                              iterpool));
                   mergeinfo_increment += mergeinfo_end;
                 }
 
-              SVN_ERR(svn_fs_fs__dag_set_entry(target, name,
+              SVN_ERR(svn_fs_py__dag_set_entry(target, name,
                                                s_entry->id,
                                                s_entry->kind,
                                                txn_id,
@@ -1429,7 +1429,7 @@ merge(svn_stringbuf_t *conflict_p,
             }
           else
             {
-              SVN_ERR(svn_fs_fs__dag_delete(target, name, txn_id, iterpool));
+              SVN_ERR(svn_fs_py__dag_delete(target, name, txn_id, iterpool));
             }
         }
 
@@ -1462,14 +1462,14 @@ merge(svn_stringbuf_t *conflict_p,
 
           /* If either SOURCE-ENTRY or TARGET-ENTRY is not a direct
              modification of ANCESTOR-ENTRY, declare a conflict. */
-          if (strcmp(svn_fs_fs__id_node_id(s_entry->id),
-                     svn_fs_fs__id_node_id(a_entry->id)) != 0
-              || strcmp(svn_fs_fs__id_copy_id(s_entry->id),
-                        svn_fs_fs__id_copy_id(a_entry->id)) != 0
-              || strcmp(svn_fs_fs__id_node_id(t_entry->id),
-                        svn_fs_fs__id_node_id(a_entry->id)) != 0
-              || strcmp(svn_fs_fs__id_copy_id(t_entry->id),
-                        svn_fs_fs__id_copy_id(a_entry->id)) != 0)
+          if (strcmp(svn_fs_py__id_node_id(s_entry->id),
+                     svn_fs_py__id_node_id(a_entry->id)) != 0
+              || strcmp(svn_fs_py__id_copy_id(s_entry->id),
+                        svn_fs_py__id_copy_id(a_entry->id)) != 0
+              || strcmp(svn_fs_py__id_node_id(t_entry->id),
+                        svn_fs_py__id_node_id(a_entry->id)) != 0
+              || strcmp(svn_fs_py__id_copy_id(t_entry->id),
+                        svn_fs_py__id_copy_id(a_entry->id)) != 0)
             return conflict_err(conflict_p,
                                 svn_fspath__join(target_path,
                                                  a_entry->name,
@@ -1478,11 +1478,11 @@ merge(svn_stringbuf_t *conflict_p,
           /* Direct modifications were made to the directory
              ANCESTOR-ENTRY in both SOURCE and TARGET.  Recursively
              merge these modifications. */
-          SVN_ERR(svn_fs_fs__dag_get_node(&s_ent_node, fs,
+          SVN_ERR(svn_fs_py__dag_get_node(&s_ent_node, fs,
                                           s_entry->id, iterpool));
-          SVN_ERR(svn_fs_fs__dag_get_node(&t_ent_node, fs,
+          SVN_ERR(svn_fs_py__dag_get_node(&t_ent_node, fs,
                                           t_entry->id, iterpool));
-          SVN_ERR(svn_fs_fs__dag_get_node(&a_ent_node, fs,
+          SVN_ERR(svn_fs_py__dag_get_node(&a_ent_node, fs,
                                           a_entry->id, iterpool));
           new_tpath = svn_fspath__join(target_path, t_entry->name, iterpool);
           SVN_ERR(merge(conflict_p, new_tpath,
@@ -1490,7 +1490,7 @@ merge(svn_stringbuf_t *conflict_p,
                         txn_id,
                         &sub_mergeinfo_increment,
                         iterpool));
-          if (svn_fs_fs__fs_supports_mergeinfo(fs))
+          if (svn_fs_py__fs_supports_mergeinfo(fs))
             mergeinfo_increment += sub_mergeinfo_increment;
         }
 
@@ -1524,29 +1524,29 @@ merge(svn_stringbuf_t *conflict_p,
                                              t_entry->name,
                                              iterpool));
 
-      SVN_ERR(svn_fs_fs__dag_get_node(&s_ent_node, fs,
+      SVN_ERR(svn_fs_py__dag_get_node(&s_ent_node, fs,
                                       s_entry->id, iterpool));
-      if (svn_fs_fs__fs_supports_mergeinfo(fs))
+      if (svn_fs_py__fs_supports_mergeinfo(fs))
         {
           apr_int64_t mergeinfo_s;
-          SVN_ERR(svn_fs_fs__dag_get_mergeinfo_count(&mergeinfo_s,
+          SVN_ERR(svn_fs_py__dag_get_mergeinfo_count(&mergeinfo_s,
                                                      s_ent_node,
                                                      iterpool));
           mergeinfo_increment += mergeinfo_s;
         }
 
-      SVN_ERR(svn_fs_fs__dag_set_entry
+      SVN_ERR(svn_fs_py__dag_set_entry
               (target, s_entry->name, s_entry->id, s_entry->kind,
                txn_id, iterpool));
     }
   svn_pool_destroy(iterpool);
 
-  SVN_ERR(svn_fs_fs__dag_get_predecessor_count(&pred_count, source, pool));
+  SVN_ERR(svn_fs_py__dag_get_predecessor_count(&pred_count, source, pool));
   SVN_ERR(update_ancestry(fs, source_id, target_id, target_path,
                           pred_count, pool));
 
-  if (svn_fs_fs__fs_supports_mergeinfo(fs))
-    SVN_ERR(svn_fs_fs__dag_increment_mergeinfo_count(target,
+  if (svn_fs_py__fs_supports_mergeinfo(fs))
+    SVN_ERR(svn_fs_py__dag_increment_mergeinfo_count(target,
                                                      mergeinfo_increment,
                                                      pool));
 
@@ -1577,16 +1577,16 @@ merge_changes(dag_node_t *ancestor_node,
   svn_fs_t *fs = txn->fs;
   const char *txn_id = txn->id;
 
-  SVN_ERR(svn_fs_fs__dag_txn_root(&txn_root_node, fs, txn_id, pool));
+  SVN_ERR(svn_fs_py__dag_txn_root(&txn_root_node, fs, txn_id, pool));
 
   if (ancestor_node == NULL)
     {
-      SVN_ERR(svn_fs_fs__dag_txn_base_root(&ancestor_node, fs,
+      SVN_ERR(svn_fs_py__dag_txn_base_root(&ancestor_node, fs,
                                            txn_id, pool));
     }
 
-  if (svn_fs_fs__id_eq(svn_fs_fs__dag_get_id(ancestor_node),
-                       svn_fs_fs__dag_get_id(txn_root_node)))
+  if (svn_fs_py__id_eq(svn_fs_py__dag_get_id(ancestor_node),
+                       svn_fs_py__dag_get_id(txn_root_node)))
     {
       /* If no changes have been made in TXN since its current base,
          then it can't conflict with any changes since that base.
@@ -1602,7 +1602,7 @@ merge_changes(dag_node_t *ancestor_node,
 
 
 svn_error_t *
-svn_fs_fs__commit_txn(const char **conflict_p,
+svn_fs_py__commit_txn(const char **conflict_p,
                       svn_revnum_t *new_rev,
                       svn_fs_txn_t *txn,
                       apr_pool_t *pool)
@@ -1674,8 +1674,8 @@ svn_fs_fs__commit_txn(const char **confl
          because new revisions might get committed after we've
          obtained it. */
 
-      SVN_ERR(svn_fs_fs__youngest_rev(&youngish_rev, fs, iterpool));
-      SVN_ERR(svn_fs_fs__revision_root(&youngish_root, fs, youngish_rev,
+      SVN_ERR(svn_fs_py__youngest_rev(&youngish_rev, fs, iterpool));
+      SVN_ERR(svn_fs_py__revision_root(&youngish_root, fs, youngish_rev,
                                        iterpool));
 
       /* Get the dag node for the youngest revision.  Later we'll use
@@ -1701,7 +1701,7 @@ svn_fs_fs__commit_txn(const char **confl
       txn->base_rev = youngish_rev;
 
       /* Try to commit. */
-      err = svn_fs_fs__commit(new_rev, fs, txn, iterpool);
+      err = svn_fs_py__commit(new_rev, fs, txn, iterpool);
       if (err && (err->apr_err == SVN_ERR_FS_TXN_OUT_OF_DATE))
         {
           /* Did someone else finish committing a new revision while we
@@ -1710,7 +1710,7 @@ svn_fs_fs__commit_txn(const char **confl
              commit again.  Or if that's not what happened, then just
              return the error. */
           svn_revnum_t youngest_rev;
-          SVN_ERR(svn_fs_fs__youngest_rev(&youngest_rev, fs, iterpool));
+          SVN_ERR(svn_fs_py__youngest_rev(&youngest_rev, fs, iterpool));
           if (youngest_rev == youngish_rev)
             goto cleanup;
           else
@@ -1729,7 +1729,7 @@ svn_fs_fs__commit_txn(const char **confl
 
  cleanup:
 
-  svn_fs_fs__reset_txn_caches(fs);
+  svn_fs_py__reset_txn_caches(fs);
 
   svn_pool_destroy(iterpool);
   return svn_error_trace(err);
@@ -1786,7 +1786,7 @@ fs_merge(const char **conflict_p,
   SVN_ERR(get_root(&source, source_root, pool));
 
   /* Open a txn for the txn root into which we're merging. */
-  SVN_ERR(svn_fs_fs__open_txn(&txn, ancestor_root->fs, target_root->txn,
+  SVN_ERR(svn_fs_py__open_txn(&txn, ancestor_root->fs, target_root->txn,
                               pool));
 
   /* Merge changes between ANCESTOR and SOURCE into TXN. */
@@ -1802,7 +1802,7 @@ fs_merge(const char **conflict_p,
 }
 
 svn_error_t *
-svn_fs_fs__deltify(svn_fs_t *fs,
+svn_fs_py__deltify(svn_fs_t *fs,
                    svn_revnum_t revision,
                    apr_pool_t *pool)
 {
@@ -1830,7 +1830,7 @@ fs_dir_entries(apr_hash_t **table_p,
 
   /* Get the entries for this path in the caller's pool. */
   SVN_ERR(get_dag(&node, root, path, pool));
-  return svn_fs_fs__dag_dir_entries(table_p, node, pool, pool);
+  return svn_fs_py__dag_dir_entries(table_p, node, pool, pool);
 }
 
 
@@ -1854,7 +1854,7 @@ fs_make_dir(svn_fs_root_t *root,
      that location, or even some child-path; if so, check that we can
      use it. */
   if (root->txn_flags & SVN_FS_TXN_CHECK_LOCKS)
-    SVN_ERR(svn_fs_fs__allow_locked_operation(path, root->fs, TRUE, FALSE,
+    SVN_ERR(svn_fs_py__allow_locked_operation(path, root->fs, TRUE, FALSE,
                                               pool));
 
   /* If there's already a sub-directory by that name, complain.  This
@@ -1864,7 +1864,7 @@ fs_make_dir(svn_fs_root_t *root,
 
   /* Create the subdirectory.  */
   SVN_ERR(make_path_mutable(root, parent_path->parent, path, pool));
-  SVN_ERR(svn_fs_fs__dag_make_dir(&sub_dir,
+  SVN_ERR(svn_fs_py__dag_make_dir(&sub_dir,
                                   parent_path->parent->node,
                                   parent_path_path(parent_path->parent,
                                                    pool),
@@ -1877,7 +1877,7 @@ fs_make_dir(svn_fs_root_t *root,
                              sub_dir, pool));
 
   /* Make a record of this modification in the changes table. */
-  return add_change(root->fs, txn_id, path, svn_fs_fs__dag_get_id(sub_dir),
+  return add_change(root->fs, txn_id, path, svn_fs_py__dag_get_id(sub_dir),
                     svn_fs_path_change_add, FALSE, FALSE, svn_node_dir,
                     SVN_INVALID_REVNUM, NULL, pool);
 }
@@ -1899,7 +1899,7 @@ fs_delete_node(svn_fs_root_t *root,
     return SVN_FS__NOT_TXN(root);
 
   SVN_ERR(open_path(&parent_path, root, path, 0, txn_id, pool));
-  kind = svn_fs_fs__dag_node_kind(parent_path->node);
+  kind = svn_fs_py__dag_node_kind(parent_path->node);
 
   /* We can't remove the root of the filesystem.  */
   if (! parent_path->parent)
@@ -1909,16 +1909,16 @@ fs_delete_node(svn_fs_root_t *root,
   /* Check to see if path (or any child thereof) is locked; if so,
      check that we can use the existing lock(s). */
   if (root->txn_flags & SVN_FS_TXN_CHECK_LOCKS)
-    SVN_ERR(svn_fs_fs__allow_locked_operation(path, root->fs, TRUE, FALSE,
+    SVN_ERR(svn_fs_py__allow_locked_operation(path, root->fs, TRUE, FALSE,
                                               pool));
 
   /* Make the parent directory mutable, and do the deletion.  */
   SVN_ERR(make_path_mutable(root, parent_path->parent, path, pool));
-  if (svn_fs_fs__fs_supports_mergeinfo(root->fs))
-    SVN_ERR(svn_fs_fs__dag_get_mergeinfo_count(&mergeinfo_count,
+  if (svn_fs_py__fs_supports_mergeinfo(root->fs))
+    SVN_ERR(svn_fs_py__dag_get_mergeinfo_count(&mergeinfo_count,
                                                parent_path->node,
                                                pool));
-  SVN_ERR(svn_fs_fs__dag_delete(parent_path->parent->node,
+  SVN_ERR(svn_fs_py__dag_delete(parent_path->parent->node,
                                 parent_path->entry,
                                 txn_id, pool));
 
@@ -1927,14 +1927,14 @@ fs_delete_node(svn_fs_root_t *root,
                                     pool));
 
   /* Update mergeinfo counts for parents */
-  if (svn_fs_fs__fs_supports_mergeinfo(root->fs) && mergeinfo_count > 0)
+  if (svn_fs_py__fs_supports_mergeinfo(root->fs) && mergeinfo_count > 0)
     SVN_ERR(increment_mergeinfo_up_tree(parent_path->parent,
                                         -mergeinfo_count,
                                         pool));
 
   /* Make a record of this modification in the changes table. */
   return add_change(root->fs, txn_id, path,
-                    svn_fs_fs__dag_get_id(parent_path->node),
+                    svn_fs_py__dag_get_id(parent_path->node),
                     svn_fs_path_change_delete, FALSE, FALSE, kind,
                     SVN_INVALID_REVNUM, NULL, pool);
 }
@@ -2005,7 +2005,7 @@ copy_helper(svn_fs_root_t *from_root,
   /* Check to see if path (or any child thereof) is locked; if so,
      check that we can use the existing lock(s). */
   if (to_root->txn_flags & SVN_FS_TXN_CHECK_LOCKS)
-    SVN_ERR(svn_fs_fs__allow_locked_operation(to_path, to_root->fs,
+    SVN_ERR(svn_fs_py__allow_locked_operation(to_path, to_root->fs,
                                               TRUE, FALSE, pool));
 
   /* If the destination node already exists as the same node as the
@@ -2013,8 +2013,8 @@ copy_helper(svn_fs_root_t *from_root,
      happening at all), just do nothing an return successfully,
      proud that you saved yourself from a tiresome task. */
   if (to_parent_path->node &&
-      svn_fs_fs__id_eq(svn_fs_fs__dag_get_id(from_node),
-                       svn_fs_fs__dag_get_id(to_parent_path->node)))
+      svn_fs_py__id_eq(svn_fs_py__dag_get_id(from_node),
+                       svn_fs_py__dag_get_id(to_parent_path->node)))
     return SVN_NO_ERROR;
 
   if (! from_root->is_txn_root)
@@ -2030,8 +2030,8 @@ copy_helper(svn_fs_root_t *from_root,
       if (to_parent_path->node)
         {
           kind = svn_fs_path_change_replace;
-          if (svn_fs_fs__fs_supports_mergeinfo(to_root->fs))
-            SVN_ERR(svn_fs_fs__dag_get_mergeinfo_count(&mergeinfo_start,
+          if (svn_fs_py__fs_supports_mergeinfo(to_root->fs))
+            SVN_ERR(svn_fs_py__dag_get_mergeinfo_count(&mergeinfo_start,
                                                        to_parent_path->node,
                                                        pool));
         }
@@ -2041,8 +2041,8 @@ copy_helper(svn_fs_root_t *from_root,
           mergeinfo_start = 0;
         }
 
-      if (svn_fs_fs__fs_supports_mergeinfo(to_root->fs))
-        SVN_ERR(svn_fs_fs__dag_get_mergeinfo_count(&mergeinfo_end,
+      if (svn_fs_py__fs_supports_mergeinfo(to_root->fs))
+        SVN_ERR(svn_fs_py__dag_get_mergeinfo_count(&mergeinfo_end,
                                                    from_node, pool));
 
       /* Make sure the target node's parents are mutable.  */
@@ -2052,7 +2052,7 @@ copy_helper(svn_fs_root_t *from_root,
       /* Canonicalize the copyfrom path. */
       from_canonpath = svn_fs__canonicalize_abspath(from_path, pool);
 
-      SVN_ERR(svn_fs_fs__dag_copy(to_parent_path->parent->node,
+      SVN_ERR(svn_fs_py__dag_copy(to_parent_path->parent->node,
                                   to_parent_path->entry,
                                   from_node,
                                   preserve_history,
@@ -2065,7 +2065,7 @@ copy_helper(svn_fs_root_t *from_root,
                                           parent_path_path(to_parent_path,
                                                            pool), pool));
 
-      if (svn_fs_fs__fs_supports_mergeinfo(to_root->fs)
+      if (svn_fs_py__fs_supports_mergeinfo(to_root->fs)
           && mergeinfo_start != mergeinfo_end)
         SVN_ERR(increment_mergeinfo_up_tree(to_parent_path->parent,
                                             mergeinfo_end - mergeinfo_start,
@@ -2074,8 +2074,8 @@ copy_helper(svn_fs_root_t *from_root,
       /* Make a record of this modification in the changes table. */
       SVN_ERR(get_dag(&new_node, to_root, to_path, pool));
       SVN_ERR(add_change(to_root->fs, txn_id, to_path,
-                         svn_fs_fs__dag_get_id(new_node), kind, FALSE, FALSE,
-                         svn_fs_fs__dag_node_kind(from_node),
+                         svn_fs_py__dag_get_id(new_node), kind, FALSE, FALSE,
+                         svn_fs_py__dag_node_kind(from_node),
                          from_root->rev, from_canonpath, pool));
     }
   else
@@ -2176,8 +2176,8 @@ fs_copied_from(svn_revnum_t *rev_p,
       /* There is no cached entry, look it up the old-fashioned
          way. */
       SVN_ERR(get_dag(&node, root, path, pool));
-      SVN_ERR(svn_fs_fs__dag_get_copyfrom_rev(&copyfrom_rev, node, pool));
-      SVN_ERR(svn_fs_fs__dag_get_copyfrom_path(&copyfrom_path, node, pool));
+      SVN_ERR(svn_fs_py__dag_get_copyfrom_rev(&copyfrom_rev, node, pool));
+      SVN_ERR(svn_fs_py__dag_get_copyfrom_path(&copyfrom_path, node, pool));
     }
 
   *rev_p  = copyfrom_rev;
@@ -2212,12 +2212,12 @@ fs_make_file(svn_fs_root_t *root,
   /* Check (non-recursively) to see if path is locked;  if so, check
      that we can use it. */
   if (root->txn_flags & SVN_FS_TXN_CHECK_LOCKS)
-    SVN_ERR(svn_fs_fs__allow_locked_operation(path, root->fs, FALSE, FALSE,
+    SVN_ERR(svn_fs_py__allow_locked_operation(path, root->fs, FALSE, FALSE,
                                               pool));
 
   /* Create the file.  */
   SVN_ERR(make_path_mutable(root, parent_path->parent, path, pool));
-  SVN_ERR(svn_fs_fs__dag_make_file(&child,
+  SVN_ERR(svn_fs_py__dag_make_file(&child,
                                    parent_path->parent->node,
                                    parent_path_path(parent_path->parent,
                                                     pool),
@@ -2230,7 +2230,7 @@ fs_make_file(svn_fs_root_t *root,
                              pool));
 
   /* Make a record of this modification in the changes table. */
-  return add_change(root->fs, txn_id, path, svn_fs_fs__dag_get_id(child),
+  return add_change(root->fs, txn_id, path, svn_fs_py__dag_get_id(child),
                     svn_fs_path_change_add, TRUE, FALSE, svn_node_file,
                     SVN_INVALID_REVNUM, NULL, pool);
 }
@@ -2250,7 +2250,7 @@ fs_file_length(svn_filesize_t *length_p,
   SVN_ERR(get_dag(&file, root, path, pool));
 
   /* Now fetch its length */
-  return svn_fs_fs__dag_file_length(length_p, file, pool);
+  return svn_fs_py__dag_file_length(length_p, file, pool);
 }
 
 
@@ -2267,7 +2267,7 @@ fs_file_checksum(svn_checksum_t **checks
   dag_node_t *file;
 
   SVN_ERR(get_dag(&file, root, path, pool));
-  return svn_fs_fs__dag_file_checksum(checksum, file, kind, pool);
+  return svn_fs_py__dag_file_checksum(checksum, file, kind, pool);
 }
 
 
@@ -2288,7 +2288,7 @@ fs_file_contents(svn_stream_t **contents
   SVN_ERR(get_dag(&node, root, path, pool));
 
   /* Then create a readable stream from the dag_node_t. */
-  SVN_ERR(svn_fs_fs__dag_get_contents(&file_stream, node, pool));
+  SVN_ERR(svn_fs_py__dag_get_contents(&file_stream, node, pool));
 
   *contents = file_stream;
   return SVN_NO_ERROR;
@@ -2399,7 +2399,7 @@ window_consumer(svn_txdelta_window_t *wi
          Berkeley DB transaction -- scandalous! */
       SVN_ERR(svn_stream_close(tb->target_stream));
 
-      SVN_ERR(svn_fs_fs__dag_finalize_edits(tb->node, tb->result_checksum,
+      SVN_ERR(svn_fs_py__dag_finalize_edits(tb->node, tb->result_checksum,
                                             tb->pool));
     }
 
@@ -2422,7 +2422,7 @@ apply_textdelta(void *baton, apr_pool_t 
   /* Check (non-recursively) to see if path is locked; if so, check
      that we can use it. */
   if (tb->root->txn_flags & SVN_FS_TXN_CHECK_LOCKS)
-    SVN_ERR(svn_fs_fs__allow_locked_operation(tb->path, tb->root->fs,
+    SVN_ERR(svn_fs_py__allow_locked_operation(tb->path, tb->root->fs,
                                               FALSE, FALSE, pool));
 
   /* Now, make sure this path is mutable. */
@@ -2435,7 +2435,7 @@ apply_textdelta(void *baton, apr_pool_t 
 
       /* Until we finalize the node, its data_key points to the old
          contents, in other words, the base text. */
-      SVN_ERR(svn_fs_fs__dag_file_checksum(&checksum, tb->node,
+      SVN_ERR(svn_fs_py__dag_file_checksum(&checksum, tb->node,
                                            tb->base_checksum->kind, pool));
       if (!svn_checksum_match(tb->base_checksum, checksum))
         return svn_checksum_mismatch_err(tb->base_checksum, checksum, pool,
@@ -2446,11 +2446,11 @@ apply_textdelta(void *baton, apr_pool_t 
   /* Make a readable "source" stream out of the current contents of
      ROOT/PATH; obviously, this must done in the context of a db_txn.
      The stream is returned in tb->source_stream. */
-  SVN_ERR(svn_fs_fs__dag_get_contents(&(tb->source_stream),
+  SVN_ERR(svn_fs_py__dag_get_contents(&(tb->source_stream),
                                       tb->node, tb->pool));
 
   /* Make a writable "target" stream */
-  SVN_ERR(svn_fs_fs__dag_get_edit_stream(&(tb->target_stream), tb->node,
+  SVN_ERR(svn_fs_py__dag_get_edit_stream(&(tb->target_stream), tb->node,
                                          tb->pool));
 
   /* Make a writable "string" stream which writes data to
@@ -2470,7 +2470,7 @@ apply_textdelta(void *baton, apr_pool_t 
 
   /* Make a record of this modification in the changes table. */
   return add_change(tb->root->fs, txn_id, tb->path,
-                    svn_fs_fs__dag_get_id(tb->node),
+                    svn_fs_py__dag_get_id(tb->node),
                     svn_fs_path_change_modify, TRUE, FALSE, svn_node_file,
                     SVN_INVALID_REVNUM, NULL, pool);
 }
@@ -2541,7 +2541,7 @@ struct text_baton_t
 };
 
 
-/* A wrapper around svn_fs_fs__dag_finalize_edits, but for
+/* A wrapper around svn_fs_py__dag_finalize_edits, but for
  * fulltext data, not text deltas.  Closes BATON->file_stream.
  *
  * Note: If you're confused about how this function relates to another
@@ -2575,7 +2575,7 @@ text_stream_closer(void *baton)
   SVN_ERR(svn_stream_close(tb->file_stream));
 
   /* Need to tell fs that we're done sending text */
-  return svn_fs_fs__dag_finalize_edits(tb->node, tb->result_checksum,
+  return svn_fs_py__dag_finalize_edits(tb->node, tb->result_checksum,
                                        tb->pool);
 }
 
@@ -2596,7 +2596,7 @@ apply_text(void *baton, apr_pool_t *pool
   /* Check (non-recursively) to see if path is locked; if so, check
      that we can use it. */
   if (tb->root->txn_flags & SVN_FS_TXN_CHECK_LOCKS)
-    SVN_ERR(svn_fs_fs__allow_locked_operation(tb->path, tb->root->fs,
+    SVN_ERR(svn_fs_py__allow_locked_operation(tb->path, tb->root->fs,
                                               FALSE, FALSE, pool));
 
   /* Now, make sure this path is mutable. */
@@ -2604,7 +2604,7 @@ apply_text(void *baton, apr_pool_t *pool
   tb->node = parent_path->node;
 
   /* Make a writable stream for replacing the file's text. */
-  SVN_ERR(svn_fs_fs__dag_get_edit_stream(&(tb->file_stream), tb->node,
+  SVN_ERR(svn_fs_py__dag_get_edit_stream(&(tb->file_stream), tb->node,
                                          tb->pool));
 
   /* Create a 'returnable' stream which writes to the file_stream. */
@@ -2614,7 +2614,7 @@ apply_text(void *baton, apr_pool_t *pool
 
   /* Make a record of this modification in the changes table. */
   return add_change(tb->root->fs, txn_id, tb->path,
-                    svn_fs_fs__dag_get_id(tb->node),
+                    svn_fs_py__dag_get_id(tb->node),
                     svn_fs_path_change_modify, TRUE, FALSE, svn_node_file,
                     SVN_INVALID_REVNUM, NULL, pool);
 }
@@ -2673,12 +2673,12 @@ fs_contents_changed(svn_boolean_t *chang
   {
     svn_node_kind_t kind;
 
-    SVN_ERR(svn_fs_fs__check_path(&kind, root1, path1, pool));
+    SVN_ERR(svn_fs_py__check_path(&kind, root1, path1, pool));
     if (kind != svn_node_file)
       return svn_error_createf
         (SVN_ERR_FS_GENERAL, NULL, _("'%s' is not a file"), path1);
 
-    SVN_ERR(svn_fs_fs__check_path(&kind, root2, path2, pool));
+    SVN_ERR(svn_fs_py__check_path(&kind, root2, path2, pool));
     if (kind != svn_node_file)
       return svn_error_createf
         (SVN_ERR_FS_GENERAL, NULL, _("'%s' is not a file"), path2);
@@ -2686,7 +2686,7 @@ fs_contents_changed(svn_boolean_t *chang
 
   SVN_ERR(get_dag(&node1, root1, path1, pool));
   SVN_ERR(get_dag(&node2, root2, path2, pool));
-  return svn_fs_fs__dag_things_different(NULL, changed_p,
+  return svn_fs_py__dag_things_different(NULL, changed_p,
                                          node1, node2, pool);
 }
 
@@ -2711,7 +2711,7 @@ fs_get_file_delta_stream(svn_txdelta_str
   SVN_ERR(get_dag(&target_node, target_root, target_path, pool));
 
   /* Create a delta stream that turns the source into the target.  */
-  return svn_fs_fs__dag_get_file_delta_stream(stream_p, source_node,
+  return svn_fs_py__dag_get_file_delta_stream(stream_p, source_node,
                                               target_node, pool);
 }
 
@@ -2729,12 +2729,12 @@ fs_paths_changed(apr_hash_t **changed_pa
                  apr_pool_t *pool)
 {
   if (root->is_txn_root)
-    return svn_fs_fs__txn_changes_fetch(changed_paths_p, root->fs, root->txn,
+    return svn_fs_py__txn_changes_fetch(changed_paths_p, root->fs, root->txn,
                                         pool);
   else
     {
       fs_rev_root_data_t *frd = root->fsap_data;
-      return svn_fs_fs__paths_changed(changed_paths_p, root->fs, root->rev,
+      return svn_fs_py__paths_changed(changed_paths_p, root->fs, root->rev,
                                       frd->copyfrom_cache, pool);
     }
 }
@@ -2785,7 +2785,7 @@ fs_node_history(svn_fs_history_t **histo
     return svn_error_create(SVN_ERR_FS_NOT_REVISION_ROOT, NULL, NULL);
 
   /* And we require that the path exist in the root. */
-  SVN_ERR(svn_fs_fs__check_path(&kind, root, path, pool));
+  SVN_ERR(svn_fs_py__check_path(&kind, root, path, pool));
   if (kind == svn_node_none)
     return SVN_FS__NOT_FOUND(root, path);
 
@@ -2816,7 +2816,7 @@ find_youngest_copyroot(svn_revnum_t *rev
                                    parent_path->parent, pool));
 
   /* Find our copyroot. */
-  SVN_ERR(svn_fs_fs__dag_get_copyroot(&rev_mine, &path_mine,
+  SVN_ERR(svn_fs_py__dag_get_copyroot(&rev_mine, &path_mine,
                                       parent_path->node, pool));
 
   /* If a parent and child were copied to in the same revision, prefer
@@ -2868,15 +2868,15 @@ static svn_error_t *fs_closest_copy(svn_
   /* It is possible that this node was created from scratch at some
      revision between COPY_DST_REV and REV.  Make sure that PATH
      exists as of COPY_DST_REV and is related to this node-rev. */
-  SVN_ERR(svn_fs_fs__revision_root(&copy_dst_root, fs, copy_dst_rev, pool));
-  SVN_ERR(svn_fs_fs__check_path(&kind, copy_dst_root, path, pool));
+  SVN_ERR(svn_fs_py__revision_root(&copy_dst_root, fs, copy_dst_rev, pool));
+  SVN_ERR(svn_fs_py__check_path(&kind, copy_dst_root, path, pool));
   if (kind == svn_node_none)
     return SVN_NO_ERROR;
   SVN_ERR(open_path(&copy_dst_parent_path, copy_dst_root, path,
                     0, NULL, pool));
   copy_dst_node = copy_dst_parent_path->node;
-  if (! svn_fs_fs__id_check_related(svn_fs_fs__dag_get_id(copy_dst_node),
-                                    svn_fs_fs__dag_get_id(parent_path->node)))
+  if (! svn_fs_py__id_check_related(svn_fs_py__dag_get_id(copy_dst_node),
+                                    svn_fs_py__dag_get_id(parent_path->node)))
     return SVN_NO_ERROR;
 
   /* One final check must be done here.  If you copy a directory and
@@ -2893,11 +2893,11 @@ static svn_error_t *fs_closest_copy(svn_
      created-rev is COPY_DST_REV, and that node-revision has no
      predecessors, then there is no relevant closest copy.
   */
-  SVN_ERR(svn_fs_fs__dag_get_revision(&created_rev, copy_dst_node, pool));
+  SVN_ERR(svn_fs_py__dag_get_revision(&created_rev, copy_dst_node, pool));
   if (created_rev == copy_dst_rev)
     {
       const svn_fs_id_t *pred;
-      SVN_ERR(svn_fs_fs__dag_get_predecessor_id(&pred, copy_dst_node, pool));
+      SVN_ERR(svn_fs_py__dag_get_predecessor_id(&pred, copy_dst_node, pool));
       if (! pred)
         return SVN_NO_ERROR;
     }
@@ -2976,7 +2976,7 @@ fs_node_origin_rev(svn_revnum_t *revisio
 
   /* Check the cache first. */
   SVN_ERR(fs_node_id(&given_noderev_id, root, path, pool));
-  node_id = svn_fs_fs__id_node_id(given_noderev_id);
+  node_id = svn_fs_py__id_node_id(given_noderev_id);
 
   /* Is it a brand new uncommitted node? */
   if (node_id[0] == '_')
@@ -2995,13 +2995,13 @@ fs_node_origin_rev(svn_revnum_t *revisio
     }
 
   /* OK, it's an old-style ID?  Maybe it's cached. */
-  SVN_ERR(svn_fs_fs__get_node_origin(&cached_origin_id,
+  SVN_ERR(svn_fs_py__get_node_origin(&cached_origin_id,
                                      fs,
                                      node_id,
                                      pool));
   if (cached_origin_id != NULL)
     {
-      *revision = svn_fs_fs__id_rev(cached_origin_id);
+      *revision = svn_fs_py__id_rev(cached_origin_id);
       return SVN_NO_ERROR;
     }
 
@@ -3032,7 +3032,7 @@ fs_node_origin_rev(svn_revnum_t *revisio
            LASTREV is invalid, but that's cool because CURROOT is
            already initialized.)  */
         if (SVN_IS_VALID_REVNUM(lastrev))
-          SVN_ERR(svn_fs_fs__revision_root(&curroot, fs, lastrev, subpool));
+          SVN_ERR(svn_fs_py__revision_root(&curroot, fs, lastrev, subpool));
 
         /* Find the previous location using the closest-copy shortcut. */
         SVN_ERR(prev_location(&curpath, &currev, fs, curroot, curpath,
@@ -3051,27 +3051,27 @@ fs_node_origin_rev(svn_revnum_t *revisio
     while (pred_id)
       {
         svn_pool_clear(subpool);
-        SVN_ERR(svn_fs_fs__dag_get_node(&node, fs, pred_id, subpool));
+        SVN_ERR(svn_fs_py__dag_get_node(&node, fs, pred_id, subpool));
 
         /* Why not just fetch the predecessor ID in PREDIDPOOL?
-           Because svn_fs_fs__dag_get_predecessor_id() doesn't
+           Because svn_fs_py__dag_get_predecessor_id() doesn't
            necessarily honor the passed-in pool, and might return a
            value cached in the node (which is allocated in
            SUBPOOL... maybe). */
         svn_pool_clear(predidpool);
-        SVN_ERR(svn_fs_fs__dag_get_predecessor_id(&pred_id, node, subpool));
-        pred_id = pred_id ? svn_fs_fs__id_copy(pred_id, predidpool) : NULL;
+        SVN_ERR(svn_fs_py__dag_get_predecessor_id(&pred_id, node, subpool));
+        pred_id = pred_id ? svn_fs_py__id_copy(pred_id, predidpool) : NULL;
       }
 
     /* When we get here, NODE should be the first node-revision in our
        chain. */
-    SVN_ERR(svn_fs_fs__dag_get_revision(revision, node, pool));
+    SVN_ERR(svn_fs_py__dag_get_revision(revision, node, pool));
 
     /* Wow, I don't want to have to do all that again.  Let's cache
        the result. */
     if (node_id[0] != '_')
-      SVN_ERR(svn_fs_fs__set_node_origin(fs, node_id,
-                                         svn_fs_fs__dag_get_id(node), pool));
+      SVN_ERR(svn_fs_py__set_node_origin(fs, node_id,
+                                         svn_fs_py__dag_get_id(node), pool));
 
     svn_pool_destroy(subpool);
     svn_pool_destroy(predidpool);
@@ -3125,14 +3125,14 @@ history_prev(void *baton, apr_pool_t *po
     }
 
   /* Construct a ROOT for the current revision. */
-  SVN_ERR(svn_fs_fs__revision_root(&root, fs, revision, pool));
+  SVN_ERR(svn_fs_py__revision_root(&root, fs, revision, pool));
 
   /* Open PATH/REVISION, and get its node and a bunch of other
      goodies.  */
   SVN_ERR(open_path(&parent_path, root, path, 0, NULL, pool));
   node = parent_path->node;
-  commit_path = svn_fs_fs__dag_get_created_path(node);
-  SVN_ERR(svn_fs_fs__dag_get_revision(&commit_rev, node, pool));
+  commit_path = svn_fs_py__dag_get_created_path(node);
+  SVN_ERR(svn_fs_py__dag_get_revision(&commit_rev, node, pool));
 
   /* The Subversion filesystem is written in such a way that a given
      line of history may have at most one interesting history point
@@ -3160,15 +3160,15 @@ history_prev(void *baton, apr_pool_t *po
              no predecessor, in which case we're all done!). */
           const svn_fs_id_t *pred_id;
 
-          SVN_ERR(svn_fs_fs__dag_get_predecessor_id(&pred_id, node, pool));
+          SVN_ERR(svn_fs_py__dag_get_predecessor_id(&pred_id, node, pool));
           if (! pred_id)
             return SVN_NO_ERROR;
 
           /* Replace NODE and friends with the information from its
              predecessor. */
-          SVN_ERR(svn_fs_fs__dag_get_node(&node, fs, pred_id, pool));
-          commit_path = svn_fs_fs__dag_get_created_path(node);
-          SVN_ERR(svn_fs_fs__dag_get_revision(&commit_rev, node, pool));
+          SVN_ERR(svn_fs_py__dag_get_node(&node, fs, pred_id, pool));
+          commit_path = svn_fs_py__dag_get_created_path(node);
+          SVN_ERR(svn_fs_py__dag_get_revision(&commit_rev, node, pool));
         }
     }
 
@@ -3188,10 +3188,10 @@ history_prev(void *baton, apr_pool_t *po
       const char *copy_dst, *copy_src;
       svn_fs_root_t *copyroot_root;
 
-      SVN_ERR(svn_fs_fs__revision_root(&copyroot_root, fs, copyroot_rev,
+      SVN_ERR(svn_fs_py__revision_root(&copyroot_root, fs, copyroot_rev,
                                        pool));
       SVN_ERR(get_dag(&node, copyroot_root, copyroot_path, pool));
-      copy_dst = svn_fs_fs__dag_get_created_path(node);
+      copy_dst = svn_fs_py__dag_get_created_path(node);
 
       /* If our current path was the very destination of the copy,
          then our new current path will be the copy source.  If our
@@ -3211,8 +3211,8 @@ history_prev(void *baton, apr_pool_t *po
           /* If we get here, then our current path is the destination
              of, or the child of the destination of, a copy.  Fill
              in the return values and get outta here.  */
-          SVN_ERR(svn_fs_fs__dag_get_copyfrom_rev(&src_rev, node, pool));
-          SVN_ERR(svn_fs_fs__dag_get_copyfrom_path(&copy_src, node, pool));
+          SVN_ERR(svn_fs_py__dag_get_copyfrom_rev(&src_rev, node, pool));
+          SVN_ERR(svn_fs_py__dag_get_copyfrom_path(&copy_src, node, pool));
 
           dst_rev = copyroot_rev;
           src_path = svn_fspath__join(copy_src, remainder, pool);
@@ -3354,7 +3354,7 @@ assemble_history(svn_fs_t *fs,
 
 /* Implements svn_fs_validate_mergeinfo. */
 svn_error_t *
-svn_fs_fs__validate_mergeinfo(svn_mergeinfo_t *validated_mergeinfo,
+svn_fs_py__validate_mergeinfo(svn_mergeinfo_t *validated_mergeinfo,
                               svn_fs_t *fs,
                               svn_mergeinfo_t mergeinfo,
                               apr_pool_t *result_pool,
@@ -3436,7 +3436,7 @@ svn_fs_fs__validate_mergeinfo(svn_mergei
       svn_pool_clear(iterpool);
       inner_iterpool = svn_pool_create(iterpool);
 
-      SVN_ERR(svn_fs_fs__revision_root(&mergeinfo_rev_root, fs,
+      SVN_ERR(svn_fs_py__revision_root(&mergeinfo_rev_root, fs,
                                        *rev, iterpool));
 
        for (hi2 = apr_hash_first(iterpool, paths);
@@ -3446,7 +3446,7 @@ svn_fs_fs__validate_mergeinfo(svn_mergei
             const char *path = svn__apr_hash_index_key(hi2);
 
             svn_pool_clear(inner_iterpool);
-            SVN_ERR(svn_fs_fs__check_path(&kind, mergeinfo_rev_root,
+            SVN_ERR(svn_fs_py__check_path(&kind, mergeinfo_rev_root,
                                           path, inner_iterpool));
             if (kind == svn_node_none)
               {
@@ -3496,7 +3496,7 @@ crawl_directory_dag_for_mergeinfo(svn_fs
   apr_hash_index_t *hi;
   apr_pool_t *iterpool = svn_pool_create(scratch_pool);
 
-  SVN_ERR(svn_fs_fs__dag_dir_entries(&entries, dir_dag,
+  SVN_ERR(svn_fs_py__dag_dir_entries(&entries, dir_dag,
                                      scratch_pool, scratch_pool));
 
   for (hi = apr_hash_first(scratch_pool, entries);
@@ -3513,8 +3513,8 @@ crawl_directory_dag_for_mergeinfo(svn_fs
       kid_path = svn_fspath__join(this_path, dirent->name, iterpool);
       SVN_ERR(get_dag(&kid_dag, root, kid_path, iterpool));
 
-      SVN_ERR(svn_fs_fs__dag_has_mergeinfo(&has_mergeinfo, kid_dag, iterpool));
-      SVN_ERR(svn_fs_fs__dag_has_descendants_with_mergeinfo(&go_down, kid_dag,
+      SVN_ERR(svn_fs_py__dag_has_mergeinfo(&has_mergeinfo, kid_dag, iterpool));
+      SVN_ERR(svn_fs_py__dag_has_descendants_with_mergeinfo(&go_down, kid_dag,
                                                             iterpool));
 
       if (has_mergeinfo)
@@ -3525,12 +3525,12 @@ crawl_directory_dag_for_mergeinfo(svn_fs
           svn_string_t *mergeinfo_string;
           svn_error_t *err;
 
-          SVN_ERR(svn_fs_fs__dag_get_proplist(&proplist, kid_dag, iterpool));
+          SVN_ERR(svn_fs_py__dag_get_proplist(&proplist, kid_dag, iterpool));
           mergeinfo_string = apr_hash_get(proplist, SVN_PROP_MERGEINFO,
                                           APR_HASH_KEY_STRING);
           if (!mergeinfo_string)
             {
-              svn_string_t *idstr = svn_fs_fs__id_unparse(dirent->id, iterpool);
+              svn_string_t *idstr = svn_fs_py__id_unparse(dirent->id, iterpool);
               return svn_error_createf
                 (SVN_ERR_FS_CORRUPT, NULL,
                  _("Node-revision #'%s' claims to have mergeinfo but doesn't"),
@@ -3614,7 +3614,7 @@ get_mergeinfo_for_path(svn_mergeinfo_t *
 
       svn_pool_clear(iterpool);
 
-      SVN_ERR(svn_fs_fs__dag_has_mergeinfo(&has_mergeinfo,
+      SVN_ERR(svn_fs_py__dag_has_mergeinfo(&has_mergeinfo,
                                            nearest_ancestor->node, iterpool));
       if (has_mergeinfo)
         break;
@@ -3636,7 +3636,7 @@ get_mergeinfo_for_path(svn_mergeinfo_t *
         }
     }
 
-  SVN_ERR(svn_fs_fs__dag_get_proplist(&proplist, nearest_ancestor->node,
+  SVN_ERR(svn_fs_py__dag_get_proplist(&proplist, nearest_ancestor->node,
                                       scratch_pool));
   mergeinfo_string = apr_hash_get(proplist, SVN_PROP_MERGEINFO,
                                   APR_HASH_KEY_STRING);
@@ -3686,7 +3686,7 @@ get_mergeinfo_for_path(svn_mergeinfo_t *
                                              result_pool));
 
       if (validate_inherited_mergeinfo)
-        SVN_ERR(svn_fs_fs__validate_mergeinfo(mergeinfo, rev_root->fs,
+        SVN_ERR(svn_fs_py__validate_mergeinfo(mergeinfo, rev_root->fs,
                                               *mergeinfo, result_pool,
                                               iterpool));
     }
@@ -3709,7 +3709,7 @@ add_descendant_mergeinfo(svn_mergeinfo_c
   svn_boolean_t go_down;
 
   SVN_ERR(get_dag(&this_dag, root, path, scratch_pool));
-  SVN_ERR(svn_fs_fs__dag_has_descendants_with_mergeinfo(&go_down,
+  SVN_ERR(svn_fs_py__dag_has_descendants_with_mergeinfo(&go_down,
                                                         this_dag,
                                                         scratch_pool));
   if (go_down)
@@ -3798,7 +3798,7 @@ fs_get_mergeinfo(svn_mergeinfo_catalog_t
     return svn_error_create(SVN_ERR_FS_NOT_REVISION_ROOT, NULL, NULL);
 
   /* We have to actually be able to find the mergeinfo metadata! */
-  if (! svn_fs_fs__fs_supports_mergeinfo(root->fs))
+  if (! svn_fs_py__fs_supports_mergeinfo(root->fs))
     return svn_error_createf
       (SVN_ERR_UNSUPPORTED_FEATURE, NULL,
        _("Querying mergeinfo requires version %d of the FSFS filesystem "
@@ -3815,10 +3815,10 @@ fs_get_mergeinfo(svn_mergeinfo_catalog_t
 /* The vtable associated with root objects. */
 static root_vtable_t root_vtable = {
   fs_paths_changed,
-  svn_fs_fs__check_path,
+  svn_fs_py__check_path,
   fs_node_history,
   fs_node_id,
-  svn_fs_fs__node_created_rev,
+  svn_fs_py__node_created_rev,
   fs_node_origin_rev,
   fs_node_created_path,
   fs_delete_node,
@@ -3907,8 +3907,8 @@ make_txn_root(svn_fs_root_t **root_p,
      Note that since dag_node_cache_invalidate uses svn_cache__iter,
      this *cannot* be a memcache-based cache.  */
   SVN_ERR(svn_cache__create_inprocess(&(frd->txn_node_cache),
-                                      svn_fs_fs__dag_serialize,
-                                      svn_fs_fs__dag_deserialize,
+                                      svn_fs_py__dag_serialize,
+                                      svn_fs_py__dag_deserialize,
                                       APR_HASH_KEY_STRING,
                                       32, 20, FALSE,
                                       apr_pstrcat(pool, txn, ":TXN", (char *)NULL),
@@ -3918,7 +3918,7 @@ make_txn_root(svn_fs_root_t **root_p,
 
      Note that we cannot put those caches in frd because that content
      fs root object is not available where we would need it. */
-  SVN_ERR(svn_fs_fs__initialize_txn_caches(fs, txn, pool));
+  SVN_ERR(svn_fs_py__initialize_txn_caches(fs, txn, pool));
 
   root->fsap_data = frd;
 

Modified: subversion/branches/fs-py/subversion/libsvn_fs_py/tree.h
URL: http://svn.apache.org/viewvc/subversion/branches/fs-py/subversion/libsvn_fs_py/tree.h?rev=1154262&r1=1154224&r2=1154262&view=diff
==============================================================================
--- subversion/branches/fs-py/subversion/libsvn_fs_py/tree.h (original)
+++ subversion/branches/fs-py/subversion/libsvn_fs_py/tree.h Fri Aug  5 15:20:23 2011
@@ -31,11 +31,11 @@ extern "C" {
 
 /* 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_error_t *svn_fs_py__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,
+svn_error_t *svn_fs_py__deltify(svn_fs_t *fs, svn_revnum_t rev,
                                 apr_pool_t *pool);
 
 /* Commit the transaction TXN as a new revision.  Return the new
@@ -43,20 +43,20 @@ svn_error_t *svn_fs_fs__deltify(svn_fs_t
    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_error_t *svn_fs_py__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,
+svn_error_t *svn_fs_py__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_py__check_path(svn_node_kind_t *kind_p,
                       svn_fs_root_t *root,
                       const char *path,
                       apr_pool_t *pool);
@@ -66,14 +66,14 @@ svn_fs_fs__check_path(svn_node_kind_t *k
    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_py__node_created_rev(svn_revnum_t *revision,
                             svn_fs_root_t *root,
                             const char *path,
                             apr_pool_t *pool);
 
 /* Implements svn_fs_validate_mergeinfo. */
 svn_error_t *
-svn_fs_fs__validate_mergeinfo(svn_mergeinfo_t *validated_mergeinfo,
+svn_fs_py__validate_mergeinfo(svn_mergeinfo_t *validated_mergeinfo,
                               svn_fs_t *fs,
                               svn_mergeinfo_t mergeinfo,
                               apr_pool_t *result_pool,



Mime
View raw message