You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@subversion.apache.org by hw...@apache.org on 2011/08/05 17:20:24 UTC
svn commit: r1154262 [4/4] - in /subversion/branches/fs-py: ./
subversion/libsvn_fs_py/
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(©root_rev, ©root_path,
+ SVN_ERR(svn_fs_py__dag_get_copyroot(©root_rev, ©root_path,
child->node,pool));
- SVN_ERR(svn_fs_fs__revision_root(©root_root, fs, copyroot_rev, pool));
+ SVN_ERR(svn_fs_py__revision_root(©root_root, fs, copyroot_rev, pool));
SVN_ERR(get_dag(©root_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(©_id, root->fs, txn_id,
+ SVN_ERR(svn_fs_py__reserve_copy_id(©_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(©root_rev, ©root_path,
+ SVN_ERR(svn_fs_py__dag_get_copyroot(©root_rev, ©root_path,
parent_path->node, pool));
- SVN_ERR(svn_fs_fs__revision_root(©root_root, root->fs,
+ SVN_ERR(svn_fs_py__revision_root(©root_root, root->fs,
copyroot_rev, pool));
SVN_ERR(get_dag(©root_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(©from_rev, node, pool));
- SVN_ERR(svn_fs_fs__dag_get_copyfrom_path(©from_path, node, pool));
+ SVN_ERR(svn_fs_py__dag_get_copyfrom_rev(©from_rev, node, pool));
+ SVN_ERR(svn_fs_py__dag_get_copyfrom_path(©from_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(©_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(©_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(©_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(©root_root, fs, copyroot_rev,
+ SVN_ERR(svn_fs_py__revision_root(©root_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(©_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(©_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,