subversion-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From hwri...@apache.org
Subject svn commit: r1154262 [1/4] - in /subversion/branches/fs-py: ./ subversion/libsvn_fs_py/
Date Fri, 05 Aug 2011 15:20:24 GMT
Author: hwright
Date: Fri Aug  5 15:20:23 2011
New Revision: 1154262

URL: http://svn.apache.org/viewvc?rev=1154262&view=rev
Log:
On the fs-py branch:
Add libsvn_fs_py as a copy of libsvn_fs_fs, and link in the Python interpreter.

* Makefile.in
  (SVN_FS_LIB_LINK): Add the SWIG_PY_LIBS to pull in the Python libs.
  (INCLUDES): Add the SWIG_PY_INCLUDES to access Python.

* configure.ac
  (SVN_LIBSVN_FS_LINKS_FS_PY): New section to include the appropriate flags.

* build.conf
  (libsvn_fs_py): New section.
  (fs-libs): Add the new fs lib.

* subversion/libsvn_fs_py:
  New, copied from libsvn_fs_fs.  For all funtions with the svn_fs_fs__ prefix,
  rename with svn_fs_py__.

Added:
    subversion/branches/fs-py/subversion/libsvn_fs_py/
      - copied from r1154224, subversion/branches/fs-py/subversion/libsvn_fs_fs/
Modified:
    subversion/branches/fs-py/Makefile.in
    subversion/branches/fs-py/build.conf
    subversion/branches/fs-py/configure.ac
    subversion/branches/fs-py/subversion/libsvn_fs_py/caching.c
    subversion/branches/fs-py/subversion/libsvn_fs_py/dag.c
    subversion/branches/fs-py/subversion/libsvn_fs_py/dag.h
    subversion/branches/fs-py/subversion/libsvn_fs_py/fs.c
    subversion/branches/fs-py/subversion/libsvn_fs_py/fs_fs.c
    subversion/branches/fs-py/subversion/libsvn_fs_py/fs_fs.h
    subversion/branches/fs-py/subversion/libsvn_fs_py/id.c
    subversion/branches/fs-py/subversion/libsvn_fs_py/id.h
    subversion/branches/fs-py/subversion/libsvn_fs_py/key-gen.c
    subversion/branches/fs-py/subversion/libsvn_fs_py/key-gen.h
    subversion/branches/fs-py/subversion/libsvn_fs_py/lock.c
    subversion/branches/fs-py/subversion/libsvn_fs_py/lock.h
    subversion/branches/fs-py/subversion/libsvn_fs_py/rep-cache.c
    subversion/branches/fs-py/subversion/libsvn_fs_py/rep-cache.h
    subversion/branches/fs-py/subversion/libsvn_fs_py/temp_serializer.c
    subversion/branches/fs-py/subversion/libsvn_fs_py/temp_serializer.h
    subversion/branches/fs-py/subversion/libsvn_fs_py/tree.c
    subversion/branches/fs-py/subversion/libsvn_fs_py/tree.h

Modified: subversion/branches/fs-py/Makefile.in
URL: http://svn.apache.org/viewvc/subversion/branches/fs-py/Makefile.in?rev=1154262&r1=1154261&r2=1154262&view=diff
==============================================================================
--- subversion/branches/fs-py/Makefile.in (original)
+++ subversion/branches/fs-py/Makefile.in Fri Aug  5 15:20:23 2011
@@ -33,7 +33,7 @@ SVN_RA_LIB_LINK = @SVN_RA_LIB_LINK@
 
 SVN_FS_LIB_DEPS = @SVN_FS_LIB_DEPS@
 SVN_FS_LIB_INSTALL_DEPS = @SVN_FS_LIB_INSTALL_DEPS@
-SVN_FS_LIB_LINK = @SVN_FS_LIB_LINK@
+SVN_FS_LIB_LINK = @SVN_FS_LIB_LINK@ @SWIG_PY_LIBS@
 
 SWIG_SRC_DIR = $(abs_srcdir)/subversion/bindings/swig
 SWIG_BUILD_DIR = $(abs_builddir)/subversion/bindings/swig
@@ -127,7 +127,7 @@ INCLUDES = -I$(top_srcdir)/subversion/in
            @SVN_DB_INCLUDES@ @SVN_GNOME_KEYRING_INCLUDES@ @SVN_GSSAPI_INCLUDES@ \
            @SVN_KWALLET_INCLUDES@ @SVN_MAGIC_INCLUDES@ @SVN_NEON_INCLUDES@ \
            @SVN_SASL_INCLUDES@ @SVN_SERF_INCLUDES@ @SVN_SQLITE_INCLUDES@ \
-           @SVN_XML_INCLUDES@ @SVN_ZLIB_INCLUDES@
+           @SVN_XML_INCLUDES@ @SVN_ZLIB_INCLUDES@ @SWIG_PY_INCLUDES@
 
 APACHE_INCLUDES = @APACHE_INCLUDES@
 APACHE_LIBEXECDIR = $(DESTDIR)@APACHE_LIBEXECDIR@

Modified: subversion/branches/fs-py/build.conf
URL: http://svn.apache.org/viewvc/subversion/branches/fs-py/build.conf?rev=1154262&r1=1154261&r2=1154262&view=diff
==============================================================================
--- subversion/branches/fs-py/build.conf (original)
+++ subversion/branches/fs-py/build.conf Fri Aug  5 15:20:23 2011
@@ -41,6 +41,7 @@ private-includes =
 private-built-includes =
         subversion/svn_private_config.h
         subversion/libsvn_fs_fs/rep-cache-db.h
+        subversion/libsvn_fs_py/rep-cache-db.h
         subversion/libsvn_wc/wc-metadata.h
         subversion/libsvn_wc/wc-queries.h
         subversion/libsvn_wc/wc-checks.h
@@ -245,6 +246,13 @@ install = fsmod-lib
 libs = libsvn_delta libsvn_subr aprutil apriconv apr libsvn_fs_util
 msvc-static = yes
 
+[libsvn_fs_py]
+type = fs-module
+path = subversion/libsvn_fs_py
+install = fsmod-lib
+libs = libsvn_delta libsvn_subr aprutil apriconv apr libsvn_fs_util
+msvc-static = yes
+
 # Low-level grab bag of utilities
 [libsvn_fs_util]
 type = lib
@@ -1089,7 +1097,7 @@ libs = libsvn_ra_neon libsvn_ra_serf lib
 [fs-libs]
 type = lib
 external-lib = $(SVN_FS_LIB_LINK)
-libs = libsvn_fs_base libsvn_fs_fs
+libs = libsvn_fs_base libsvn_fs_fs libsvn_fs_py
 
 [__ALL__]
 type = project

Modified: subversion/branches/fs-py/configure.ac
URL: http://svn.apache.org/viewvc/subversion/branches/fs-py/configure.ac?rev=1154262&r1=1154261&r2=1154262&view=diff
==============================================================================
--- subversion/branches/fs-py/configure.ac (original)
+++ subversion/branches/fs-py/configure.ac Fri Aug  5 15:20:23 2011
@@ -1229,6 +1229,12 @@ if test "$svn_enable_shared" = "no" || t
   svn_fs_lib_install_deps="install-fsmod-lib"
   svn_fs_lib_link="\$(FS_FS_LINK)"
 
+  AC_DEFINE(SVN_LIBSVN_FS_LINKS_FS_PY, 1,
+      [Defined if libsvn_fs should link against libsvn_fs_py])
+  svn_fs_lib_deps="$svn_fs_lib_deps \$(FS_PY_DEPS)"
+  svn_fs_lib_install_deps="$svn_fs_lib_install_deps install-fspy-lib"
+  svn_fs_lib_link="$svn_fs_lib_link \$(FS_PY_LINK)"
+
   if test "$svn_lib_berkeley_db" = "yes"; then
   AC_DEFINE(SVN_LIBSVN_FS_LINKS_FS_BASE, 1,
       [Defined if libsvn_fs should link against libsvn_fs_base])

Modified: subversion/branches/fs-py/subversion/libsvn_fs_py/caching.c
URL: http://svn.apache.org/viewvc/subversion/branches/fs-py/subversion/libsvn_fs_py/caching.c?rev=1154262&r1=1154224&r2=1154262&view=diff
==============================================================================
--- subversion/branches/fs-py/subversion/libsvn_fs_py/caching.c (original)
+++ subversion/branches/fs-py/subversion/libsvn_fs_py/caching.c Fri Aug  5 15:20:23 2011
@@ -236,7 +236,7 @@ create_cache(svn_cache__t **cache_p,
 }
 
 svn_error_t *
-svn_fs_fs__initialize_caches(svn_fs_t *fs,
+svn_fs_py__initialize_caches(svn_fs_t *fs,
                              apr_pool_t *pool)
 {
   fs_fs_data_t *ffd = fs->fsap_data;
@@ -272,8 +272,8 @@ svn_fs_fs__initialize_caches(svn_fs_t *f
                        NULL,
                        membuffer,
                        1, 100,
-                       svn_fs_fs__serialize_id,
-                       svn_fs_fs__deserialize_id,
+                       svn_fs_py__serialize_id,
+                       svn_fs_py__deserialize_id,
                        sizeof(svn_revnum_t),
                        apr_pstrcat(pool, prefix, "RRI", (char *)NULL),
                        fs->pool));
@@ -286,8 +286,8 @@ svn_fs_fs__initialize_caches(svn_fs_t *f
                        NULL,
                        membuffer,
                        1024, 16,
-                       svn_fs_fs__dag_serialize,
-                       svn_fs_fs__dag_deserialize,
+                       svn_fs_py__dag_serialize,
+                       svn_fs_py__dag_deserialize,
                        APR_HASH_KEY_STRING,
                        apr_pstrcat(pool, prefix, "DAG", (char *)NULL),
                        fs->pool));
@@ -299,8 +299,8 @@ svn_fs_fs__initialize_caches(svn_fs_t *f
                        NULL,
                        membuffer,
                        1024, 8,
-                       svn_fs_fs__serialize_dir_entries,
-                       svn_fs_fs__deserialize_dir_entries,
+                       svn_fs_py__serialize_dir_entries,
+                       svn_fs_py__deserialize_dir_entries,
                        APR_HASH_KEY_STRING,
                        apr_pstrcat(pool, prefix, "DIR", (char *)NULL),
                        fs->pool));
@@ -313,8 +313,8 @@ svn_fs_fs__initialize_caches(svn_fs_t *f
                        NULL,
                        membuffer,
                        32, 1,
-                       svn_fs_fs__serialize_manifest,
-                       svn_fs_fs__deserialize_manifest,
+                       svn_fs_py__serialize_manifest,
+                       svn_fs_py__deserialize_manifest,
                        sizeof(svn_revnum_t),
                        apr_pstrcat(pool, prefix, "PACK-MANIFEST",
                                    (char *)NULL),
@@ -346,8 +346,8 @@ svn_fs_fs__initialize_caches(svn_fs_t *f
                            NULL,
                            membuffer,
                            0, 0, /* Do not use inprocess cache */
-                           svn_fs_fs__serialize_txdelta_window,
-                           svn_fs_fs__deserialize_txdelta_window,
+                           svn_fs_py__serialize_txdelta_window,
+                           svn_fs_py__deserialize_txdelta_window,
                            APR_HASH_KEY_STRING,
                            apr_pstrcat(pool, prefix, "TXDELTA_WINDOW",
                                        (char *)NULL),
@@ -365,8 +365,8 @@ svn_fs_fs__initialize_caches(svn_fs_t *f
                        NULL,
                        membuffer,
                        0, 0, /* Do not use inprocess cache */
-                       svn_fs_fs__serialize_node_revision,
-                       svn_fs_fs__deserialize_node_revision,
+                       svn_fs_py__serialize_node_revision,
+                       svn_fs_py__deserialize_node_revision,
                        APR_HASH_KEY_STRING,
                        apr_pstrcat(pool, prefix, "NODEREVS", (char *)NULL),
                        fs->pool));
@@ -396,7 +396,7 @@ remove_txn_cache(void *baton_void)
   /* be careful not to hurt performance by resetting newer txn's caches. */
   if (*baton->to_reset == baton->txn_cache)
     {
-     /* This is equivalent to calling svn_fs_fs__reset_txn_caches(). */
+     /* This is equivalent to calling svn_fs_py__reset_txn_caches(). */
       *baton->to_reset  = NULL;
     }
 
@@ -428,7 +428,7 @@ init_txn_callbacks(svn_cache__t **cache,
 }
 
 svn_error_t *
-svn_fs_fs__initialize_txn_caches(svn_fs_t *fs,
+svn_fs_py__initialize_txn_caches(svn_fs_t *fs,
                                  const char *txn_id,
                                  apr_pool_t *pool)
 {
@@ -461,8 +461,8 @@ svn_fs_fs__initialize_txn_caches(svn_fs_
                        NULL,
                        svn_cache__get_global_membuffer_cache(),
                        1024, 8,
-                       svn_fs_fs__serialize_dir_entries,
-                       svn_fs_fs__deserialize_dir_entries,
+                       svn_fs_py__serialize_dir_entries,
+                       svn_fs_py__deserialize_dir_entries,
                        APR_HASH_KEY_STRING,
                        apr_pstrcat(pool, prefix, "TXNDIR",
                                    (char *)NULL),
@@ -475,7 +475,7 @@ svn_fs_fs__initialize_txn_caches(svn_fs_
 }
 
 void
-svn_fs_fs__reset_txn_caches(svn_fs_t *fs)
+svn_fs_py__reset_txn_caches(svn_fs_t *fs)
 {
   /* we can always just reset the caches. This may degrade performance but
    * can never cause in incorrect behavior. */

Modified: subversion/branches/fs-py/subversion/libsvn_fs_py/dag.c
URL: http://svn.apache.org/viewvc/subversion/branches/fs-py/subversion/libsvn_fs_py/dag.c?rev=1154262&r1=1154224&r2=1154262&view=diff
==============================================================================
--- subversion/branches/fs-py/subversion/libsvn_fs_py/dag.c (original)
+++ subversion/branches/fs-py/subversion/libsvn_fs_py/dag.c Fri Aug  5 15:20:23 2011
@@ -77,34 +77,34 @@ struct dag_node_t
 
 
 /* Trivial helper/accessor functions. */
-svn_node_kind_t svn_fs_fs__dag_node_kind(dag_node_t *node)
+svn_node_kind_t svn_fs_py__dag_node_kind(dag_node_t *node)
 {
   return node->kind;
 }
 
 
 const svn_fs_id_t *
-svn_fs_fs__dag_get_id(const dag_node_t *node)
+svn_fs_py__dag_get_id(const dag_node_t *node)
 {
   return node->id;
 }
 
 
 const char *
-svn_fs_fs__dag_get_created_path(dag_node_t *node)
+svn_fs_py__dag_get_created_path(dag_node_t *node)
 {
   return node->created_path;
 }
 
 
 svn_fs_t *
-svn_fs_fs__dag_get_fs(dag_node_t *node)
+svn_fs_py__dag_get_fs(dag_node_t *node)
 {
   return node->fs;
 }
 
 void
-svn_fs_fs__dag_set_fs(dag_node_t *node, svn_fs_t *fs)
+svn_fs_py__dag_set_fs(dag_node_t *node, svn_fs_t *fs)
 {
   node->fs = fs;
 }
@@ -119,15 +119,15 @@ copy_node_revision(node_revision_t *node
   node_revision_t *nr = apr_pcalloc(pool, sizeof(*nr));
   nr->kind = noderev->kind;
   if (noderev->predecessor_id)
-    nr->predecessor_id = svn_fs_fs__id_copy(noderev->predecessor_id, pool);
+    nr->predecessor_id = svn_fs_py__id_copy(noderev->predecessor_id, pool);
   nr->predecessor_count = noderev->predecessor_count;
   if (noderev->copyfrom_path)
     nr->copyfrom_path = apr_pstrdup(pool, noderev->copyfrom_path);
   nr->copyfrom_rev = noderev->copyfrom_rev;
   nr->copyroot_path = apr_pstrdup(pool, noderev->copyroot_path);
   nr->copyroot_rev = noderev->copyroot_rev;
-  nr->data_rep = svn_fs_fs__rep_copy(noderev->data_rep, pool);
-  nr->prop_rep = svn_fs_fs__rep_copy(noderev->prop_rep, pool);
+  nr->data_rep = svn_fs_py__rep_copy(noderev->data_rep, pool);
+  nr->prop_rep = svn_fs_py__rep_copy(noderev->prop_rep, pool);
   nr->mergeinfo_count = noderev->mergeinfo_count;
   nr->has_mergeinfo = noderev->has_mergeinfo;
 
@@ -158,7 +158,7 @@ get_node_revision(node_revision_t **node
   /* If we've already got a copy, there's no need to read it in.  */
   if (! node->node_revision)
     {
-      SVN_ERR(svn_fs_fs__get_node_revision(&noderev, node->fs,
+      SVN_ERR(svn_fs_py__get_node_revision(&noderev, node->fs,
                                            node->id, pool));
       node->node_revision = noderev;
     }
@@ -169,14 +169,14 @@ get_node_revision(node_revision_t **node
 }
 
 
-svn_boolean_t svn_fs_fs__dag_check_mutable(const dag_node_t *node)
+svn_boolean_t svn_fs_py__dag_check_mutable(const dag_node_t *node)
 {
-  return (svn_fs_fs__id_txn_id(svn_fs_fs__dag_get_id(node)) != NULL);
+  return (svn_fs_py__id_txn_id(svn_fs_py__dag_get_id(node)) != NULL);
 }
 
 
 svn_error_t *
-svn_fs_fs__dag_get_node(dag_node_t **node,
+svn_fs_py__dag_get_node(dag_node_t **node,
                         svn_fs_t *fs,
                         const svn_fs_id_t *id,
                         apr_pool_t *pool)
@@ -187,7 +187,7 @@ svn_fs_fs__dag_get_node(dag_node_t **nod
   /* Construct the node. */
   new_node = apr_pcalloc(pool, sizeof(*new_node));
   new_node->fs = fs;
-  new_node->id = svn_fs_fs__id_copy(id, pool);
+  new_node->id = svn_fs_py__id_copy(id, pool);
 
   /* Grab the contents so we can inspect the node's kind and created path. */
   SVN_ERR(get_node_revision(&noderev, new_node, pool));
@@ -208,7 +208,7 @@ svn_fs_fs__dag_get_node(dag_node_t **nod
 
 
 svn_error_t *
-svn_fs_fs__dag_get_revision(svn_revnum_t *rev,
+svn_fs_py__dag_get_revision(svn_revnum_t *rev,
                             dag_node_t *node,
                             apr_pool_t *pool)
 {
@@ -219,14 +219,14 @@ svn_fs_fs__dag_get_revision(svn_revnum_t
     ? node->fresh_root_predecessor_id : node->id;
 
   /* Look up the committed revision from the Node-ID. */
-  *rev = svn_fs_fs__id_rev(correct_id);
+  *rev = svn_fs_py__id_rev(correct_id);
 
   return SVN_NO_ERROR;
 }
 
 
 svn_error_t *
-svn_fs_fs__dag_get_predecessor_id(const svn_fs_id_t **id_p,
+svn_fs_py__dag_get_predecessor_id(const svn_fs_id_t **id_p,
                                   dag_node_t *node,
                                   apr_pool_t *pool)
 {
@@ -239,7 +239,7 @@ svn_fs_fs__dag_get_predecessor_id(const 
 
 
 svn_error_t *
-svn_fs_fs__dag_get_predecessor_count(int *count,
+svn_fs_py__dag_get_predecessor_count(int *count,
                                      dag_node_t *node,
                                      apr_pool_t *pool)
 {
@@ -251,7 +251,7 @@ svn_fs_fs__dag_get_predecessor_count(int
 }
 
 svn_error_t *
-svn_fs_fs__dag_get_mergeinfo_count(apr_int64_t *count,
+svn_fs_py__dag_get_mergeinfo_count(apr_int64_t *count,
                                    dag_node_t *node,
                                    apr_pool_t *pool)
 {
@@ -263,7 +263,7 @@ svn_fs_fs__dag_get_mergeinfo_count(apr_i
 }
 
 svn_error_t *
-svn_fs_fs__dag_has_mergeinfo(svn_boolean_t *has_mergeinfo,
+svn_fs_py__dag_has_mergeinfo(svn_boolean_t *has_mergeinfo,
                              dag_node_t *node,
                              apr_pool_t *pool)
 {
@@ -275,7 +275,7 @@ svn_fs_fs__dag_has_mergeinfo(svn_boolean
 }
 
 svn_error_t *
-svn_fs_fs__dag_has_descendants_with_mergeinfo(svn_boolean_t *do_they,
+svn_fs_py__dag_has_descendants_with_mergeinfo(svn_boolean_t *do_they,
                                               dag_node_t *node,
                                               apr_pool_t *pool)
 {
@@ -314,8 +314,8 @@ dir_entry_id_from_node(const svn_fs_id_t
   svn_fs_dirent_t *dirent;
   apr_pool_t *subpool = svn_pool_create(pool);
 
-  SVN_ERR(svn_fs_fs__dag_dir_entry(&dirent, parent, name, subpool, pool));
-  *id_p = dirent ? svn_fs_fs__id_copy(dirent->id, pool) : NULL;
+  SVN_ERR(svn_fs_py__dag_dir_entry(&dirent, parent, name, subpool, pool));
+  *id_p = dirent ? svn_fs_py__id_copy(dirent->id, pool) : NULL;
 
   svn_pool_destroy(subpool);
 
@@ -345,7 +345,7 @@ set_entry(dag_node_t *parent,
   SVN_ERR(get_node_revision(&parent_noderev, parent, pool));
 
   /* Set the new entry. */
-  return svn_fs_fs__set_entry(parent->fs, txn_id, parent_noderev, name, id,
+  return svn_fs_py__set_entry(parent->fs, txn_id, parent_noderev, name, id,
                               kind, pool);
 }
 
@@ -382,7 +382,7 @@ make_entry(dag_node_t **child_p,
        _("Attempted to create entry in non-directory parent"));
 
   /* Check that the parent is mutable. */
-  if (! svn_fs_fs__dag_check_mutable(parent))
+  if (! svn_fs_py__dag_check_mutable(parent))
     return svn_error_createf
       (SVN_ERR_FS_NOT_MUTABLE, NULL,
        _("Attempted to clone child of non-mutable node"));
@@ -399,25 +399,25 @@ make_entry(dag_node_t **child_p,
   new_noderev.copyfrom_rev = SVN_INVALID_REVNUM;
   new_noderev.copyfrom_path = NULL;
 
-  SVN_ERR(svn_fs_fs__create_node
-          (&new_node_id, svn_fs_fs__dag_get_fs(parent), &new_noderev,
-           svn_fs_fs__id_copy_id(svn_fs_fs__dag_get_id(parent)),
+  SVN_ERR(svn_fs_py__create_node
+          (&new_node_id, svn_fs_py__dag_get_fs(parent), &new_noderev,
+           svn_fs_py__id_copy_id(svn_fs_py__dag_get_id(parent)),
            txn_id, pool));
 
   /* Create a new dag_node_t for our new node */
-  SVN_ERR(svn_fs_fs__dag_get_node(child_p, svn_fs_fs__dag_get_fs(parent),
+  SVN_ERR(svn_fs_py__dag_get_node(child_p, svn_fs_py__dag_get_fs(parent),
                                   new_node_id, pool));
 
   /* We can safely call set_entry because we already know that
      PARENT is mutable, and we just created CHILD, so we know it has
      no ancestors (therefore, PARENT cannot be an ancestor of CHILD) */
-  return set_entry(parent, name, svn_fs_fs__dag_get_id(*child_p),
+  return set_entry(parent, name, svn_fs_py__dag_get_id(*child_p),
                    new_noderev.kind, txn_id, pool);
 }
 
 
 svn_error_t *
-svn_fs_fs__dag_dir_entries(apr_hash_t **entries,
+svn_fs_py__dag_dir_entries(apr_hash_t **entries,
                            dag_node_t *node,
                            apr_pool_t *pool,
                            apr_pool_t *node_pool)
@@ -430,11 +430,11 @@ svn_fs_fs__dag_dir_entries(apr_hash_t **
     return svn_error_create(SVN_ERR_FS_NOT_DIRECTORY, NULL,
                             _("Can't get entries of non-directory"));
 
-  return svn_fs_fs__rep_contents_dir(entries, node->fs, noderev, pool);
+  return svn_fs_py__rep_contents_dir(entries, node->fs, noderev, pool);
 }
 
 svn_error_t *
-svn_fs_fs__dag_dir_entry(svn_fs_dirent_t **dirent,
+svn_fs_py__dag_dir_entry(svn_fs_dirent_t **dirent,
                          dag_node_t *node,
                          const char* name,
                          apr_pool_t *pool,
@@ -448,13 +448,13 @@ svn_fs_fs__dag_dir_entry(svn_fs_dirent_t
                             _("Can't get entries of non-directory"));
 
   /* Get a dirent hash for this directory. */
-  return svn_fs_fs__rep_contents_dir_entry(dirent, node->fs,
+  return svn_fs_py__rep_contents_dir_entry(dirent, node->fs,
                                            noderev, name, pool);
 }
 
 
 svn_error_t *
-svn_fs_fs__dag_set_entry(dag_node_t *node,
+svn_fs_py__dag_set_entry(dag_node_t *node,
                          const char *entry_name,
                          const svn_fs_id_t *id,
                          svn_node_kind_t kind,
@@ -468,7 +468,7 @@ svn_fs_fs__dag_set_entry(dag_node_t *nod
        _("Attempted to set entry in non-directory node"));
 
   /* Check it's mutable. */
-  if (! svn_fs_fs__dag_check_mutable(node))
+  if (! svn_fs_py__dag_check_mutable(node))
     return svn_error_create
       (SVN_ERR_FS_NOT_MUTABLE, NULL,
        _("Attempted to set entry in immutable node"));
@@ -481,7 +481,7 @@ svn_fs_fs__dag_set_entry(dag_node_t *nod
 /*** Proplists. ***/
 
 svn_error_t *
-svn_fs_fs__dag_get_proplist(apr_hash_t **proplist_p,
+svn_fs_py__dag_get_proplist(apr_hash_t **proplist_p,
                             dag_node_t *node,
                             apr_pool_t *pool)
 {
@@ -490,7 +490,7 @@ svn_fs_fs__dag_get_proplist(apr_hash_t *
 
   SVN_ERR(get_node_revision(&noderev, node, pool));
 
-  SVN_ERR(svn_fs_fs__get_proplist(&proplist, node->fs,
+  SVN_ERR(svn_fs_py__get_proplist(&proplist, node->fs,
                                   noderev, pool));
 
   *proplist_p = proplist;
@@ -500,16 +500,16 @@ svn_fs_fs__dag_get_proplist(apr_hash_t *
 
 
 svn_error_t *
-svn_fs_fs__dag_set_proplist(dag_node_t *node,
+svn_fs_py__dag_set_proplist(dag_node_t *node,
                             apr_hash_t *proplist,
                             apr_pool_t *pool)
 {
   node_revision_t *noderev;
 
   /* Sanity check: this node better be mutable! */
-  if (! svn_fs_fs__dag_check_mutable(node))
+  if (! svn_fs_py__dag_check_mutable(node))
     {
-      svn_string_t *idstr = svn_fs_fs__id_unparse(node->id, pool);
+      svn_string_t *idstr = svn_fs_py__id_unparse(node->id, pool);
       return svn_error_createf
         (SVN_ERR_FS_NOT_MUTABLE, NULL,
          "Can't set proplist on *immutable* node-revision %s",
@@ -520,21 +520,21 @@ svn_fs_fs__dag_set_proplist(dag_node_t *
   SVN_ERR(get_node_revision(&noderev, node, pool));
 
   /* Set the new proplist. */
-  return svn_fs_fs__set_proplist(node->fs, noderev, proplist, pool);
+  return svn_fs_py__set_proplist(node->fs, noderev, proplist, pool);
 }
 
 
 svn_error_t *
-svn_fs_fs__dag_increment_mergeinfo_count(dag_node_t *node,
+svn_fs_py__dag_increment_mergeinfo_count(dag_node_t *node,
                                          apr_int64_t increment,
                                          apr_pool_t *pool)
 {
   node_revision_t *noderev;
 
   /* Sanity check: this node better be mutable! */
-  if (! svn_fs_fs__dag_check_mutable(node))
+  if (! svn_fs_py__dag_check_mutable(node))
     {
-      svn_string_t *idstr = svn_fs_fs__id_unparse(node->id, pool);
+      svn_string_t *idstr = svn_fs_py__id_unparse(node->id, pool);
       return svn_error_createf
         (SVN_ERR_FS_NOT_MUTABLE, NULL,
          "Can't increment mergeinfo count on *immutable* node-revision %s",
@@ -550,7 +550,7 @@ svn_fs_fs__dag_increment_mergeinfo_count
   noderev->mergeinfo_count += increment;
   if (noderev->mergeinfo_count < 0)
     {
-      svn_string_t *idstr = svn_fs_fs__id_unparse(node->id, pool);
+      svn_string_t *idstr = svn_fs_py__id_unparse(node->id, pool);
       return svn_error_createf
         (SVN_ERR_FS_CORRUPT, NULL,
          apr_psprintf(pool,
@@ -561,7 +561,7 @@ svn_fs_fs__dag_increment_mergeinfo_count
     }
   if (noderev->mergeinfo_count > 1 && noderev->kind == svn_node_file)
     {
-      svn_string_t *idstr = svn_fs_fs__id_unparse(node->id, pool);
+      svn_string_t *idstr = svn_fs_py__id_unparse(node->id, pool);
       return svn_error_createf
         (SVN_ERR_FS_CORRUPT, NULL,
          apr_psprintf(pool,
@@ -572,21 +572,21 @@ svn_fs_fs__dag_increment_mergeinfo_count
     }
 
   /* Flush it out. */
-  return svn_fs_fs__put_node_revision(node->fs, noderev->id,
+  return svn_fs_py__put_node_revision(node->fs, noderev->id,
                                       noderev, FALSE, pool);
 }
 
 svn_error_t *
-svn_fs_fs__dag_set_has_mergeinfo(dag_node_t *node,
+svn_fs_py__dag_set_has_mergeinfo(dag_node_t *node,
                                  svn_boolean_t has_mergeinfo,
                                  apr_pool_t *pool)
 {
   node_revision_t *noderev;
 
   /* Sanity check: this node better be mutable! */
-  if (! svn_fs_fs__dag_check_mutable(node))
+  if (! svn_fs_py__dag_check_mutable(node))
     {
-      svn_string_t *idstr = svn_fs_fs__id_unparse(node->id, pool);
+      svn_string_t *idstr = svn_fs_py__id_unparse(node->id, pool);
       return svn_error_createf
         (SVN_ERR_FS_NOT_MUTABLE, NULL,
          "Can't set mergeinfo flag on *immutable* node-revision %s",
@@ -599,7 +599,7 @@ svn_fs_fs__dag_set_has_mergeinfo(dag_nod
   noderev->has_mergeinfo = has_mergeinfo;
 
   /* Flush it out. */
-  return svn_fs_fs__put_node_revision(node->fs, noderev->id,
+  return svn_fs_py__put_node_revision(node->fs, noderev->id,
                                       noderev, FALSE, pool);
 }
 
@@ -607,46 +607,46 @@ svn_fs_fs__dag_set_has_mergeinfo(dag_nod
 /*** Roots. ***/
 
 svn_error_t *
-svn_fs_fs__dag_revision_root(dag_node_t **node_p,
+svn_fs_py__dag_revision_root(dag_node_t **node_p,
                              svn_fs_t *fs,
                              svn_revnum_t rev,
                              apr_pool_t *pool)
 {
   svn_fs_id_t *root_id;
 
-  SVN_ERR(svn_fs_fs__rev_get_root(&root_id, fs, rev, pool));
-  return svn_fs_fs__dag_get_node(node_p, fs, root_id, pool);
+  SVN_ERR(svn_fs_py__rev_get_root(&root_id, fs, rev, pool));
+  return svn_fs_py__dag_get_node(node_p, fs, root_id, pool);
 }
 
 
 svn_error_t *
-svn_fs_fs__dag_txn_root(dag_node_t **node_p,
+svn_fs_py__dag_txn_root(dag_node_t **node_p,
                         svn_fs_t *fs,
                         const char *txn_id,
                         apr_pool_t *pool)
 {
   const svn_fs_id_t *root_id, *ignored;
 
-  SVN_ERR(svn_fs_fs__get_txn_ids(&root_id, &ignored, fs, txn_id, pool));
-  return svn_fs_fs__dag_get_node(node_p, fs, root_id, pool);
+  SVN_ERR(svn_fs_py__get_txn_ids(&root_id, &ignored, fs, txn_id, pool));
+  return svn_fs_py__dag_get_node(node_p, fs, root_id, pool);
 }
 
 
 svn_error_t *
-svn_fs_fs__dag_txn_base_root(dag_node_t **node_p,
+svn_fs_py__dag_txn_base_root(dag_node_t **node_p,
                              svn_fs_t *fs,
                              const char *txn_id,
                              apr_pool_t *pool)
 {
   const svn_fs_id_t *base_root_id, *ignored;
 
-  SVN_ERR(svn_fs_fs__get_txn_ids(&ignored, &base_root_id, fs, txn_id, pool));
-  return svn_fs_fs__dag_get_node(node_p, fs, base_root_id, pool);
+  SVN_ERR(svn_fs_py__get_txn_ids(&ignored, &base_root_id, fs, txn_id, pool));
+  return svn_fs_py__dag_get_node(node_p, fs, base_root_id, pool);
 }
 
 
 svn_error_t *
-svn_fs_fs__dag_clone_child(dag_node_t **child_p,
+svn_fs_py__dag_clone_child(dag_node_t **child_p,
                            dag_node_t *parent,
                            const char *parent_path,
                            const char *name,
@@ -657,10 +657,10 @@ svn_fs_fs__dag_clone_child(dag_node_t **
 {
   dag_node_t *cur_entry; /* parent's current entry named NAME */
   const svn_fs_id_t *new_node_id; /* node id we'll put into NEW_NODE */
-  svn_fs_t *fs = svn_fs_fs__dag_get_fs(parent);
+  svn_fs_t *fs = svn_fs_py__dag_get_fs(parent);
 
   /* First check that the parent is mutable. */
-  if (! svn_fs_fs__dag_check_mutable(parent))
+  if (! svn_fs_py__dag_check_mutable(parent))
     return svn_error_createf
       (SVN_ERR_FS_NOT_MUTABLE, NULL,
        "Attempted to clone child of non-mutable node");
@@ -672,11 +672,11 @@ svn_fs_fs__dag_clone_child(dag_node_t **
        "Attempted to make a child clone with an illegal name '%s'", name);
 
   /* Find the node named NAME in PARENT's entries list if it exists. */
-  SVN_ERR(svn_fs_fs__dag_open(&cur_entry, parent, name, pool));
+  SVN_ERR(svn_fs_py__dag_open(&cur_entry, parent, name, pool));
 
   /* Check for mutability in the node we found.  If it's mutable, we
      don't need to clone it. */
-  if (svn_fs_fs__dag_check_mutable(cur_entry))
+  if (svn_fs_py__dag_check_mutable(cur_entry))
     {
       /* This has already been cloned */
       new_node_id = cur_entry->id;
@@ -699,12 +699,12 @@ svn_fs_fs__dag_clone_child(dag_node_t **
       noderev->copyfrom_path = NULL;
       noderev->copyfrom_rev = SVN_INVALID_REVNUM;
 
-      noderev->predecessor_id = svn_fs_fs__id_copy(cur_entry->id, pool);
+      noderev->predecessor_id = svn_fs_py__id_copy(cur_entry->id, pool);
       if (noderev->predecessor_count != -1)
         noderev->predecessor_count++;
       noderev->created_path = svn_fspath__join(parent_path, name, pool);
 
-      SVN_ERR(svn_fs_fs__create_successor(&new_node_id, fs, cur_entry->id,
+      SVN_ERR(svn_fs_py__create_successor(&new_node_id, fs, cur_entry->id,
                                           noderev, copy_id, txn_id, pool));
 
       /* Replace the ID in the parent's ENTRY list with the ID which
@@ -714,13 +714,13 @@ svn_fs_fs__dag_clone_child(dag_node_t **
     }
 
   /* Initialize the youngster. */
-  return svn_fs_fs__dag_get_node(child_p, fs, new_node_id, pool);
+  return svn_fs_py__dag_get_node(child_p, fs, new_node_id, pool);
 }
 
 
 
 svn_error_t *
-svn_fs_fs__dag_clone_root(dag_node_t **root_p,
+svn_fs_py__dag_clone_root(dag_node_t **root_p,
                           svn_fs_t *fs,
                           const char *txn_id,
                           apr_pool_t *pool)
@@ -729,12 +729,12 @@ svn_fs_fs__dag_clone_root(dag_node_t **r
 
   /* Get the node ID's of the root directories of the transaction and
      its base revision.  */
-  SVN_ERR(svn_fs_fs__get_txn_ids(&root_id, &base_root_id, fs, txn_id, pool));
+  SVN_ERR(svn_fs_py__get_txn_ids(&root_id, &base_root_id, fs, txn_id, pool));
 
   /* Oh, give me a clone...
      (If they're the same, we haven't cloned the transaction's root
      directory yet.)  */
-  SVN_ERR_ASSERT(!svn_fs_fs__id_eq(root_id, base_root_id));
+  SVN_ERR_ASSERT(!svn_fs_py__id_eq(root_id, base_root_id));
 
   /*
    * (Sung to the tune of "Home, Home on the Range", with thanks to
@@ -742,12 +742,12 @@ svn_fs_fs__dag_clone_root(dag_node_t **r
    */
 
   /* One way or another, root_id now identifies a cloned root node. */
-  return svn_fs_fs__dag_get_node(root_p, fs, root_id, pool);
+  return svn_fs_py__dag_get_node(root_p, fs, root_id, pool);
 }
 
 
 svn_error_t *
-svn_fs_fs__dag_delete(dag_node_t *parent,
+svn_fs_py__dag_delete(dag_node_t *parent,
                       const char *name,
                       const char *txn_id,
                       apr_pool_t *pool)
@@ -766,7 +766,7 @@ svn_fs_fs__dag_delete(dag_node_t *parent
        "Attempted to delete entry '%s' from *non*-directory node", name);
 
   /* Make sure parent is mutable. */
-  if (! svn_fs_fs__dag_check_mutable(parent))
+  if (! svn_fs_py__dag_check_mutable(parent))
     return svn_error_createf
       (SVN_ERR_FS_NOT_MUTABLE, NULL,
        "Attempted to delete entry '%s' from immutable directory node", name);
@@ -783,7 +783,7 @@ svn_fs_fs__dag_delete(dag_node_t *parent
   subpool = svn_pool_create(pool);
 
   /* Get a dirent hash for this directory. */
-  SVN_ERR(svn_fs_fs__rep_contents_dir(&entries, fs, parent_noderev, subpool));
+  SVN_ERR(svn_fs_py__rep_contents_dir(&entries, fs, parent_noderev, subpool));
 
   /* Find name in the ENTRIES hash. */
   dirent = apr_hash_get(entries, name, APR_HASH_KEY_STRING);
@@ -798,50 +798,50 @@ svn_fs_fs__dag_delete(dag_node_t *parent
 
   /* Copy the ID out of the subpool and release the rest of the
      directory listing. */
-  id = svn_fs_fs__id_copy(dirent->id, pool);
+  id = svn_fs_py__id_copy(dirent->id, pool);
   svn_pool_destroy(subpool);
 
   /* If mutable, remove it and any mutable children from db. */
-  SVN_ERR(svn_fs_fs__dag_delete_if_mutable(parent->fs, id, pool));
+  SVN_ERR(svn_fs_py__dag_delete_if_mutable(parent->fs, id, pool));
 
   /* Remove this entry from its parent's entries list. */
-  return svn_fs_fs__set_entry(parent->fs, txn_id, parent_noderev, name,
+  return svn_fs_py__set_entry(parent->fs, txn_id, parent_noderev, name,
                               NULL, svn_node_unknown, pool);
 }
 
 
 svn_error_t *
-svn_fs_fs__dag_remove_node(svn_fs_t *fs,
+svn_fs_py__dag_remove_node(svn_fs_t *fs,
                            const svn_fs_id_t *id,
                            apr_pool_t *pool)
 {
   dag_node_t *node;
 
   /* Fetch the node. */
-  SVN_ERR(svn_fs_fs__dag_get_node(&node, fs, id, pool));
+  SVN_ERR(svn_fs_py__dag_get_node(&node, fs, id, pool));
 
   /* If immutable, do nothing and return immediately. */
-  if (! svn_fs_fs__dag_check_mutable(node))
+  if (! svn_fs_py__dag_check_mutable(node))
     return svn_error_createf(SVN_ERR_FS_NOT_MUTABLE, NULL,
                              "Attempted removal of immutable node");
 
   /* Delete the node revision. */
-  return svn_fs_fs__delete_node_revision(fs, id, pool);
+  return svn_fs_py__delete_node_revision(fs, id, pool);
 }
 
 
 svn_error_t *
-svn_fs_fs__dag_delete_if_mutable(svn_fs_t *fs,
+svn_fs_py__dag_delete_if_mutable(svn_fs_t *fs,
                                  const svn_fs_id_t *id,
                                  apr_pool_t *pool)
 {
   dag_node_t *node;
 
   /* Get the node. */
-  SVN_ERR(svn_fs_fs__dag_get_node(&node, fs, id, pool));
+  SVN_ERR(svn_fs_py__dag_get_node(&node, fs, id, pool));
 
   /* If immutable, do nothing and return immediately. */
-  if (! svn_fs_fs__dag_check_mutable(node))
+  if (! svn_fs_py__dag_check_mutable(node))
     return SVN_NO_ERROR;
 
   /* Else it's mutable.  Recurse on directories... */
@@ -851,7 +851,7 @@ svn_fs_fs__dag_delete_if_mutable(svn_fs_
       apr_hash_index_t *hi;
 
       /* Loop over hash entries */
-      SVN_ERR(svn_fs_fs__dag_dir_entries(&entries, node, pool, pool));
+      SVN_ERR(svn_fs_py__dag_dir_entries(&entries, node, pool, pool));
       if (entries)
         {
           for (hi = apr_hash_first(pool, entries);
@@ -860,7 +860,7 @@ svn_fs_fs__dag_delete_if_mutable(svn_fs_
             {
               svn_fs_dirent_t *dirent = svn__apr_hash_index_val(hi);
 
-              SVN_ERR(svn_fs_fs__dag_delete_if_mutable(fs, dirent->id,
+              SVN_ERR(svn_fs_py__dag_delete_if_mutable(fs, dirent->id,
                                                        pool));
             }
         }
@@ -868,11 +868,11 @@ svn_fs_fs__dag_delete_if_mutable(svn_fs_
 
   /* ... then delete the node itself, after deleting any mutable
      representations and strings it points to. */
-  return svn_fs_fs__dag_remove_node(fs, id, pool);
+  return svn_fs_py__dag_remove_node(fs, id, pool);
 }
 
 svn_error_t *
-svn_fs_fs__dag_make_file(dag_node_t **child_p,
+svn_fs_py__dag_make_file(dag_node_t **child_p,
                          dag_node_t *parent,
                          const char *parent_path,
                          const char *name,
@@ -885,7 +885,7 @@ svn_fs_fs__dag_make_file(dag_node_t **ch
 
 
 svn_error_t *
-svn_fs_fs__dag_make_dir(dag_node_t **child_p,
+svn_fs_py__dag_make_dir(dag_node_t **child_p,
                         dag_node_t *parent,
                         const char *parent_path,
                         const char *name,
@@ -898,7 +898,7 @@ svn_fs_fs__dag_make_dir(dag_node_t **chi
 
 
 svn_error_t *
-svn_fs_fs__dag_get_contents(svn_stream_t **contents_p,
+svn_fs_py__dag_get_contents(svn_stream_t **contents_p,
                             dag_node_t *file,
                             apr_pool_t *pool)
 {
@@ -915,7 +915,7 @@ svn_fs_fs__dag_get_contents(svn_stream_t
   SVN_ERR(get_node_revision(&noderev, file, pool));
 
   /* Get a stream to the contents. */
-  SVN_ERR(svn_fs_fs__get_contents(&contents, file->fs,
+  SVN_ERR(svn_fs_py__get_contents(&contents, file->fs,
                                   noderev, pool));
 
   *contents_p = contents;
@@ -925,7 +925,7 @@ svn_fs_fs__dag_get_contents(svn_stream_t
 
 
 svn_error_t *
-svn_fs_fs__dag_get_file_delta_stream(svn_txdelta_stream_t **stream_p,
+svn_fs_py__dag_get_file_delta_stream(svn_txdelta_stream_t **stream_p,
                                      dag_node_t *source,
                                      dag_node_t *target,
                                      apr_pool_t *pool)
@@ -948,13 +948,13 @@ svn_fs_fs__dag_get_file_delta_stream(svn
   SVN_ERR(get_node_revision(&tgt_noderev, target, pool));
 
   /* Get the delta stream. */
-  return svn_fs_fs__get_file_delta_stream(stream_p, target->fs,
+  return svn_fs_py__get_file_delta_stream(stream_p, target->fs,
                                           src_noderev, tgt_noderev, pool);
 }
 
 
 svn_error_t *
-svn_fs_fs__dag_file_length(svn_filesize_t *length,
+svn_fs_py__dag_file_length(svn_filesize_t *length,
                            dag_node_t *file,
                            apr_pool_t *pool)
 {
@@ -969,12 +969,12 @@ svn_fs_fs__dag_file_length(svn_filesize_
   /* Go get a fresh node-revision for FILE, and . */
   SVN_ERR(get_node_revision(&noderev, file, pool));
 
-  return svn_fs_fs__file_length(length, noderev, pool);
+  return svn_fs_py__file_length(length, noderev, pool);
 }
 
 
 svn_error_t *
-svn_fs_fs__dag_file_checksum(svn_checksum_t **checksum,
+svn_fs_py__dag_file_checksum(svn_checksum_t **checksum,
                              dag_node_t *file,
                              svn_checksum_kind_t kind,
                              apr_pool_t *pool)
@@ -988,12 +988,12 @@ svn_fs_fs__dag_file_checksum(svn_checksu
 
   SVN_ERR(get_node_revision(&noderev, file, pool));
 
-  return svn_fs_fs__file_checksum(checksum, noderev, kind, pool);
+  return svn_fs_py__file_checksum(checksum, noderev, kind, pool);
 }
 
 
 svn_error_t *
-svn_fs_fs__dag_get_edit_stream(svn_stream_t **contents,
+svn_fs_py__dag_get_edit_stream(svn_stream_t **contents,
                                dag_node_t *file,
                                apr_pool_t *pool)
 {
@@ -1007,7 +1007,7 @@ svn_fs_fs__dag_get_edit_stream(svn_strea
        "Attempted to set textual contents of a *non*-file node");
 
   /* Make sure our node is mutable. */
-  if (! svn_fs_fs__dag_check_mutable(file))
+  if (! svn_fs_py__dag_check_mutable(file))
     return svn_error_createf
       (SVN_ERR_FS_NOT_MUTABLE, NULL,
        "Attempted to set textual contents of an immutable node");
@@ -1015,7 +1015,7 @@ svn_fs_fs__dag_get_edit_stream(svn_strea
   /* Get the node revision. */
   SVN_ERR(get_node_revision(&noderev, file, pool));
 
-  SVN_ERR(svn_fs_fs__set_contents(&ws, file->fs, noderev, pool));
+  SVN_ERR(svn_fs_py__set_contents(&ws, file->fs, noderev, pool));
 
   *contents = ws;
 
@@ -1025,7 +1025,7 @@ svn_fs_fs__dag_get_edit_stream(svn_strea
 
 
 svn_error_t *
-svn_fs_fs__dag_finalize_edits(dag_node_t *file,
+svn_fs_py__dag_finalize_edits(dag_node_t *file,
                               const svn_checksum_t *checksum,
                               apr_pool_t *pool)
 {
@@ -1033,7 +1033,7 @@ svn_fs_fs__dag_finalize_edits(dag_node_t
     {
       svn_checksum_t *file_checksum;
 
-      SVN_ERR(svn_fs_fs__dag_file_checksum(&file_checksum, file,
+      SVN_ERR(svn_fs_py__dag_file_checksum(&file_checksum, file,
                                            checksum->kind, pool));
       if (!svn_checksum_match(checksum, file_checksum))
         return svn_checksum_mismatch_err(checksum, file_checksum, pool,
@@ -1046,23 +1046,23 @@ svn_fs_fs__dag_finalize_edits(dag_node_t
 
 
 dag_node_t *
-svn_fs_fs__dag_dup(const dag_node_t *node,
+svn_fs_py__dag_dup(const dag_node_t *node,
                    apr_pool_t *pool)
 {
   /* Allocate our new node. */
   dag_node_t *new_node = apr_pcalloc(pool, sizeof(*new_node));
 
   new_node->fs = node->fs;
-  new_node->id = svn_fs_fs__id_copy(node->id, pool);
+  new_node->id = svn_fs_py__id_copy(node->id, pool);
   new_node->kind = node->kind;
   new_node->created_path = apr_pstrdup(pool, node->created_path);
 
   /* Only copy cached node_revision_t for immutable nodes. */
-  if (node->node_revision && !svn_fs_fs__dag_check_mutable(node))
+  if (node->node_revision && !svn_fs_py__dag_check_mutable(node))
     {
       new_node->node_revision = copy_node_revision(node->node_revision, pool);
       new_node->node_revision->id =
-          svn_fs_fs__id_copy(node->node_revision->id, pool);
+          svn_fs_py__id_copy(node->node_revision->id, pool);
       new_node->node_revision->is_fresh_txn_root =
           node->node_revision->is_fresh_txn_root;
     }
@@ -1070,7 +1070,7 @@ svn_fs_fs__dag_dup(const dag_node_t *nod
 }
 
 svn_error_t *
-svn_fs_fs__dag_serialize(char **data,
+svn_fs_py__dag_serialize(char **data,
                          apr_size_t *data_len,
                          void *in,
                          apr_pool_t *pool)
@@ -1086,15 +1086,15 @@ svn_fs_fs__dag_serialize(char **data,
                                 pool);
 
   /* for mutable nodes, we will _never_ cache the noderev */
-  if (node->node_revision && !svn_fs_fs__dag_check_mutable(node))
-    svn_fs_fs__noderev_serialize(context, &node->node_revision);
+  if (node->node_revision && !svn_fs_py__dag_check_mutable(node))
+    svn_fs_py__noderev_serialize(context, &node->node_revision);
   else
     svn_temp_serializer__set_null(context,
                                   (const void * const *)&node->node_revision);
 
   /* serialize other sub-structures */
-  svn_fs_fs__id_serialize(context, (const svn_fs_id_t **)&node->id);
-  svn_fs_fs__id_serialize(context, &node->fresh_root_predecessor_id);
+  svn_fs_py__id_serialize(context, (const svn_fs_id_t **)&node->id);
+  svn_fs_py__id_serialize(context, &node->fresh_root_predecessor_id);
   svn_temp_serializer__add_string(context, &node->created_path);
 
   /* return serialized data */
@@ -1106,7 +1106,7 @@ svn_fs_fs__dag_serialize(char **data,
 }
 
 svn_error_t *
-svn_fs_fs__dag_deserialize(void **out,
+svn_fs_py__dag_deserialize(void **out,
                            char *data,
                            apr_size_t data_len,
                            apr_pool_t *pool)
@@ -1120,10 +1120,10 @@ svn_fs_fs__dag_deserialize(void **out,
   node->fs = NULL;
 
   /* fixup all references to sub-structures */
-  svn_fs_fs__id_deserialize(node, &node->id);
-  svn_fs_fs__id_deserialize(node,
+  svn_fs_py__id_deserialize(node, &node->id);
+  svn_fs_py__id_deserialize(node,
                             (svn_fs_id_t **)&node->fresh_root_predecessor_id);
-  svn_fs_fs__noderev_deserialize(node, &node->node_revision);
+  svn_fs_py__noderev_deserialize(node, &node->node_revision);
 
   svn_temp_deserializer__resolve(node, (void**)&node->created_path);
 
@@ -1134,7 +1134,7 @@ svn_fs_fs__dag_deserialize(void **out,
 }
 
 svn_error_t *
-svn_fs_fs__dag_open(dag_node_t **child_p,
+svn_fs_py__dag_open(dag_node_t **child_p,
                     dag_node_t *parent,
                     const char *name,
                     apr_pool_t *pool)
@@ -1155,13 +1155,13 @@ svn_fs_fs__dag_open(dag_node_t **child_p
        "Attempted to open node with an illegal name '%s'", name);
 
   /* Now get the node that was requested. */
-  return svn_fs_fs__dag_get_node(child_p, svn_fs_fs__dag_get_fs(parent),
+  return svn_fs_py__dag_get_node(child_p, svn_fs_py__dag_get_fs(parent),
                                  node_id, pool);
 }
 
 
 svn_error_t *
-svn_fs_fs__dag_copy(dag_node_t *to_node,
+svn_fs_py__dag_copy(dag_node_t *to_node,
                     const char *entry,
                     dag_node_t *from_node,
                     svn_boolean_t preserve_history,
@@ -1176,23 +1176,23 @@ svn_fs_fs__dag_copy(dag_node_t *to_node,
     {
       node_revision_t *from_noderev, *to_noderev;
       const char *copy_id;
-      const svn_fs_id_t *src_id = svn_fs_fs__dag_get_id(from_node);
-      svn_fs_t *fs = svn_fs_fs__dag_get_fs(from_node);
+      const svn_fs_id_t *src_id = svn_fs_py__dag_get_id(from_node);
+      svn_fs_t *fs = svn_fs_py__dag_get_fs(from_node);
 
       /* Make a copy of the original node revision. */
       SVN_ERR(get_node_revision(&from_noderev, from_node, pool));
       to_noderev = copy_node_revision(from_noderev, pool);
 
       /* Reserve a copy ID for this new copy. */
-      SVN_ERR(svn_fs_fs__reserve_copy_id(&copy_id, fs, txn_id, pool));
+      SVN_ERR(svn_fs_py__reserve_copy_id(&copy_id, fs, txn_id, pool));
 
       /* Create a successor with its predecessor pointing at the copy
          source. */
-      to_noderev->predecessor_id = svn_fs_fs__id_copy(src_id, pool);
+      to_noderev->predecessor_id = svn_fs_py__id_copy(src_id, pool);
       if (to_noderev->predecessor_count != -1)
         to_noderev->predecessor_count++;
       to_noderev->created_path =
-        svn_fspath__join(svn_fs_fs__dag_get_created_path(to_node), entry,
+        svn_fspath__join(svn_fs_py__dag_get_created_path(to_node), entry,
                      pool);
       to_noderev->copyfrom_path = apr_pstrdup(pool, from_path);
       to_noderev->copyfrom_rev = from_rev;
@@ -1200,17 +1200,17 @@ svn_fs_fs__dag_copy(dag_node_t *to_node,
       /* Set the copyroot equal to our own id. */
       to_noderev->copyroot_path = NULL;
 
-      SVN_ERR(svn_fs_fs__create_successor(&id, fs, src_id, to_noderev,
+      SVN_ERR(svn_fs_py__create_successor(&id, fs, src_id, to_noderev,
                                           copy_id, txn_id, pool));
 
     }
   else  /* don't preserve history */
     {
-      id = svn_fs_fs__dag_get_id(from_node);
+      id = svn_fs_py__dag_get_id(from_node);
     }
 
   /* Set the entry in to_node to the new id. */
-  return svn_fs_fs__dag_set_entry(to_node, entry, id, from_node->kind,
+  return svn_fs_py__dag_set_entry(to_node, entry, id, from_node->kind,
                                   txn_id, pool);
 }
 
@@ -1219,7 +1219,7 @@ svn_fs_fs__dag_copy(dag_node_t *to_node,
 /*** Comparison. ***/
 
 svn_error_t *
-svn_fs_fs__dag_things_different(svn_boolean_t *props_changed,
+svn_fs_py__dag_things_different(svn_boolean_t *props_changed,
                                 svn_boolean_t *contents_changed,
                                 dag_node_t *node1,
                                 dag_node_t *node2,
@@ -1238,20 +1238,20 @@ svn_fs_fs__dag_things_different(svn_bool
 
   /* Compare property keys. */
   if (props_changed != NULL)
-    *props_changed = (! svn_fs_fs__noderev_same_rep_key(noderev1->prop_rep,
+    *props_changed = (! svn_fs_py__noderev_same_rep_key(noderev1->prop_rep,
                                                         noderev2->prop_rep));
 
   /* Compare contents keys. */
   if (contents_changed != NULL)
     *contents_changed =
-      (! svn_fs_fs__noderev_same_rep_key(noderev1->data_rep,
+      (! svn_fs_py__noderev_same_rep_key(noderev1->data_rep,
                                          noderev2->data_rep));
 
   return SVN_NO_ERROR;
 }
 
 svn_error_t *
-svn_fs_fs__dag_get_copyroot(svn_revnum_t *rev,
+svn_fs_py__dag_get_copyroot(svn_revnum_t *rev,
                             const char **path,
                             dag_node_t *node,
                             apr_pool_t *pool)
@@ -1268,7 +1268,7 @@ svn_fs_fs__dag_get_copyroot(svn_revnum_t
 }
 
 svn_error_t *
-svn_fs_fs__dag_get_copyfrom_rev(svn_revnum_t *rev,
+svn_fs_py__dag_get_copyfrom_rev(svn_revnum_t *rev,
                                 dag_node_t *node,
                                 apr_pool_t *pool)
 {
@@ -1283,7 +1283,7 @@ svn_fs_fs__dag_get_copyfrom_rev(svn_revn
 }
 
 svn_error_t *
-svn_fs_fs__dag_get_copyfrom_path(const char **path,
+svn_fs_py__dag_get_copyfrom_path(const char **path,
                                  dag_node_t *node,
                                  apr_pool_t *pool)
 {

Modified: subversion/branches/fs-py/subversion/libsvn_fs_py/dag.h
URL: http://svn.apache.org/viewvc/subversion/branches/fs-py/subversion/libsvn_fs_py/dag.h?rev=1154262&r1=1154224&r2=1154262&view=diff
==============================================================================
--- subversion/branches/fs-py/subversion/libsvn_fs_py/dag.h (original)
+++ subversion/branches/fs-py/subversion/libsvn_fs_py/dag.h Fri Aug  5 15:20:23 2011
@@ -64,7 +64,7 @@ typedef struct dag_node_t dag_node_t;
 /* Fill *NODE with a dag_node_t representing node revision ID in FS,
    allocating in POOL.  */
 svn_error_t *
-svn_fs_fs__dag_get_node(dag_node_t **node,
+svn_fs_py__dag_get_node(dag_node_t **node,
                         svn_fs_t *fs,
                         const svn_fs_id_t *id,
                         apr_pool_t *pool);
@@ -75,13 +75,13 @@ svn_fs_fs__dag_get_node(dag_node_t **nod
    pool that wants to refer to dag nodes that may have been allocated
    elsewhere, you can call this function and avoid inter-pool pointers. */
 dag_node_t *
-svn_fs_fs__dag_dup(const dag_node_t *node,
+svn_fs_py__dag_dup(const dag_node_t *node,
                    apr_pool_t *pool);
 
 /* Serialize a DAG node, except don't try to preserve the 'fs' member.
    Implements svn_cache__serialize_func_t */
 svn_error_t *
-svn_fs_fs__dag_serialize(char **data,
+svn_fs_py__dag_serialize(char **data,
                          apr_size_t *data_len,
                          void *in,
                          apr_pool_t *pool);
@@ -89,35 +89,35 @@ svn_fs_fs__dag_serialize(char **data,
 /* Deserialize a DAG node, leaving the 'fs' member as NULL.
    Implements svn_cache__deserialize_func_t */
 svn_error_t *
-svn_fs_fs__dag_deserialize(void **out,
+svn_fs_py__dag_deserialize(void **out,
                            char *data,
                            apr_size_t data_len,
                            apr_pool_t *pool);
 
 /* Return the filesystem containing NODE.  */
-svn_fs_t *svn_fs_fs__dag_get_fs(dag_node_t *node);
+svn_fs_t *svn_fs_py__dag_get_fs(dag_node_t *node);
 
 /* Changes the filesystem containing NODE to FS.  (Used when pulling
    nodes out of a shared cache, say.) */
-void svn_fs_fs__dag_set_fs(dag_node_t *node, svn_fs_t *fs);
+void svn_fs_py__dag_set_fs(dag_node_t *node, svn_fs_t *fs);
 
 
 /* Set *REV to NODE's revision number, allocating in POOL.  If NODE
    has never been committed as part of a revision, set *REV to
    SVN_INVALID_REVNUM.  */
-svn_error_t *svn_fs_fs__dag_get_revision(svn_revnum_t *rev,
+svn_error_t *svn_fs_py__dag_get_revision(svn_revnum_t *rev,
                                          dag_node_t *node,
                                          apr_pool_t *pool);
 
 
 /* Return the node revision ID of NODE.  The value returned is shared
    with NODE, and will be deallocated when NODE is.  */
-const svn_fs_id_t *svn_fs_fs__dag_get_id(const dag_node_t *node);
+const svn_fs_id_t *svn_fs_py__dag_get_id(const dag_node_t *node);
 
 
 /* Return the created path of NODE.  The value returned is shared
    with NODE, and will be deallocated when NODE is.  */
-const char *svn_fs_fs__dag_get_created_path(dag_node_t *node);
+const char *svn_fs_py__dag_get_created_path(dag_node_t *node);
 
 
 /* Set *ID_P to the node revision ID of NODE's immediate predecessor,
@@ -126,7 +126,7 @@ const char *svn_fs_fs__dag_get_created_p
    Use POOL for all allocations, including to cache the node_revision in
    NODE.
  */
-svn_error_t *svn_fs_fs__dag_get_predecessor_id(const svn_fs_id_t **id_p,
+svn_error_t *svn_fs_py__dag_get_predecessor_id(const svn_fs_id_t **id_p,
                                                dag_node_t *node,
                                                apr_pool_t *pool);
 
@@ -137,7 +137,7 @@ svn_error_t *svn_fs_fs__dag_get_predeces
    Use POOL for all allocations, including to cache the node_revision in
    NODE.
  */
-svn_error_t *svn_fs_fs__dag_get_predecessor_count(int *count,
+svn_error_t *svn_fs_py__dag_get_predecessor_count(int *count,
                                                   dag_node_t *node,
                                                   apr_pool_t *pool);
 
@@ -147,7 +147,7 @@ svn_error_t *svn_fs_fs__dag_get_predeces
    Use POOL for all allocations, including to cache the node_revision in
    NODE.
  */
-svn_error_t *svn_fs_fs__dag_get_mergeinfo_count(apr_int64_t *count,
+svn_error_t *svn_fs_py__dag_get_mergeinfo_count(apr_int64_t *count,
                                                 dag_node_t *node,
                                                 apr_pool_t *pool);
 
@@ -159,7 +159,7 @@ svn_error_t *svn_fs_fs__dag_get_mergeinf
    NODE.
  */
 svn_error_t *
-svn_fs_fs__dag_has_descendants_with_mergeinfo(svn_boolean_t *do_they,
+svn_fs_py__dag_has_descendants_with_mergeinfo(svn_boolean_t *do_they,
                                               dag_node_t *node,
                                               apr_pool_t *pool);
 
@@ -170,15 +170,15 @@ svn_fs_fs__dag_has_descendants_with_merg
    NODE.
  */
 svn_error_t *
-svn_fs_fs__dag_has_mergeinfo(svn_boolean_t *has_mergeinfo,
+svn_fs_py__dag_has_mergeinfo(svn_boolean_t *has_mergeinfo,
                              dag_node_t *node,
                              apr_pool_t *pool);
 
 /* Return non-zero IFF NODE is currently mutable. */
-svn_boolean_t svn_fs_fs__dag_check_mutable(const dag_node_t *node);
+svn_boolean_t svn_fs_py__dag_check_mutable(const dag_node_t *node);
 
 /* Return the node kind of NODE. */
-svn_node_kind_t svn_fs_fs__dag_node_kind(dag_node_t *node);
+svn_node_kind_t svn_fs_py__dag_node_kind(dag_node_t *node);
 
 /* Set *PROPLIST_P to a PROPLIST hash representing the entire property
    list of NODE, allocating from POOL.  The hash has const char *
@@ -191,7 +191,7 @@ svn_node_kind_t svn_fs_fs__dag_node_kind
    Use POOL for all allocations, including to cache the node_revision in
    NODE.
  */
-svn_error_t *svn_fs_fs__dag_get_proplist(apr_hash_t **proplist_p,
+svn_error_t *svn_fs_py__dag_get_proplist(apr_hash_t **proplist_p,
                                          dag_node_t *node,
                                          apr_pool_t *pool);
 
@@ -201,7 +201,7 @@ svn_error_t *svn_fs_fs__dag_get_proplist
    Use POOL for all allocations, including to cache the node_revision in
    NODE.
  */
-svn_error_t *svn_fs_fs__dag_set_proplist(dag_node_t *node,
+svn_error_t *svn_fs_py__dag_set_proplist(dag_node_t *node,
                                          apr_hash_t *proplist,
                                          apr_pool_t *pool);
 
@@ -211,7 +211,7 @@ svn_error_t *svn_fs_fs__dag_set_proplist
    Use POOL for all allocations, including to cache the node_revision in
    NODE.
  */
-svn_error_t *svn_fs_fs__dag_increment_mergeinfo_count(dag_node_t *node,
+svn_error_t *svn_fs_py__dag_increment_mergeinfo_count(dag_node_t *node,
                                                       apr_int64_t increment,
                                                       apr_pool_t *pool);
 
@@ -221,7 +221,7 @@ svn_error_t *svn_fs_fs__dag_increment_me
    Use POOL for all allocations, including to cache the node_revision in
    NODE.
  */
-svn_error_t *svn_fs_fs__dag_set_has_mergeinfo(dag_node_t *node,
+svn_error_t *svn_fs_py__dag_set_has_mergeinfo(dag_node_t *node,
                                               svn_boolean_t has_mergeinfo,
                                               apr_pool_t *pool);
 
@@ -232,7 +232,7 @@ svn_error_t *svn_fs_fs__dag_set_has_merg
 
 /* Open the root of revision REV of filesystem FS, allocating from
    POOL.  Set *NODE_P to the new node.  */
-svn_error_t *svn_fs_fs__dag_revision_root(dag_node_t **node_p,
+svn_error_t *svn_fs_py__dag_revision_root(dag_node_t **node_p,
                                           svn_fs_t *fs,
                                           svn_revnum_t rev,
                                           apr_pool_t *pool);
@@ -244,8 +244,8 @@ svn_error_t *svn_fs_fs__dag_revision_roo
    Note that the root node of TXN_ID is not necessarily mutable.  If
    no changes have been made in the transaction, then it may share its
    root directory with its base revision.  To get a mutable root node
-   for a transaction, call svn_fs_fs__dag_clone_root.  */
-svn_error_t *svn_fs_fs__dag_txn_root(dag_node_t **node_p,
+   for a transaction, call svn_fs_py__dag_clone_root.  */
+svn_error_t *svn_fs_py__dag_txn_root(dag_node_t **node_p,
                                      svn_fs_t *fs,
                                      const char *txn_id,
                                      apr_pool_t *pool);
@@ -253,7 +253,7 @@ svn_error_t *svn_fs_fs__dag_txn_root(dag
 
 /* Set *NODE_P to the base root of transaction TXN_ID in FS,
    allocating from POOL.  Allocate the node in TRAIL->pool.  */
-svn_error_t *svn_fs_fs__dag_txn_base_root(dag_node_t **node_p,
+svn_error_t *svn_fs_py__dag_txn_base_root(dag_node_t **node_p,
                                           svn_fs_t *fs,
                                           const char *txn_id,
                                           apr_pool_t *pool);
@@ -263,7 +263,7 @@ svn_error_t *svn_fs_fs__dag_txn_base_roo
    `transactions' table entry to point to it, unless this has been
    done already.  In either case, set *ROOT_P to a reference to the
    root directory clone.  Allocate *ROOT_P in POOL.  */
-svn_error_t *svn_fs_fs__dag_clone_root(dag_node_t **root_p,
+svn_error_t *svn_fs_py__dag_clone_root(dag_node_t **root_p,
                                        svn_fs_t *fs,
                                        const char *txn_id,
                                        apr_pool_t *pool);
@@ -280,7 +280,7 @@ svn_error_t *svn_fs_fs__dag_clone_root(d
    Use POOL for all allocations, including to cache the node_revision in
    PARENT.
  */
-svn_error_t *svn_fs_fs__dag_open(dag_node_t **child_p,
+svn_error_t *svn_fs_py__dag_open(dag_node_t **child_p,
                                  dag_node_t *parent,
                                  const char *name,
                                  apr_pool_t *pool);
@@ -292,7 +292,7 @@ svn_error_t *svn_fs_fs__dag_open(dag_nod
    which is also used for temporary allocations.  NODE_POOL is used
    for any allocation of memory that needs to live as long as NODE
    lives. */
-svn_error_t *svn_fs_fs__dag_dir_entries(apr_hash_t **entries_p,
+svn_error_t *svn_fs_py__dag_dir_entries(apr_hash_t **entries_p,
                                         dag_node_t *node,
                                         apr_pool_t *pool,
                                         apr_pool_t *node_pool);
@@ -303,7 +303,7 @@ svn_error_t *svn_fs_fs__dag_dir_entries(
    Otherwise, the *DIRENT will be set to NULL. NODE_POOL is used for
    any allocation of memory that needs to live as long as NODE lives.
  */
-svn_error_t * svn_fs_fs__dag_dir_entry(svn_fs_dirent_t **dirent,
+svn_error_t * svn_fs_py__dag_dir_entry(svn_fs_dirent_t **dirent,
                                        dag_node_t *node,
                                        const char* name,
                                        apr_pool_t *pool,
@@ -318,7 +318,7 @@ svn_error_t * svn_fs_fs__dag_dir_entry(s
    Use POOL for all allocations, including to cache the node_revision in
    NODE.
  */
-svn_error_t *svn_fs_fs__dag_set_entry(dag_node_t *node,
+svn_error_t *svn_fs_py__dag_set_entry(dag_node_t *node,
                                       const char *entry_name,
                                       const svn_fs_id_t *id,
                                       svn_node_kind_t kind,
@@ -346,7 +346,7 @@ svn_error_t *svn_fs_fs__dag_set_entry(da
    Use POOL for all allocations, including to cache the node_revision in
    FILE.
  */
-svn_error_t *svn_fs_fs__dag_clone_child(dag_node_t **child_p,
+svn_error_t *svn_fs_py__dag_clone_child(dag_node_t **child_p,
                                         dag_node_t *parent,
                                         const char *parent_path,
                                         const char *name,
@@ -369,7 +369,7 @@ svn_error_t *svn_fs_fs__dag_clone_child(
    Use POOL for all allocations, including to cache the node_revision in
    FILE.
  */
-svn_error_t *svn_fs_fs__dag_delete(dag_node_t *parent,
+svn_error_t *svn_fs_py__dag_delete(dag_node_t *parent,
                                    const char *name,
                                    const char *txn_id,
                                    apr_pool_t *pool);
@@ -384,7 +384,7 @@ svn_error_t *svn_fs_fs__dag_delete(dag_n
    children, you risk orphaning those children by leaving them
    dangling, disconnected from all DAG trees.  It is assumed that
    callers of this interface know what in the world they are doing.  */
-svn_error_t *svn_fs_fs__dag_remove_node(svn_fs_t *fs,
+svn_error_t *svn_fs_py__dag_remove_node(svn_fs_t *fs,
                                         const svn_fs_id_t *id,
                                         apr_pool_t *pool);
 
@@ -394,7 +394,7 @@ svn_error_t *svn_fs_fs__dag_remove_node(
    delete any mutable representations and strings associated with that
    node revision.  ID may refer to a file or directory, which may be
    mutable or immutable. */
-svn_error_t *svn_fs_fs__dag_delete_if_mutable(svn_fs_t *fs,
+svn_error_t *svn_fs_py__dag_delete_if_mutable(svn_fs_t *fs,
                                               const svn_fs_id_t *id,
                                               apr_pool_t *pool);
 
@@ -411,7 +411,7 @@ svn_error_t *svn_fs_fs__dag_delete_if_mu
    Use POOL for all allocations, including to cache the node_revision in
    PARENT.
  */
-svn_error_t *svn_fs_fs__dag_make_dir(dag_node_t **child_p,
+svn_error_t *svn_fs_py__dag_make_dir(dag_node_t **child_p,
                                      dag_node_t *parent,
                                      const char *parent_path,
                                      const char *name,
@@ -431,7 +431,7 @@ svn_error_t *svn_fs_fs__dag_make_dir(dag
    Use POOL for all allocations, including to cache the node_revision in
    FILE.
  */
-svn_error_t *svn_fs_fs__dag_get_contents(svn_stream_t **contents,
+svn_error_t *svn_fs_py__dag_get_contents(svn_stream_t **contents,
                                          dag_node_t *file,
                                          apr_pool_t *pool);
 
@@ -444,7 +444,7 @@ svn_error_t *svn_fs_fs__dag_get_contents
    SOURCE and TARGET.
  */
 svn_error_t *
-svn_fs_fs__dag_get_file_delta_stream(svn_txdelta_stream_t **stream_p,
+svn_fs_py__dag_get_file_delta_stream(svn_txdelta_stream_t **stream_p,
                                      dag_node_t *source,
                                      dag_node_t *target,
                                      apr_pool_t *pool);
@@ -458,13 +458,13 @@ svn_fs_fs__dag_get_file_delta_stream(svn
    Use POOL for all allocations, including to cache the node_revision in
    FILE.
  */
-svn_error_t *svn_fs_fs__dag_get_edit_stream(svn_stream_t **contents,
+svn_error_t *svn_fs_py__dag_get_edit_stream(svn_stream_t **contents,
                                             dag_node_t *file,
                                             apr_pool_t *pool);
 
 
 /* Signify the completion of edits to FILE made using the stream
-   returned by svn_fs_fs__dag_get_edit_stream, allocating from POOL.
+   returned by svn_fs_py__dag_get_edit_stream, allocating from POOL.
 
    If CHECKSUM is non-null, it must match the checksum for FILE's
    contents (note: this is not recalculated, the recorded checksum is
@@ -475,7 +475,7 @@ svn_error_t *svn_fs_fs__dag_get_edit_str
    Use POOL for all allocations, including to cache the node_revision in
    FILE.
  */
-svn_error_t *svn_fs_fs__dag_finalize_edits(dag_node_t *file,
+svn_error_t *svn_fs_py__dag_finalize_edits(dag_node_t *file,
                                            const svn_checksum_t *checksum,
                                            apr_pool_t *pool);
 
@@ -485,7 +485,7 @@ svn_error_t *svn_fs_fs__dag_finalize_edi
    Use POOL for all allocations, including to cache the node_revision in
    FILE.
  */
-svn_error_t *svn_fs_fs__dag_file_length(svn_filesize_t *length,
+svn_error_t *svn_fs_py__dag_file_length(svn_filesize_t *length,
                                         dag_node_t *file,
                                         apr_pool_t *pool);
 
@@ -499,7 +499,7 @@ svn_error_t *svn_fs_fs__dag_file_length(
    FILE.
  */
 svn_error_t *
-svn_fs_fs__dag_file_checksum(svn_checksum_t **checksum,
+svn_fs_py__dag_file_checksum(svn_checksum_t **checksum,
                              dag_node_t *file,
                              svn_checksum_kind_t kind,
                              apr_pool_t *pool);
@@ -515,7 +515,7 @@ svn_fs_fs__dag_file_checksum(svn_checksu
    Use POOL for all allocations, including to cache the node_revision in
    PARENT.
  */
-svn_error_t *svn_fs_fs__dag_make_file(dag_node_t **child_p,
+svn_error_t *svn_fs_py__dag_make_file(dag_node_t **child_p,
                                       dag_node_t *parent,
                                       const char *parent_path,
                                       const char *name,
@@ -541,7 +541,7 @@ svn_error_t *svn_fs_fs__dag_make_file(da
    Use POOL for all allocations, including to cache the node_revision in
    FROM_NODE.
  */
-svn_error_t *svn_fs_fs__dag_copy(dag_node_t *to_node,
+svn_error_t *svn_fs_py__dag_copy(dag_node_t *to_node,
                                  const char *entry,
                                  dag_node_t *from_node,
                                  svn_boolean_t preserve_history,
@@ -573,7 +573,7 @@ svn_error_t *svn_fs_fs__dag_copy(dag_nod
    Use POOL for all allocations, including to cache the node_revision in NODE1
    and NODE2.
  */
-svn_error_t *svn_fs_fs__dag_things_different(svn_boolean_t *props_changed,
+svn_error_t *svn_fs_py__dag_things_different(svn_boolean_t *props_changed,
                                              svn_boolean_t *contents_changed,
                                              dag_node_t *node1,
                                              dag_node_t *node2,
@@ -584,7 +584,7 @@ svn_error_t *svn_fs_fs__dag_things_diffe
    to SVN_INVALID_REVNUM and NULL if no copyroot exists.
    Use POOL for all allocations, including to cache the node_revision in NODE.
  */
-svn_error_t *svn_fs_fs__dag_get_copyroot(svn_revnum_t *rev,
+svn_error_t *svn_fs_py__dag_get_copyroot(svn_revnum_t *rev,
                                          const char **path,
                                          dag_node_t *node,
                                          apr_pool_t *pool);
@@ -592,14 +592,14 @@ svn_error_t *svn_fs_fs__dag_get_copyroot
 /* Set *REV to the copyfrom revision associated with NODE.
    Use POOL for all allocations, including to cache the node_revision in NODE.
  */
-svn_error_t *svn_fs_fs__dag_get_copyfrom_rev(svn_revnum_t *rev,
+svn_error_t *svn_fs_py__dag_get_copyfrom_rev(svn_revnum_t *rev,
                                              dag_node_t *node,
                                              apr_pool_t *pool);
 
 /* Set *PATH to the copyfrom path associated with NODE.
    Use POOL for all allocations, including to cache the node_revision in NODE.
  */
-svn_error_t *svn_fs_fs__dag_get_copyfrom_path(const char **path,
+svn_error_t *svn_fs_py__dag_get_copyfrom_path(const char **path,
                                               dag_node_t *node,
                                               apr_pool_t *pool);
 

Modified: subversion/branches/fs-py/subversion/libsvn_fs_py/fs.c
URL: http://svn.apache.org/viewvc/subversion/branches/fs-py/subversion/libsvn_fs_py/fs.c?rev=1154262&r1=1154224&r2=1154262&view=diff
==============================================================================
--- subversion/branches/fs-py/subversion/libsvn_fs_py/fs.c (original)
+++ subversion/branches/fs-py/subversion/libsvn_fs_py/fs.c Fri Aug  5 15:20:23 2011
@@ -141,25 +141,25 @@ fs_set_errcall(svn_fs_t *fs,
 
 /* The vtable associated with a specific open filesystem. */
 static fs_vtable_t fs_vtable = {
-  svn_fs_fs__youngest_rev,
-  svn_fs_fs__revision_prop,
-  svn_fs_fs__revision_proplist,
-  svn_fs_fs__change_rev_prop,
-  svn_fs_fs__get_uuid,
-  svn_fs_fs__set_uuid,
-  svn_fs_fs__revision_root,
-  svn_fs_fs__begin_txn,
-  svn_fs_fs__open_txn,
-  svn_fs_fs__purge_txn,
-  svn_fs_fs__list_transactions,
-  svn_fs_fs__deltify,
-  svn_fs_fs__lock,
-  svn_fs_fs__generate_lock_token,
-  svn_fs_fs__unlock,
-  svn_fs_fs__get_lock,
-  svn_fs_fs__get_locks,
+  svn_fs_py__youngest_rev,
+  svn_fs_py__revision_prop,
+  svn_fs_py__revision_proplist,
+  svn_fs_py__change_rev_prop,
+  svn_fs_py__get_uuid,
+  svn_fs_py__set_uuid,
+  svn_fs_py__revision_root,
+  svn_fs_py__begin_txn,
+  svn_fs_py__open_txn,
+  svn_fs_py__purge_txn,
+  svn_fs_py__list_transactions,
+  svn_fs_py__deltify,
+  svn_fs_py__lock,
+  svn_fs_py__generate_lock_token,
+  svn_fs_py__unlock,
+  svn_fs_py__get_lock,
+  svn_fs_py__get_locks,
   fs_set_errcall,
-  svn_fs_fs__validate_mergeinfo,
+  svn_fs_py__validate_mergeinfo,
 };
 
 
@@ -187,9 +187,9 @@ fs_create(svn_fs_t *fs, const char *path
 
   SVN_ERR(initialize_fs_struct(fs));
 
-  SVN_ERR(svn_fs_fs__create(fs, path, pool));
+  SVN_ERR(svn_fs_py__create(fs, path, pool));
 
-  SVN_ERR(svn_fs_fs__initialize_caches(fs, pool));
+  SVN_ERR(svn_fs_py__initialize_caches(fs, pool));
   return fs_serialized_init(fs, common_pool, pool);
 }
 
@@ -207,9 +207,9 @@ fs_open(svn_fs_t *fs, const char *path, 
 {
   SVN_ERR(initialize_fs_struct(fs));
 
-  SVN_ERR(svn_fs_fs__open(fs, path, pool));
+  SVN_ERR(svn_fs_py__open(fs, path, pool));
 
-  SVN_ERR(svn_fs_fs__initialize_caches(fs, pool));
+  SVN_ERR(svn_fs_py__initialize_caches(fs, pool));
   return fs_serialized_init(fs, common_pool, pool);
 }
 
@@ -233,7 +233,7 @@ fs_open_for_recovery(svn_fs_t *fs,
   /* Use a partly-filled fs pointer first to create 'current'.  This will fail
      if 'current' already exists, but we don't care about that. */
   fs->path = apr_pstrdup(fs->pool, path);
-  svn_error_clear(svn_io_file_create(svn_fs_fs__path_current(fs, pool),
+  svn_error_clear(svn_io_file_create(svn_fs_py__path_current(fs, pool),
                                      "0 1 1\n", pool));
 
   /* Now open the filesystem properly by calling the vtable method directly. */
@@ -249,10 +249,10 @@ fs_upgrade(svn_fs_t *fs, const char *pat
 {
   SVN_ERR(svn_fs__check_fs(fs, FALSE));
   SVN_ERR(initialize_fs_struct(fs));
-  SVN_ERR(svn_fs_fs__open(fs, path, pool));
-  SVN_ERR(svn_fs_fs__initialize_caches(fs, pool));
+  SVN_ERR(svn_fs_py__open(fs, path, pool));
+  SVN_ERR(svn_fs_py__initialize_caches(fs, pool));
   SVN_ERR(fs_serialized_init(fs, common_pool, pool));
-  return svn_fs_fs__upgrade(fs, pool);
+  return svn_fs_py__upgrade(fs, pool);
 }
 
 static svn_error_t *
@@ -264,10 +264,10 @@ fs_verify(svn_fs_t *fs, const char *path
 {
   SVN_ERR(svn_fs__check_fs(fs, FALSE));
   SVN_ERR(initialize_fs_struct(fs));
-  SVN_ERR(svn_fs_fs__open(fs, path, pool));
-  SVN_ERR(svn_fs_fs__initialize_caches(fs, pool));
+  SVN_ERR(svn_fs_py__open(fs, path, pool));
+  SVN_ERR(svn_fs_py__initialize_caches(fs, pool));
   SVN_ERR(fs_serialized_init(fs, common_pool, pool));
-  return svn_fs_fs__verify(fs, cancel_func, cancel_baton, pool);
+  return svn_fs_py__verify(fs, cancel_func, cancel_baton, pool);
 }
 
 static svn_error_t *
@@ -281,10 +281,10 @@ fs_pack(svn_fs_t *fs,
 {
   SVN_ERR(svn_fs__check_fs(fs, FALSE));
   SVN_ERR(initialize_fs_struct(fs));
-  SVN_ERR(svn_fs_fs__open(fs, path, pool));
-  SVN_ERR(svn_fs_fs__initialize_caches(fs, pool));
+  SVN_ERR(svn_fs_py__open(fs, path, pool));
+  SVN_ERR(svn_fs_py__initialize_caches(fs, pool));
   SVN_ERR(fs_serialized_init(fs, pool, pool));
-  return svn_fs_fs__pack(fs, notify_func, notify_baton,
+  return svn_fs_py__pack(fs, notify_func, notify_baton,
                          cancel_func, cancel_baton, pool);
 }
 
@@ -301,7 +301,7 @@ fs_hotcopy(const char *src_path,
            svn_boolean_t clean_logs,
            apr_pool_t *pool)
 {
-  return svn_fs_fs__hotcopy(src_path, dest_path, pool);
+  return svn_fs_py__hotcopy(src_path, dest_path, pool);
 }
 
 
@@ -361,13 +361,13 @@ static fs_library_vtable_t library_vtabl
   fs_delete_fs,
   fs_hotcopy,
   fs_get_description,
-  svn_fs_fs__recover,
+  svn_fs_py__recover,
   fs_pack,
   fs_logfiles
 };
 
 svn_error_t *
-svn_fs_fs__init(const svn_version_t *loader_version,
+svn_fs_py__init(const svn_version_t *loader_version,
                 fs_library_vtable_t **vtable, apr_pool_t* common_pool)
 {
   static const svn_version_checklist_t checklist[] =



Mime
View raw message