Import trimmed svn-1.8.0-rc3

1 files changed, 2747 insertions, 0 deletions

diff --git a/subversion/libsvn_wc/diff_editor.c b/subversion/libsvn_wc/diff_editor.c
new file mode 100644
index 0000000..839241f
--- /dev/null
+++ b/subversion/libsvn_wc/diff_editor.c
@@ -0,0 +1,2747 @@
+/*
+ * diff_editor.c -- The diff editor for comparing the working copy against the
+ *                  repository.
+ *
+ * ====================================================================
+ *    Licensed to the Apache Software Foundation (ASF) under one
+ *    or more contributor license agreements.  See the NOTICE file
+ *    distributed with this work for additional information
+ *    regarding copyright ownership.  The ASF licenses this file
+ *    to you under the Apache License, Version 2.0 (the
+ *    "License"); you may not use this file except in compliance
+ *    with the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing,
+ *    software distributed under the License is distributed on an
+ *    "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ *    KIND, either express or implied.  See the License for the
+ *    specific language governing permissions and limitations
+ *    under the License.
+ * ====================================================================
+ */
+
+/*
+ * This code uses an svn_delta_editor_t editor driven by
+ * svn_wc_crawl_revisions (like the update command) to retrieve the
+ * differences between the working copy and the requested repository
+ * version. Rather than updating the working copy, this new editor creates
+ * temporary files that contain the pristine repository versions. When the
+ * crawler closes the files the editor calls back to a client layer
+ * function to compare the working copy and the temporary file. There is
+ * only ever one temporary file in existence at any time.
+ *
+ * When the crawler closes a directory, the editor then calls back to the
+ * client layer to compare any remaining files that may have been modified
+ * locally. Added directories do not have corresponding temporary
+ * directories created, as they are not needed.
+ *
+ * The diff result from this editor is a combination of the restructuring
+ * operations from the repository with the local restructurings since checking
+ * out.
+ *
+ * ### TODO: Make sure that we properly support and report multi layered
+ *           operations instead of only simple file replacements.
+ *
+ * ### TODO: Replacements where the node kind changes needs support. It
+ * mostly works when the change is in the repository, but not when it is
+ * in the working copy.
+ *
+ * ### TODO: Do we need to support copyfrom?
+ *
+ */
+
+#include <apr_hash.h>
+#include <apr_md5.h>
+
+#include <assert.h>
+
+#include "svn_error.h"
+#include "svn_pools.h"
+#include "svn_dirent_uri.h"
+#include "svn_path.h"
+#include "svn_hash.h"
+#include "svn_sorts.h"
+
+#include "private/svn_subr_private.h"
+#include "private/svn_wc_private.h"
+#include "private/svn_diff_tree.h"
+#include "private/svn_editor.h"
+
+#include "wc.h"
+#include "props.h"
+#include "adm_files.h"
+#include "translate.h"
+#include "diff.h"
+
+#include "svn_private_config.h"
+
+/*-------------------------------------------------------------------------*/
+
+
+/* Overall crawler editor baton.
+ */
+struct edit_baton_t
+{
+  /* A wc db. */
+  svn_wc__db_t *db;
+
+  /* A diff tree processor, receiving the result of the diff. */
+  const svn_diff_tree_processor_t *processor;
+
+  /* A boolean indicating whether local additions should be reported before
+     remote deletes. The processor can transform adds in deletes and deletes
+     in adds, but it can't reorder the output. */
+  svn_boolean_t local_before_remote;
+
+  /* ANCHOR/TARGET represent the base of the hierarchy to be compared. */
+  const char *target;
+  const char *anchor_abspath;
+
+  /* Target revision */
+  svn_revnum_t revnum;
+
+  /* Was the root opened? */
+  svn_boolean_t root_opened;
+
+  /* How does this diff descend as seen from target? */
+  svn_depth_t depth;
+
+  /* Should this diff ignore node ancestry? */
+  svn_boolean_t ignore_ancestry;
+
+  /* Possibly diff repos against text-bases instead of working files. */
+  svn_boolean_t diff_pristine;
+
+  /* Hash whose keys are const char * changelist names. */
+  apr_hash_t *changelist_hash;
+
+  /* Cancel function/baton */
+  svn_cancel_func_t cancel_func;
+  void *cancel_baton;
+
+  apr_pool_t *pool;
+};
+
+/* Directory level baton.
+ */
+struct dir_baton_t
+{
+  /* Reference to parent directory baton (or NULL for the root) */
+  struct dir_baton_t *parent_baton;
+
+  /* The depth at which this directory should be diffed. */
+  svn_depth_t depth;
+
+  /* The name and path of this directory as if they would be/are in the
+      local working copy. */
+  const char *name;
+  const char *relpath;
+  const char *local_abspath;
+
+  /* TRUE if the file is added by the editor drive. */
+  svn_boolean_t added;
+  /* TRUE if the node exists only on the repository side (op_depth 0 or added) */
+  svn_boolean_t repos_only;
+  /* TRUE if the node is to be compared with an unrelated node*/
+  svn_boolean_t ignoring_ancestry;
+
+  /* Processor state */
+  void *pdb;
+  svn_boolean_t skip;
+  svn_boolean_t skip_children;
+
+  svn_diff_source_t *left_src;
+  svn_diff_source_t *right_src;
+
+  apr_hash_t *local_info;
+
+  /* A hash containing the basenames of the nodes reported deleted by the
+     repository (or NULL for no values). */
+  apr_hash_t *deletes;
+
+  /* Identifies those directory elements that get compared while running
+     the crawler.  These elements should not be compared again when
+     recursively looking for local modifications.
+
+     This hash maps the basename of the node to an unimportant value.
+
+     If the directory's properties have been compared, an item with hash
+     key of "" will be present in the hash. */
+  apr_hash_t *compared;
+
+  /* The list of incoming BASE->repos propchanges. */
+  apr_array_header_t *propchanges;
+
+  /* Has a change on regular properties */
+  svn_boolean_t has_propchange;
+
+  /* The overall crawler editor baton. */
+  struct edit_baton_t *eb;
+
+  apr_pool_t *pool;
+  int users;
+};
+
+/* File level baton.
+ */
+struct file_baton_t
+{
+  struct dir_baton_t *parent_baton;
+
+  /* The name and path of this file as if they would be/are in the
+     parent directory, diff session and local working copy. */
+  const char *name;
+  const char *relpath;
+  const char *local_abspath;
+
+  /* Processor state */
+  void *pfb;
+  svn_boolean_t skip;
+
+  /* TRUE if the file is added by the editor drive. */
+  svn_boolean_t added;
+  /* TRUE if the node exists only on the repository side (op_depth 0 or added) */
+  svn_boolean_t repos_only;
+  /* TRUE if the node is to be compared with an unrelated node*/
+  svn_boolean_t ignoring_ancestry;
+
+  const svn_diff_source_t *left_src;
+  const svn_diff_source_t *right_src;
+
+  /* The list of incoming BASE->repos propchanges. */
+  apr_array_header_t *propchanges;
+
+  /* Has a change on regular properties */
+  svn_boolean_t has_propchange;
+
+  /* The current BASE checksum and props */
+  const svn_checksum_t *base_checksum;
+  apr_hash_t *base_props;
+
+  /* The resulting from apply_textdelta */
+  const char *temp_file_path;
+  unsigned char result_digest[APR_MD5_DIGESTSIZE];
+
+  /* The overall crawler editor baton. */
+  struct edit_baton_t *eb;
+
+  apr_pool_t *pool;
+};
+
+/* Create a new edit baton. TARGET_PATH/ANCHOR are working copy paths
+ * that describe the root of the comparison. CALLBACKS/CALLBACK_BATON
+ * define the callbacks to compare files. DEPTH defines if and how to
+ * descend into subdirectories; see public doc string for exactly how.
+ * IGNORE_ANCESTRY defines whether to utilize node ancestry when
+ * calculating diffs.  USE_TEXT_BASE defines whether to compare
+ * against working files or text-bases.  REVERSE_ORDER defines which
+ * direction to perform the diff.
+ *
+ * CHANGELIST_FILTER is a list of const char * changelist names, used to
+ * filter diff output responses to only those items in one of the
+ * specified changelists, empty (or NULL altogether) if no changelist
+ * filtering is requested.
+ */
+static svn_error_t *
+make_edit_baton(struct edit_baton_t **edit_baton,
+                svn_wc__db_t *db,
+                const char *anchor_abspath,
+                const char *target,
+                const svn_wc_diff_callbacks4_t *callbacks,
+                void *callback_baton,
+                svn_depth_t depth,
+                svn_boolean_t ignore_ancestry,
+                svn_boolean_t show_copies_as_adds,
+                svn_boolean_t use_text_base,
+                svn_boolean_t reverse_order,
+                const apr_array_header_t *changelist_filter,
+                svn_cancel_func_t cancel_func,
+                void *cancel_baton,
+                apr_pool_t *pool)
+{
+  apr_hash_t *changelist_hash = NULL;
+  struct edit_baton_t *eb;
+  const svn_diff_tree_processor_t *processor;
+
+  SVN_ERR_ASSERT(svn_dirent_is_absolute(anchor_abspath));
+
+  if (changelist_filter && changelist_filter->nelts)
+    SVN_ERR(svn_hash_from_cstring_keys(&changelist_hash, changelist_filter,
+                                       pool));
+
+  SVN_ERR(svn_wc__wrap_diff_callbacks(&processor,
+                                      callbacks, callback_baton, TRUE,
+                                      pool, pool));
+
+  if (reverse_order)
+    processor = svn_diff__tree_processor_reverse_create(processor, NULL, pool);
+
+  /* --show-copies-as-adds implies --notice-ancestry */
+  if (show_copies_as_adds)
+    ignore_ancestry = FALSE;
+
+  if (! show_copies_as_adds)
+    processor = svn_diff__tree_processor_copy_as_changed_create(processor,
+                                                                pool);
+
+  eb = apr_pcalloc(pool, sizeof(*eb));
+  eb->db = db;
+  eb->anchor_abspath = apr_pstrdup(pool, anchor_abspath);
+  eb->target = apr_pstrdup(pool, target);
+  eb->processor = processor;
+  eb->depth = depth;
+  eb->ignore_ancestry = ignore_ancestry;
+  eb->local_before_remote = reverse_order;
+  eb->diff_pristine = use_text_base;
+  eb->changelist_hash = changelist_hash;
+  eb->cancel_func = cancel_func;
+  eb->cancel_baton = cancel_baton;
+  eb->pool = pool;
+
+  *edit_baton = eb;
+  return SVN_NO_ERROR;
+}
+
+/* Create a new directory baton.  PATH is the directory path,
+ * including anchor_path.  ADDED is set if this directory is being
+ * added rather than replaced.  PARENT_BATON is the baton of the
+ * parent directory, it will be null if this is the root of the
+ * comparison hierarchy.  The directory and its parent may or may not
+ * exist in the working copy.  EDIT_BATON is the overall crawler
+ * editor baton.
+ */
+static struct dir_baton_t *
+make_dir_baton(const char *path,
+               struct dir_baton_t *parent_baton,
+               struct edit_baton_t *eb,
+               svn_boolean_t added,
+               svn_depth_t depth,
+               apr_pool_t *result_pool)
+{
+  apr_pool_t *dir_pool = svn_pool_create(parent_baton ? parent_baton->pool
+                                                      : eb->pool);
+  struct dir_baton_t *db = apr_pcalloc(dir_pool, sizeof(*db));
+
+  db->parent_baton = parent_baton;
+
+  /* Allocate 1 string for using as 3 strings */
+  db->local_abspath = svn_dirent_join(eb->anchor_abspath, path, dir_pool);
+  db->relpath = svn_dirent_skip_ancestor(eb->anchor_abspath, db->local_abspath);
+  db->name = svn_dirent_basename(db->relpath, NULL);
+
+  db->eb = eb;
+  db->added = added;
+  db->depth = depth;
+  db->pool = dir_pool;
+  db->propchanges = apr_array_make(dir_pool, 8, sizeof(svn_prop_t));
+  db->compared = apr_hash_make(dir_pool);
+
+  if (parent_baton != NULL)
+    {
+      parent_baton->users++;
+    }
+
+  db->users = 1;
+
+  return db;
+}
+
+/* Create a new file baton.  PATH is the file path, including
+ * anchor_path.  ADDED is set if this file is being added rather than
+ * replaced.  PARENT_BATON is the baton of the parent directory.
+ * The directory and its parent may or may not exist in the working copy.
+ */
+static struct file_baton_t *
+make_file_baton(const char *path,
+                svn_boolean_t added,
+                struct dir_baton_t *parent_baton,
+                apr_pool_t *result_pool)
+{
+  apr_pool_t *file_pool = svn_pool_create(result_pool);
+  struct file_baton_t *fb = apr_pcalloc(file_pool, sizeof(*fb));
+  struct edit_baton_t *eb = parent_baton->eb;
+
+  fb->eb = eb;
+  fb->parent_baton = parent_baton;
+  fb->parent_baton->users++;
+
+  /* Allocate 1 string for using as 3 strings */
+  fb->local_abspath = svn_dirent_join(eb->anchor_abspath, path, file_pool);
+  fb->relpath = svn_dirent_skip_ancestor(eb->anchor_abspath, fb->local_abspath);
+  fb->name = svn_dirent_basename(fb->relpath, NULL);
+
+  fb->added = added;
+  fb->pool = file_pool;
+  fb->propchanges  = apr_array_make(file_pool, 8, sizeof(svn_prop_t));
+
+  return fb;
+}
+
+/* Destroy DB when there are no more registered users */
+static svn_error_t *
+maybe_done(struct dir_baton_t *db)
+{
+  db->users--;
+
+  if (!db->users)
+    {
+      struct dir_baton_t *pb = db->parent_baton;
+
+      svn_pool_clear(db->pool);
+
+      if (pb != NULL)
+        SVN_ERR(maybe_done(pb));
+    }
+
+  return SVN_NO_ERROR;
+}
+
+/* Standard check to see if a node is represented in the local working copy */
+#define NOT_PRESENT(status)                                    \
+            ((status) == svn_wc__db_status_not_present          \
+             || (status) == svn_wc__db_status_excluded          \
+             || (status) == svn_wc__db_status_server_excluded)
+
+svn_error_t *
+svn_wc__diff_base_working_diff(svn_wc__db_t *db,
+                               const char *local_abspath,
+                               const char *relpath,
+                               svn_revnum_t revision,
+                               apr_hash_t *changelist_hash,
+                               const svn_diff_tree_processor_t *processor,
+                               void *processor_dir_baton,
+                               svn_boolean_t diff_pristine,
+                               svn_cancel_func_t cancel_func,
+                               void *cancel_baton,
+                               apr_pool_t *scratch_pool)
+{
+  void *file_baton = NULL;
+  svn_boolean_t skip = FALSE;
+  svn_wc__db_status_t status;
+  svn_revnum_t db_revision;
+  svn_boolean_t had_props;
+  svn_boolean_t props_mod;
+  svn_boolean_t files_same = FALSE;
+  svn_wc__db_status_t base_status;
+  const svn_checksum_t *working_checksum;
+  const svn_checksum_t *checksum;
+  svn_filesize_t recorded_size;
+  apr_time_t recorded_time;
+  const char *pristine_file;
+  const char *local_file;
+  svn_diff_source_t *left_src;
+  svn_diff_source_t *right_src;
+  apr_hash_t *base_props;
+  apr_hash_t *local_props;
+  apr_array_header_t *prop_changes;
+  const char *changelist;
+
+  SVN_ERR(svn_wc__db_read_info(&status, NULL, &db_revision, NULL, NULL, NULL,
+                               NULL, NULL, NULL, NULL, &working_checksum, NULL,
+                               NULL, NULL, NULL, NULL, NULL, &recorded_size,
+                               &recorded_time, &changelist, NULL, NULL,
+                               &had_props, &props_mod, NULL, NULL, NULL,
+                               db, local_abspath, scratch_pool, scratch_pool));
+  checksum = working_checksum;
+
+  assert(status == svn_wc__db_status_normal
+         || status == svn_wc__db_status_added
+         || (status == svn_wc__db_status_deleted && diff_pristine));
+
+  /* If the item is not a member of a specified changelist (and there are
+     some specified changelists), skip it. */
+  if (changelist_hash && !svn_hash_gets(changelist_hash, changelist))
+    return SVN_NO_ERROR;
+
+
+  if (status != svn_wc__db_status_normal)
+    {
+      SVN_ERR(svn_wc__db_base_get_info(&base_status, NULL, &db_revision,
+                                       NULL, NULL, NULL, NULL, NULL, NULL,
+                                       NULL, &checksum, NULL, NULL, &had_props,
+                                       NULL, NULL,
+                                       db, local_abspath,
+                                       scratch_pool, scratch_pool));
+      recorded_size = SVN_INVALID_FILESIZE;
+      recorded_time = 0;
+      props_mod = TRUE; /* Requires compare */
+    }
+  else if (diff_pristine)
+    files_same = TRUE;
+  else
+    {
+      const svn_io_dirent2_t *dirent;
+
+      SVN_ERR(svn_io_stat_dirent2(&dirent, local_abspath,
+                                  FALSE /* verify truename */,
+                                  TRUE /* ingore_enoent */,
+                                  scratch_pool, scratch_pool));
+
+      if (dirent->kind == svn_node_file
+          && dirent->filesize == recorded_size
+          && dirent->mtime == recorded_time)
+        {
+          files_same = TRUE;
+        }
+    }
+
+  if (files_same && !props_mod)
+    return SVN_NO_ERROR; /* Cheap exit */
+
+  assert(checksum);
+
+  if (!SVN_IS_VALID_REVNUM(revision))
+    revision = db_revision;
+
+  left_src = svn_diff__source_create(revision, scratch_pool);
+  right_src = svn_diff__source_create(SVN_INVALID_REVNUM, scratch_pool);
+
+  SVN_ERR(processor->file_opened(&file_baton, &skip, relpath,
+                                 left_src,
+                                 right_src,
+                                 NULL /* copyfrom_src */,
+                                 processor_dir_baton,
+                                 processor,
+                                 scratch_pool, scratch_pool));
+
+  if (skip)
+    return SVN_NO_ERROR;
+
+  SVN_ERR(svn_wc__db_pristine_get_path(&pristine_file,
+                                       db, local_abspath, checksum,
+                                       scratch_pool, scratch_pool));
+
+  if (diff_pristine)
+    SVN_ERR(svn_wc__db_pristine_get_path(&local_file,
+                                         db, local_abspath,
+                                         working_checksum,
+                                         scratch_pool, scratch_pool));
+  else if (! (had_props || props_mod))
+    local_file = local_abspath;
+  else if (files_same)
+    local_file = pristine_file;
+  else
+    SVN_ERR(svn_wc__internal_translated_file(
+                            &local_file, local_abspath,
+                            db, local_abspath,
+                            SVN_WC_TRANSLATE_TO_NF
+                                | SVN_WC_TRANSLATE_USE_GLOBAL_TMP,
+                            cancel_func, cancel_baton,
+                            scratch_pool, scratch_pool));
+
+  if (! files_same)
+    SVN_ERR(svn_io_files_contents_same_p(&files_same, local_file,
+                                         pristine_file, scratch_pool));
+
+  if (had_props)
+    SVN_ERR(svn_wc__db_base_get_props(&base_props, db, local_abspath,
+                                      scratch_pool, scratch_pool));
+  else
+    base_props = apr_hash_make(scratch_pool);
+
+  if (status == svn_wc__db_status_normal && (diff_pristine || !props_mod))
+    local_props = base_props;
+  else if (diff_pristine)
+    SVN_ERR(svn_wc__db_read_pristine_props(&local_props, db, local_abspath,
+                                           scratch_pool, scratch_pool));
+  else
+    SVN_ERR(svn_wc__db_read_props(&local_props, db, local_abspath,
+                                  scratch_pool, scratch_pool));
+
+  SVN_ERR(svn_prop_diffs(&prop_changes, local_props, base_props, scratch_pool));
+
+  if (prop_changes->nelts || !files_same)
+    {
+      SVN_ERR(processor->file_changed(relpath,
+                                      left_src,
+                                      right_src,
+                                      pristine_file,
+                                      local_file,
+                                      base_props,
+                                      local_props,
+                                      ! files_same,
+                                      prop_changes,
+                                      file_baton,
+                                      processor,
+                                      scratch_pool));
+    }
+  else
+    {
+      SVN_ERR(processor->file_closed(relpath,
+                                     left_src,
+                                     right_src,
+                                     file_baton,
+                                     processor,
+                                     scratch_pool));
+    }
+
+  return SVN_NO_ERROR;
+}
+
+static svn_error_t *
+ensure_local_info(struct dir_baton_t *db,
+                  apr_pool_t *scratch_pool)
+{
+  apr_hash_t *conflicts;
+
+  if (db->local_info)
+    return SVN_NO_ERROR;
+
+  SVN_ERR(svn_wc__db_read_children_info(&db->local_info, &conflicts,
+                                        db->eb->db, db->local_abspath,
+                                        db->pool, scratch_pool));
+
+  return SVN_NO_ERROR;
+}
+
+/* Called when the directory is closed to compare any elements that have
+ * not yet been compared.  This identifies local, working copy only
+ * changes.  At this stage we are dealing with files/directories that do
+ * exist in the working copy.
+ *
+ * DIR_BATON is the baton for the directory.
+ */
+static svn_error_t *
+walk_local_nodes_diff(struct edit_baton_t *eb,
+                      const char *local_abspath,
+                      const char *path,
+                      svn_depth_t depth,
+                      apr_hash_t *compared,
+                      void *parent_baton,
+                      apr_pool_t *scratch_pool)
+{
+  svn_wc__db_t *db = eb->db;
+  svn_boolean_t in_anchor_not_target;
+  apr_pool_t *iterpool;
+  void *dir_baton = NULL;
+  svn_boolean_t skip = FALSE;
+  svn_boolean_t skip_children = FALSE;
+  svn_revnum_t revision;
+  svn_boolean_t props_mod;
+  svn_diff_source_t *left_src;
+  svn_diff_source_t *right_src;
+
+  /* Everything we do below is useless if we are comparing to BASE. */
+  if (eb->diff_pristine)
+    return SVN_NO_ERROR;
+
+  /* Determine if this is the anchor directory if the anchor is different
+     to the target. When the target is a file, the anchor is the parent
+     directory and if this is that directory the non-target entries must be
+     skipped. */
+  in_anchor_not_target = ((*path == '\0') && (*eb->target != '\0'));
+
+  iterpool = svn_pool_create(scratch_pool);
+
+  SVN_ERR(svn_wc__db_read_info(NULL, NULL, &revision, NULL, NULL, NULL, NULL,
+                               NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
+                               NULL, NULL, NULL, NULL, NULL, NULL, NULL,
+                               NULL, &props_mod, NULL, NULL, NULL,
+                               db, local_abspath, scratch_pool, scratch_pool));
+
+  left_src = svn_diff__source_create(revision, scratch_pool);
+  right_src = svn_diff__source_create(SVN_INVALID_REVNUM, scratch_pool);
+
+  if (compared)
+    {
+      dir_baton = parent_baton;
+      skip = TRUE;
+    }
+  else if (!in_anchor_not_target)
+    SVN_ERR(eb->processor->dir_opened(&dir_baton, &skip, &skip_children,
+                                      path,
+                                      left_src,
+                                      right_src,
+                                      NULL /* copyfrom_src */,
+                                      parent_baton,
+                                      eb->processor,
+                                      scratch_pool, scratch_pool));
+
+
+  if (!skip_children && depth != svn_depth_empty)
+    {
+      apr_hash_t *nodes;
+      apr_hash_t *conflicts;
+      apr_array_header_t *children;
+      svn_depth_t depth_below_here = depth;
+      svn_boolean_t diff_files;
+      svn_boolean_t diff_dirs;
+      int i;
+
+      if (depth_below_here == svn_depth_immediates)
+        depth_below_here = svn_depth_empty;
+
+      diff_files = (depth == svn_depth_unknown
+                   || depth >= svn_depth_files);
+      diff_dirs = (depth == svn_depth_unknown
+                   || depth >= svn_depth_immediates);
+
+      SVN_ERR(svn_wc__db_read_children_info(&nodes, &conflicts,
+                                            db, local_abspath,
+                                            scratch_pool, iterpool));
+
+      children = svn_sort__hash(nodes, svn_sort_compare_items_lexically,
+                            scratch_pool);
+
+      for (i = 0; i < children->nelts; i++)
+        {
+          svn_sort__item_t *item = &APR_ARRAY_IDX(children, i,
+                                                  svn_sort__item_t);
+          const char *name = item->key;
+          struct svn_wc__db_info_t *info = item->value;
+
+          const char *child_abspath;
+          const char *child_relpath;
+          svn_boolean_t repos_only;
+          svn_boolean_t local_only;
+          svn_node_kind_t base_kind;
+
+          if (eb->cancel_func)
+            SVN_ERR(eb->cancel_func(eb->cancel_baton));
+
+          /* In the anchor directory, if the anchor is not the target then all
+             entries other than the target should not be diff'd. Running diff
+             on one file in a directory should not diff other files in that
+             directory. */
+          if (in_anchor_not_target && strcmp(eb->target, name))
+            continue;
+
+          if (compared && svn_hash_gets(compared, name))
+            continue;
+
+          if (NOT_PRESENT(info->status))
+            continue;
+
+          assert(info->status == svn_wc__db_status_normal
+                 || info->status == svn_wc__db_status_added
+                 || info->status == svn_wc__db_status_deleted);
+
+          svn_pool_clear(iterpool);
+          child_abspath = svn_dirent_join(local_abspath, name, iterpool);
+          child_relpath = svn_relpath_join(path, name, iterpool);
+
+          repos_only = FALSE;
+          local_only = FALSE;
+
+          if (!info->have_base)
+            {
+              local_only = TRUE; /* Only report additions */
+            }
+          else if (info->status == svn_wc__db_status_normal)
+            {
+              /* Simple diff */
+              base_kind = info->kind;
+            }
+          else if (info->status == svn_wc__db_status_deleted
+                   && (!eb->diff_pristine || !info->have_more_work))
+            {
+              svn_wc__db_status_t base_status;
+              repos_only = TRUE;
+              SVN_ERR(svn_wc__db_base_get_info(&base_status, &base_kind, NULL,
+                                               NULL, NULL, NULL, NULL, NULL,
+                                               NULL, NULL, NULL, NULL, NULL,
+                                               NULL, NULL, NULL,
+                                               db, child_abspath,
+                                               iterpool, iterpool));
+
+              if (NOT_PRESENT(base_status))
+                continue;
+            }
+          else
+            {
+              /* working status is either added or deleted */
+              svn_wc__db_status_t base_status;
+
+              SVN_ERR(svn_wc__db_base_get_info(&base_status, &base_kind, NULL,
+                                               NULL, NULL, NULL, NULL, NULL,
+                                               NULL, NULL, NULL, NULL, NULL,
+                                               NULL, NULL, NULL,
+                                               db, child_abspath,
+                                               iterpool, iterpool));
+
+              if (NOT_PRESENT(base_status))
+                local_only = TRUE;
+              else if (base_kind != info->kind || !eb->ignore_ancestry)
+                {
+                  repos_only = TRUE;
+                  local_only = TRUE;
+                }
+            }
+
+          if (eb->local_before_remote && local_only)
+            {
+              if (info->kind == svn_node_file && diff_files)
+                SVN_ERR(svn_wc__diff_local_only_file(db, child_abspath,
+                                                     child_relpath,
+                                                     eb->processor, dir_baton,
+                                                     eb->changelist_hash,
+                                                     eb->diff_pristine,
+                                                     eb->cancel_func,
+                                                     eb->cancel_baton,
+                                                     iterpool));
+              else if (info->kind == svn_node_dir && diff_dirs)
+                SVN_ERR(svn_wc__diff_local_only_dir(db, child_abspath,
+                                                    child_relpath,
+                                                    depth_below_here,
+                                                    eb->processor, dir_baton,
+                                                    eb->changelist_hash,
+                                                    eb->diff_pristine,
+                                                    eb->cancel_func,
+                                                    eb->cancel_baton,
+                                                    iterpool));
+            }
+
+          if (repos_only)
+            {
+              /* Report repository form deleted */
+              if (base_kind == svn_node_file && diff_files)
+                SVN_ERR(svn_wc__diff_base_only_file(db, child_abspath,
+                                                    child_relpath, eb->revnum,
+                                                    eb->processor, dir_baton,
+                                                    iterpool));
+              else if (base_kind == svn_node_dir && diff_dirs)
+                SVN_ERR(svn_wc__diff_base_only_dir(db, child_abspath,
+                                                   child_relpath, eb->revnum,
+                                                   depth_below_here,
+                                                   eb->processor, dir_baton,
+                                                   eb->cancel_func,
+                                                   eb->cancel_baton,
+                                                   iterpool));
+            }
+          else if (!local_only) /* Not local only nor remote only */
+            {
+              /* Diff base against actual */
+              if (info->kind == svn_node_file && diff_files)
+                {
+                  if (info->status != svn_wc__db_status_normal
+                      || !eb->diff_pristine)
+                    {
+                      SVN_ERR(svn_wc__diff_base_working_diff(
+                                                db, child_abspath,
+                                                child_relpath,
+                                                eb->revnum,
+                                                eb->changelist_hash,
+                                                eb->processor, dir_baton,
+                                                eb->diff_pristine,
+                                                eb->cancel_func,
+                                                eb->cancel_baton,
+                                                scratch_pool));
+                    }
+                }
+              else if (info->kind == svn_node_dir && diff_dirs)
+                SVN_ERR(walk_local_nodes_diff(eb, child_abspath,
+                                              child_relpath,
+                                              depth_below_here,
+                                              NULL /* compared */,
+                                              dir_baton,
+                                              scratch_pool));
+            }
+
+          if (!eb->local_before_remote && local_only)
+            {
+              if (info->kind == svn_node_file && diff_files)
+                SVN_ERR(svn_wc__diff_local_only_file(db, child_abspath,
+                                                     child_relpath,
+                                                     eb->processor, dir_baton,
+                                                     eb->changelist_hash,
+                                                     eb->diff_pristine,
+                                                     eb->cancel_func,
+                                                     eb->cancel_baton,
+                                                     iterpool));
+              else if (info->kind == svn_node_dir && diff_dirs)
+                SVN_ERR(svn_wc__diff_local_only_dir(db, child_abspath,
+                                                     child_relpath, depth_below_here,
+                                                     eb->processor, dir_baton,
+                                                     eb->changelist_hash,
+                                                     eb->diff_pristine,
+                                                     eb->cancel_func,
+                                                     eb->cancel_baton,
+                                                     iterpool));
+            }
+        }
+    }
+
+  if (compared)
+    return SVN_NO_ERROR;
+
+    /* Check for local property mods on this directory, if we haven't
+     already reported them and we aren't changelist-filted.
+     ### it should be noted that we do not currently allow directories
+     ### to be part of changelists, so if a changelist is provided, the
+     ### changelist check will always fail. */
+  if (! skip
+      && ! eb->changelist_hash
+      && ! in_anchor_not_target
+      && props_mod)
+    {
+      apr_array_header_t *propchanges;
+      apr_hash_t *left_props;
+      apr_hash_t *right_props;
+
+      SVN_ERR(svn_wc__internal_propdiff(&propchanges, &left_props,
+                                        db, local_abspath,
+                                        scratch_pool, scratch_pool));
+
+      right_props = svn_prop__patch(left_props, propchanges, scratch_pool);
+
+      SVN_ERR(eb->processor->dir_changed(path,
+                                         left_src,
+                                         right_src,
+                                         left_props,
+                                         right_props,
+                                         propchanges,
+                                         dir_baton,
+                                         eb->processor,
+                                         scratch_pool));
+    }
+  else if (! skip)
+    SVN_ERR(eb->processor->dir_closed(path,
+                                      left_src,
+                                      right_src,
+                                      dir_baton,
+                                      eb->processor,
+                                      scratch_pool));
+
+  svn_pool_destroy(iterpool);
+
+  return SVN_NO_ERROR;
+}
+
+svn_error_t *
+svn_wc__diff_local_only_file(svn_wc__db_t *db,
+                             const char *local_abspath,
+                             const char *relpath,
+                             const svn_diff_tree_processor_t *processor,
+                             void *processor_parent_baton,
+                             apr_hash_t *changelist_hash,
+                             svn_boolean_t diff_pristine,
+                             svn_cancel_func_t cancel_func,
+                             void *cancel_baton,
+                             apr_pool_t *scratch_pool)
+{
+  svn_diff_source_t *right_src;
+  svn_diff_source_t *copyfrom_src = NULL;
+  svn_wc__db_status_t status;
+  svn_node_kind_t kind;
+  const svn_checksum_t *checksum;
+  const char *original_repos_relpath;
+  svn_revnum_t original_revision;
+  const char *changelist;
+  svn_boolean_t had_props;
+  svn_boolean_t props_mod;
+  apr_hash_t *pristine_props;
+  apr_hash_t *right_props = NULL;
+  const char *pristine_file;
+  const char *translated_file;
+  svn_revnum_t revision;
+  void *file_baton = NULL;
+  svn_boolean_t skip = FALSE;
+  svn_boolean_t file_mod = TRUE;
+
+  SVN_ERR(svn_wc__db_read_info(&status, &kind, &revision, NULL, NULL, NULL,
+                               NULL, NULL, NULL, NULL, &checksum, NULL,
+                               &original_repos_relpath, NULL, NULL,
+                               &original_revision, NULL, NULL, NULL,
+                               &changelist, NULL, NULL, &had_props,
+                               &props_mod, NULL, NULL, NULL,
+                               db, local_abspath,
+                               scratch_pool, scratch_pool));
+
+  assert(kind == svn_node_file
+         && (status == svn_wc__db_status_normal
+             || status == svn_wc__db_status_added
+             || (status == svn_wc__db_status_deleted && diff_pristine)));
+
+
+  if (changelist && changelist_hash
+      && !svn_hash_gets(changelist_hash, changelist))
+    return SVN_NO_ERROR;
+
+  if (status == svn_wc__db_status_deleted)
+    {
+      assert(diff_pristine);
+
+      SVN_ERR(svn_wc__db_read_pristine_info(&status, &kind, NULL, NULL, NULL,
+                                            NULL, &checksum, NULL, &had_props,
+                                            &pristine_props,
+                                            db, local_abspath,
+                                            scratch_pool, scratch_pool));
+      props_mod = FALSE;
+    }
+  else if (!had_props)
+    pristine_props = apr_hash_make(scratch_pool);
+  else
+    SVN_ERR(svn_wc__db_read_pristine_props(&pristine_props,
+                                           db, local_abspath,
+                                           scratch_pool, scratch_pool));
+
+  if (original_repos_relpath)
+    {
+      copyfrom_src = svn_diff__source_create(original_revision, scratch_pool);
+      copyfrom_src->repos_relpath = original_repos_relpath;
+    }
+
+  if (props_mod || !SVN_IS_VALID_REVNUM(revision))
+    right_src = svn_diff__source_create(SVN_INVALID_REVNUM, scratch_pool);
+  else
+    {
+      if (diff_pristine)
+        file_mod = FALSE;
+      else
+        SVN_ERR(svn_wc__internal_file_modified_p(&file_mod, db, local_abspath,
+                                                 FALSE, scratch_pool));
+
+      if (!file_mod)
+        right_src = svn_diff__source_create(revision, scratch_pool);
+      else
+        right_src = svn_diff__source_create(SVN_INVALID_REVNUM, scratch_pool);
+    }
+
+  SVN_ERR(processor->file_opened(&file_baton, &skip,
+                                 relpath,
+                                 NULL /* left_source */,
+                                 right_src,
+                                 copyfrom_src,
+                                 processor_parent_baton,
+                                 processor,
+                                 scratch_pool, scratch_pool));
+
+  if (skip)
+    return SVN_NO_ERROR;
+
+  if (props_mod && !diff_pristine)
+    SVN_ERR(svn_wc__db_read_props(&right_props, db, local_abspath,
+                                  scratch_pool, scratch_pool));
+  else
+    right_props = svn_prop_hash_dup(pristine_props, scratch_pool);
+
+  if (checksum)
+    SVN_ERR(svn_wc__db_pristine_get_path(&pristine_file, db, local_abspath,
+                                         checksum, scratch_pool, scratch_pool));
+  else
+    pristine_file = NULL;
+
+  if (diff_pristine)
+    {
+      translated_file = pristine_file; /* No translation needed */
+    }
+  else
+    {
+      SVN_ERR(svn_wc__internal_translated_file(
+           &translated_file, local_abspath, db, local_abspath,
+           SVN_WC_TRANSLATE_TO_NF | SVN_WC_TRANSLATE_USE_GLOBAL_TMP,
+           cancel_func, cancel_baton,
+           scratch_pool, scratch_pool));
+    }
+
+  SVN_ERR(processor->file_added(relpath,
+                                copyfrom_src,
+                                right_src,
+                                copyfrom_src
+                                  ? pristine_file
+                                  : NULL,
+                                translated_file,
+                                copyfrom_src
+                                  ? pristine_props
+                                  : NULL,
+                                right_props,
+                                file_baton,
+                                processor,
+                                scratch_pool));
+
+  return SVN_NO_ERROR;
+}
+
+svn_error_t *
+svn_wc__diff_local_only_dir(svn_wc__db_t *db,
+                            const char *local_abspath,
+                            const char *relpath,
+                            svn_depth_t depth,
+                            const svn_diff_tree_processor_t *processor,
+                            void *processor_parent_baton,
+                            apr_hash_t *changelist_hash,
+                            svn_boolean_t diff_pristine,
+                            svn_cancel_func_t cancel_func,
+                            void *cancel_baton,
+                            apr_pool_t *scratch_pool)
+{
+  const apr_array_header_t *children;
+  int i;
+  apr_pool_t *iterpool;
+  void *pdb = NULL;
+  svn_boolean_t skip = FALSE;
+  svn_boolean_t skip_children = FALSE;
+  svn_diff_source_t *right_src = svn_diff__source_create(SVN_INVALID_REVNUM,
+                                                         scratch_pool);
+  svn_depth_t depth_below_here = depth;
+  apr_hash_t *nodes;
+  apr_hash_t *conflicts;
+
+  /* Report the addition of the directory's contents. */
+  iterpool = svn_pool_create(scratch_pool);
+
+  SVN_ERR(processor->dir_opened(&pdb, &skip, &skip_children,
+                                relpath,
+                                NULL,
+                                right_src,
+                                NULL /* copyfrom_src */,
+                                processor_parent_baton,
+                                processor,
+                                scratch_pool, iterpool));
+
+  SVN_ERR(svn_wc__db_read_children_info(&nodes, &conflicts, db, local_abspath,
+                                        scratch_pool, iterpool));
+
+  if (depth_below_here == svn_depth_immediates)
+    depth_below_here = svn_depth_empty;
+
+  children = svn_sort__hash(nodes, svn_sort_compare_items_lexically,
+                            scratch_pool);
+
+  for (i = 0; i < children->nelts; i++)
+    {
+      svn_sort__item_t *item = &APR_ARRAY_IDX(children, i, svn_sort__item_t);
+      const char *name = item->key;
+      struct svn_wc__db_info_t *info = item->value;
+      const char *child_abspath;
+      const char *child_relpath;
+
+      svn_pool_clear(iterpool);
+
+      if (cancel_func)
+        SVN_ERR(cancel_func(cancel_baton));
+
+      child_abspath = svn_dirent_join(local_abspath, name, iterpool);
+
+      if (NOT_PRESENT(info->status))
+        {
+          continue;
+        }
+
+      /* If comparing against WORKING, skip entries that are
+         schedule-deleted - they don't really exist. */
+      if (!diff_pristine && info->status == svn_wc__db_status_deleted)
+        continue;
+
+      child_relpath = svn_relpath_join(relpath, name, iterpool);
+
+      switch (info->kind)
+        {
+        case svn_node_file:
+        case svn_node_symlink:
+          SVN_ERR(svn_wc__diff_local_only_file(db, child_abspath,
+                                               child_relpath,
+                                               processor, pdb,
+                                               changelist_hash,
+                                               diff_pristine,
+                                               cancel_func, cancel_baton,
+                                               scratch_pool));
+          break;
+
+        case svn_node_dir:
+          if (depth > svn_depth_files || depth == svn_depth_unknown)
+            {
+              SVN_ERR(svn_wc__diff_local_only_dir(db, child_abspath,
+                                                  child_relpath, depth_below_here,
+                                                  processor, pdb,
+                                                  changelist_hash,
+                                                  diff_pristine,
+                                                  cancel_func, cancel_baton,
+                                                  iterpool));
+            }
+          break;
+
+        default:
+          break;
+        }
+    }
+
+  if (!skip)
+    {
+      apr_hash_t *right_props;
+      if (diff_pristine)
+        SVN_ERR(svn_wc__db_read_pristine_props(&right_props, db, local_abspath,
+                                               scratch_pool, scratch_pool));
+      else
+        SVN_ERR(svn_wc__get_actual_props(&right_props, db, local_abspath,
+                                         scratch_pool, scratch_pool));
+
+      SVN_ERR(processor->dir_added(relpath,
+                                   NULL /* copyfrom_src */,
+                                   right_src,
+                                   NULL,
+                                   right_props,
+                                   pdb,
+                                   processor,
+                                   iterpool));
+    }
+  svn_pool_destroy(iterpool);
+
+  return SVN_NO_ERROR;
+}
+
+/* Reports local changes. */
+static svn_error_t *
+handle_local_only(struct dir_baton_t *pb,
+                  const char *name,
+                  apr_pool_t *scratch_pool)
+{
+  struct edit_baton_t *eb = pb->eb;
+  const struct svn_wc__db_info_t *info;
+  svn_boolean_t repos_delete = (pb->deletes
+                                && svn_hash_gets(pb->deletes, name));
+
+  assert(!strchr(name, '/'));
+  assert(!pb->added || eb->ignore_ancestry);
+
+  if (pb->skip_children)
+    return SVN_NO_ERROR;
+
+  SVN_ERR(ensure_local_info(pb, scratch_pool));
+
+  info = svn_hash_gets(pb->local_info, name);
+
+  if (info == NULL || NOT_PRESENT(info->status))
+    return SVN_NO_ERROR;
+
+  switch (info->status)
+    {
+      case svn_wc__db_status_incomplete:
+        return SVN_NO_ERROR; /* Not local only */
+
+      case svn_wc__db_status_normal:
+        if (!repos_delete)
+          return SVN_NO_ERROR; /* Local and remote */
+        svn_hash_sets(pb->deletes, name, NULL);
+        break;
+
+      case svn_wc__db_status_deleted:
+        if (!(eb->diff_pristine && repos_delete))
+          return SVN_NO_ERROR;
+        break;
+
+      case svn_wc__db_status_added:
+      default:
+        break;
+    }
+
+  if (info->kind == svn_node_dir)
+    {
+      svn_depth_t depth ;
+
+      if (pb->depth == svn_depth_infinity || pb->depth == svn_depth_unknown)
+        depth = pb->depth;
+      else
+        depth = svn_depth_empty;
+
+      SVN_ERR(svn_wc__diff_local_only_dir(
+                      eb->db,
+                      svn_dirent_join(pb->local_abspath, name, scratch_pool),
+                      svn_relpath_join(pb->relpath, name, scratch_pool),
+                      repos_delete ? svn_depth_infinity : depth,
+                      eb->processor, pb->pdb,
+                      eb->changelist_hash,
+                      eb->diff_pristine,
+                      eb->cancel_func, eb->cancel_baton,
+                      scratch_pool));
+    }
+  else
+    SVN_ERR(svn_wc__diff_local_only_file(
+                      eb->db,
+                      svn_dirent_join(pb->local_abspath, name, scratch_pool),
+                      svn_relpath_join(pb->relpath, name, scratch_pool),
+                      eb->processor, pb->pdb,
+                      eb->changelist_hash,
+                      eb->diff_pristine,
+                      eb->cancel_func, eb->cancel_baton,
+                      scratch_pool));
+
+  return SVN_NO_ERROR;
+}
+
+/* Reports a file LOCAL_ABSPATH in BASE as deleted */
+svn_error_t *
+svn_wc__diff_base_only_file(svn_wc__db_t *db,
+                            const char *local_abspath,
+                            const char *relpath,
+                            svn_revnum_t revision,
+                            const svn_diff_tree_processor_t *processor,
+                            void *processor_parent_baton,
+                            apr_pool_t *scratch_pool)
+{
+  svn_wc__db_status_t status;
+  svn_node_kind_t kind;
+  const svn_checksum_t *checksum;
+  apr_hash_t *props;
+  void *file_baton = NULL;
+  svn_boolean_t skip = FALSE;
+  svn_diff_source_t *left_src;
+  const char *pristine_file;
+
+  SVN_ERR(svn_wc__db_base_get_info(&status, &kind,
+                                   SVN_IS_VALID_REVNUM(revision)
+                                        ? NULL : &revision,
+                                   NULL, NULL, NULL, NULL, NULL, NULL, NULL,
+                                   &checksum, NULL, NULL, NULL, &props, NULL,
+                                   db, local_abspath,
+                                   scratch_pool, scratch_pool));
+
+  SVN_ERR_ASSERT(status == svn_wc__db_status_normal
+                 && kind == svn_node_file
+                 && checksum);
+
+  left_src = svn_diff__source_create(revision, scratch_pool);
+
+  SVN_ERR(processor->file_opened(&file_baton, &skip,
+                                 relpath,
+                                 left_src,
+                                 NULL /* right_src */,
+                                 NULL /* copyfrom_source */,
+                                 processor_parent_baton,
+                                 processor,
+                                 scratch_pool, scratch_pool));
+
+  if (skip)
+    return SVN_NO_ERROR;
+
+  SVN_ERR(svn_wc__db_pristine_get_path(&pristine_file,
+                                       db, local_abspath, checksum,
+                                       scratch_pool, scratch_pool));
+
+  SVN_ERR(processor->file_deleted(relpath,
+                                  left_src,
+                                  pristine_file,
+                                  props,
+                                  file_baton,
+                                  processor,
+                                  scratch_pool));
+
+  return SVN_NO_ERROR;
+}
+
+svn_error_t *
+svn_wc__diff_base_only_dir(svn_wc__db_t *db,
+                           const char *local_abspath,
+                           const char *relpath,
+                           svn_revnum_t revision,
+                           svn_depth_t depth,
+                           const svn_diff_tree_processor_t *processor,
+                           void *processor_parent_baton,
+                           svn_cancel_func_t cancel_func,
+                           void *cancel_baton,
+                           apr_pool_t *scratch_pool)
+{
+  void *dir_baton = NULL;
+  svn_boolean_t skip = FALSE;
+  svn_boolean_t skip_children = FALSE;
+  svn_diff_source_t *left_src;
+  svn_revnum_t report_rev = revision;
+
+  if (!SVN_IS_VALID_REVNUM(report_rev))
+    SVN_ERR(svn_wc__db_base_get_info(NULL, NULL, &report_rev, NULL, NULL, NULL,
+                                     NULL, NULL, NULL, NULL, NULL, NULL, NULL,
+                                     NULL, NULL, NULL,
+                                     db, local_abspath,
+                                     scratch_pool, scratch_pool));
+
+  left_src = svn_diff__source_create(report_rev, scratch_pool);
+
+  SVN_ERR(processor->dir_opened(&dir_baton, &skip, &skip_children,
+                                relpath,
+                                left_src,
+                                NULL /* right_src */,
+                                NULL /* copyfrom_src */,
+                                processor_parent_baton,
+                                processor,
+                                scratch_pool, scratch_pool));
+
+  if (!skip_children && (depth == svn_depth_unknown || depth > svn_depth_empty))
+    {
+      apr_hash_t *nodes;
+      apr_pool_t *iterpool = svn_pool_create(scratch_pool);
+      apr_array_header_t *children;
+      int i;
+
+      SVN_ERR(svn_wc__db_base_get_children_info(&nodes, db, local_abspath,
+                                                scratch_pool, iterpool));
+
+      children = svn_sort__hash(nodes, svn_sort_compare_items_lexically,
+                                scratch_pool);
+
+      for (i = 0; i < children->nelts; i++)
+        {
+          svn_sort__item_t *item = &APR_ARRAY_IDX(children, i,
+                                                  svn_sort__item_t);
+          const char *name = item->key;
+          struct svn_wc__db_base_info_t *info = item->value;
+          const char *child_abspath;
+          const char *child_relpath;
+
+          if (info->status != svn_wc__db_status_normal)
+            continue;
+
+          if (cancel_func)
+            SVN_ERR(cancel_func(cancel_baton));
+
+          svn_pool_clear(iterpool);
+
+          child_abspath = svn_dirent_join(local_abspath, name, iterpool);
+          child_relpath = svn_relpath_join(relpath, name, iterpool);
+
+          switch (info->kind)
+            {
+              case svn_node_file:
+              case svn_node_symlink:
+                SVN_ERR(svn_wc__diff_base_only_file(db, child_abspath,
+                                                    child_relpath,
+                                                    revision,
+                                                    processor, dir_baton,
+                                                    iterpool));
+                break;
+              case svn_node_dir:
+                if (depth > svn_depth_files || depth == svn_depth_unknown)
+                  {
+                    svn_depth_t depth_below_here = depth;
+
+                    if (depth_below_here == svn_depth_immediates)
+                      depth_below_here = svn_depth_empty;
+
+                    SVN_ERR(svn_wc__diff_base_only_dir(db, child_abspath,
+                                                       child_relpath,
+                                                       revision,
+                                                       depth_below_here,
+                                                       processor, dir_baton,
+                                                       cancel_func,
+                                                       cancel_baton,
+                                                       iterpool));
+                  }
+                break;
+
+              default:
+                break;
+            }
+        }
+    }
+
+  if (!skip)
+    {
+      apr_hash_t *props;
+      SVN_ERR(svn_wc__db_base_get_props(&props, db, local_abspath,
+                                        scratch_pool, scratch_pool));
+
+      SVN_ERR(processor->dir_deleted(relpath,
+                                     left_src,
+                                     props,
+                                     dir_baton,
+                                     processor,
+                                     scratch_pool));
+    }
+
+  return SVN_NO_ERROR;
+}
+
+/* An svn_delta_editor_t function. */
+static svn_error_t *
+set_target_revision(void *edit_baton,
+                    svn_revnum_t target_revision,
+                    apr_pool_t *pool)
+{
+  struct edit_baton_t *eb = edit_baton;
+  eb->revnum = target_revision;
+
+  return SVN_NO_ERROR;
+}
+
+/* An svn_delta_editor_t function. The root of the comparison hierarchy */
+static svn_error_t *
+open_root(void *edit_baton,
+          svn_revnum_t base_revision,
+          apr_pool_t *dir_pool,
+          void **root_baton)
+{
+  struct edit_baton_t *eb = edit_baton;
+  struct dir_baton_t *db;
+
+  eb->root_opened = TRUE;
+  db = make_dir_baton("", NULL, eb, FALSE, eb->depth, dir_pool);
+  *root_baton = db;
+
+  if (eb->target[0] == '\0')
+    {
+      db->left_src = svn_diff__source_create(eb->revnum, db->pool);
+      db->right_src = svn_diff__source_create(SVN_INVALID_REVNUM, db->pool);
+
+      SVN_ERR(eb->processor->dir_opened(&db->pdb, &db->skip,
+                                        &db->skip_children,
+                                        "",
+                                        db->left_src,
+                                        db->right_src,
+                                        NULL /* copyfrom_source */,
+                                        NULL /* parent_baton */,
+                                        eb->processor,
+                                        db->pool, db->pool));
+    }
+  else
+    db->skip = TRUE; /* Skip this, but not the children */
+
+  return SVN_NO_ERROR;
+}
+
+/* An svn_delta_editor_t function. */
+static svn_error_t *
+delete_entry(const char *path,
+             svn_revnum_t base_revision,
+             void *parent_baton,
+             apr_pool_t *pool)
+{
+  struct dir_baton_t *pb = parent_baton;
+  const char *name = svn_dirent_basename(path, pb->pool);
+
+  if (!pb->deletes)
+    pb->deletes = apr_hash_make(pb->pool);
+
+  svn_hash_sets(pb->deletes, name, "");
+  return SVN_NO_ERROR;
+}
+
+/* An svn_delta_editor_t function. */
+static svn_error_t *
+add_directory(const char *path,
+              void *parent_baton,
+              const char *copyfrom_path,
+              svn_revnum_t copyfrom_revision,
+              apr_pool_t *dir_pool,
+              void **child_baton)
+{
+  struct dir_baton_t *pb = parent_baton;
+  struct edit_baton_t *eb = pb->eb;
+  struct dir_baton_t *db;
+  svn_depth_t subdir_depth = (pb->depth == svn_depth_immediates)
+                              ? svn_depth_empty : pb->depth;
+
+  db = make_dir_baton(path, pb, pb->eb, TRUE, subdir_depth,
+                      dir_pool);
+  *child_baton = db;
+
+  if (pb->repos_only || !eb->ignore_ancestry)
+    db->repos_only = TRUE;
+  else
+    {
+      struct svn_wc__db_info_t *info;
+      SVN_ERR(ensure_local_info(pb, dir_pool));
+
+      info = svn_hash_gets(pb->local_info, db->name);
+
+      if (!info || info->kind != svn_node_dir || NOT_PRESENT(info->status))
+        db->repos_only = TRUE;
+
+      if (!db->repos_only && info->status != svn_wc__db_status_added)
+        db->repos_only = TRUE;
+
+      if (!db->repos_only)
+        {
+          db->right_src = svn_diff__source_create(SVN_INVALID_REVNUM, db->pool);
+          db->ignoring_ancestry = TRUE;
+
+          svn_hash_sets(pb->compared, apr_pstrdup(pb->pool, db->name), "");
+        }
+    }
+
+  db->left_src = svn_diff__source_create(eb->revnum, db->pool);
+
+  if (eb->local_before_remote && !db->repos_only && !db->ignoring_ancestry)
+    SVN_ERR(handle_local_only(pb, db->name, dir_pool));
+
+  SVN_ERR(eb->processor->dir_opened(&db->pdb, &db->skip, &db->skip_children,
+                                    db->relpath,
+                                    db->left_src,
+                                    db->right_src,
+                                    NULL /* copyfrom src */,
+                                    pb->pdb,
+                                    eb->processor,
+                                    db->pool, db->pool));
+
+  return SVN_NO_ERROR;
+}
+
+/* An svn_delta_editor_t function. */
+static svn_error_t *
+open_directory(const char *path,
+               void *parent_baton,
+               svn_revnum_t base_revision,
+               apr_pool_t *dir_pool,
+               void **child_baton)
+{
+  struct dir_baton_t *pb = parent_baton;
+  struct edit_baton_t *eb = pb->eb;
+  struct dir_baton_t *db;
+  svn_depth_t subdir_depth = (pb->depth == svn_depth_immediates)
+                              ? svn_depth_empty : pb->depth;
+
+  /* Allocate path from the parent pool since the memory is used in the
+     parent's compared hash */
+  db = make_dir_baton(path, pb, pb->eb, FALSE, subdir_depth, dir_pool);
+  *child_baton = db;
+
+  if (pb->repos_only)
+    db->repos_only = TRUE;
+  else
+    {
+      struct svn_wc__db_info_t *info;
+      SVN_ERR(ensure_local_info(pb, dir_pool));
+
+      info = svn_hash_gets(pb->local_info, db->name);
+
+      if (!info || info->kind != svn_node_dir || NOT_PRESENT(info->status))
+        db->repos_only = TRUE;
+
+      if (!db->repos_only)
+        switch (info->status)
+          {
+            case svn_wc__db_status_normal:
+              break;
+            case svn_wc__db_status_deleted:
+              db->repos_only = TRUE;
+
+              if (!info->have_more_work)
+                svn_hash_sets(pb->compared,
+                              apr_pstrdup(pb->pool, db->name), "");
+              break;
+            case svn_wc__db_status_added:
+              if (eb->ignore_ancestry)
+                db->ignoring_ancestry = TRUE;
+              else
+                db->repos_only = TRUE;
+              break;
+            default:
+              SVN_ERR_MALFUNCTION();
+        }
+
+      if (!db->repos_only)
+        {
+          db->right_src = svn_diff__source_create(SVN_INVALID_REVNUM, db->pool);
+          svn_hash_sets(pb->compared, apr_pstrdup(pb->pool, db->name), "");
+        }
+    }
+
+  db->left_src = svn_diff__source_create(eb->revnum, db->pool);
+
+  if (eb->local_before_remote && !db->repos_only && !db->ignoring_ancestry)
+    SVN_ERR(handle_local_only(pb, db->name, dir_pool));
+
+  SVN_ERR(eb->processor->dir_opened(&db->pdb, &db->skip, &db->skip_children,
+                                    db->relpath,
+                                    db->left_src,
+                                    db->right_src,
+                                    NULL /* copyfrom src */,
+                                    pb->pdb,
+                                    eb->processor,
+                                    db->pool, db->pool));
+
+  return SVN_NO_ERROR;
+}
+
+
+/* An svn_delta_editor_t function.  When a directory is closed, all the
+ * directory elements that have been added or replaced will already have been
+ * diff'd. However there may be other elements in the working copy
+ * that have not yet been considered.  */
+static svn_error_t *
+close_directory(void *dir_baton,
+                apr_pool_t *pool)
+{
+  struct dir_baton_t *db = dir_baton;
+  struct dir_baton_t *pb = db->parent_baton;
+  struct edit_baton_t *eb = db->eb;
+  apr_pool_t *scratch_pool = db->pool;
+  svn_boolean_t reported_closed = FALSE;
+
+  if (!db->skip_children && db->deletes && apr_hash_count(db->deletes))
+    {
+      apr_pool_t *iterpool = svn_pool_create(scratch_pool);
+      apr_array_header_t *children;
+      int i;
+      children = svn_sort__hash(db->deletes, svn_sort_compare_items_lexically,
+                                scratch_pool);
+
+      for (i = 0; i < children->nelts; i++)
+        {
+          svn_sort__item_t *item = &APR_ARRAY_IDX(children, i,
+                                                  svn_sort__item_t);
+          const char *name = item->key;
+
+          svn_pool_clear(iterpool);
+          SVN_ERR(handle_local_only(db, name, iterpool));
+
+          svn_hash_sets(db->compared, name, "");
+        }
+
+      svn_pool_destroy(iterpool);
+    }
+
+  /* Report local modifications for this directory.  Skip added
+     directories since they can only contain added elements, all of
+     which have already been diff'd. */
+  if (!db->repos_only && !db->skip_children)
+  {
+    SVN_ERR(walk_local_nodes_diff(eb,
+                                  db->local_abspath,
+                                  db->relpath,
+                                  db->depth,
+                                  db->compared,
+                                  db->pdb,
+                                  scratch_pool));
+  }
+
+  /* Report the property changes on the directory itself, if necessary. */
+  if (db->skip)
+    {
+      /* Diff processor requested no directory details */
+    }
+  else if (db->propchanges->nelts > 0 || db->repos_only)
+    {
+      apr_hash_t *repos_props;
+
+      if (db->added)
+        {
+          repos_props = apr_hash_make(scratch_pool);
+        }
+      else
+        {
+          SVN_ERR(svn_wc__db_base_get_props(&repos_props,
+                                            eb->db, db->local_abspath,
+                                            scratch_pool, scratch_pool));
+        }
+
+      /* Add received property changes and entry props */
+      if (db->propchanges->nelts)
+        repos_props = svn_prop__patch(repos_props, db->propchanges,
+                                      scratch_pool);
+
+      if (db->repos_only)
+        {
+          SVN_ERR(eb->processor->dir_deleted(db->relpath,
+                                             db->left_src,
+                                             repos_props,
+                                             db->pdb,
+                                             eb->processor,
+                                             scratch_pool));
+          reported_closed = TRUE;
+        }
+      else
+        {
+          apr_hash_t *local_props;
+          apr_array_header_t *prop_changes;
+
+          if (eb->diff_pristine)
+            SVN_ERR(svn_wc__db_read_pristine_info(NULL, NULL, NULL, NULL, NULL,
+                                                  NULL, NULL, NULL, NULL,
+                                                  &local_props,
+                                                  eb->db, db->local_abspath,
+                                                  scratch_pool, scratch_pool));
+          else
+            SVN_ERR(svn_wc__db_read_props(&local_props,
+                                          eb->db, db->local_abspath,
+                                          scratch_pool, scratch_pool));
+
+          SVN_ERR(svn_prop_diffs(&prop_changes, local_props, repos_props,
+                                 scratch_pool));
+
+          /* ### as a good diff processor we should now only report changes
+                 if there are non-entry changes, but for now we stick to
+                 compatibility */
+
+          if (prop_changes->nelts)
+            {
+              SVN_ERR(eb->processor->dir_changed(db->relpath,
+                                                 db->left_src,
+                                                 db->right_src,
+                                                 repos_props,
+                                                 local_props,
+                                                 prop_changes,
+                                                 db->pdb,
+                                                 eb->processor,
+                                                 scratch_pool));
+              reported_closed = TRUE;
+          }
+        }
+    }
+
+  /* Mark this directory as compared in the parent directory's baton,
+     unless this is the root of the comparison. */
+  if (!reported_closed && !db->skip)
+    SVN_ERR(eb->processor->dir_closed(db->relpath,
+                                      db->left_src,
+                                      db->right_src,
+                                      db->pdb,
+                                      eb->processor,
+                                      scratch_pool));
+
+  if (pb && !eb->local_before_remote && !db->repos_only && !db->ignoring_ancestry)
+    SVN_ERR(handle_local_only(pb, db->name, scratch_pool));
+
+  SVN_ERR(maybe_done(db)); /* destroys scratch_pool */
+
+  return SVN_NO_ERROR;
+}
+
+/* An svn_delta_editor_t function. */
+static svn_error_t *
+add_file(const char *path,
+         void *parent_baton,
+         const char *copyfrom_path,
+         svn_revnum_t copyfrom_revision,
+         apr_pool_t *file_pool,
+         void **file_baton)
+{
+  struct dir_baton_t *pb = parent_baton;
+  struct edit_baton_t *eb = pb->eb;
+  struct file_baton_t *fb;
+
+  fb = make_file_baton(path, TRUE, pb, file_pool);
+  *file_baton = fb;
+
+  if (pb->skip_children)
+    {
+      fb->skip = TRUE;
+      return SVN_NO_ERROR;
+    }
+  else if (pb->repos_only || !eb->ignore_ancestry)
+    fb->repos_only = TRUE;
+  else
+    {
+      struct svn_wc__db_info_t *info;
+      SVN_ERR(ensure_local_info(pb, file_pool));
+
+      info = svn_hash_gets(pb->local_info, fb->name);
+
+      if (!info || info->kind != svn_node_file || NOT_PRESENT(info->status))
+        fb->repos_only = TRUE;
+
+      if (!fb->repos_only && info->status != svn_wc__db_status_added)
+        fb->repos_only = TRUE;
+
+      if (!fb->repos_only)
+        {
+          /* Add this path to the parent directory's list of elements that
+             have been compared. */
+          fb->right_src = svn_diff__source_create(SVN_INVALID_REVNUM, fb->pool);
+          fb->ignoring_ancestry = TRUE;
+
+          svn_hash_sets(pb->compared, apr_pstrdup(pb->pool, fb->name), "");
+        }
+    }
+
+  fb->left_src = svn_diff__source_create(eb->revnum, fb->pool);
+
+  SVN_ERR(eb->processor->file_opened(&fb->pfb, &fb->skip,
+                                     fb->relpath,
+                                     fb->left_src,
+                                     fb->right_src,
+                                     NULL /* copyfrom src */,
+                                     pb->pdb,
+                                     eb->processor,
+                                     fb->pool, fb->pool));
+
+  return SVN_NO_ERROR;
+}
+
+/* An svn_delta_editor_t function. */
+static svn_error_t *
+open_file(const char *path,
+          void *parent_baton,
+          svn_revnum_t base_revision,
+          apr_pool_t *file_pool,
+          void **file_baton)
+{
+  struct dir_baton_t *pb = parent_baton;
+  struct edit_baton_t *eb = pb->eb;
+  struct file_baton_t *fb;
+
+  fb = make_file_baton(path, FALSE, pb, file_pool);
+  *file_baton = fb;
+
+  if (pb->skip_children)
+    fb->skip = TRUE;
+  else if (pb->repos_only)
+    fb->repos_only = TRUE;
+  else
+    {
+      struct svn_wc__db_info_t *info;
+      SVN_ERR(ensure_local_info(pb, file_pool));
+
+      info = svn_hash_gets(pb->local_info, fb->name);
+
+      if (!info || info->kind != svn_node_file || NOT_PRESENT(info->status))
+        fb->repos_only = TRUE;
+
+      if (!fb->repos_only)
+        switch (info->status)
+          {
+            case svn_wc__db_status_normal:
+              break;
+            case svn_wc__db_status_deleted:
+              fb->repos_only = TRUE;
+              if (!info->have_more_work)
+                svn_hash_sets(pb->compared,
+                              apr_pstrdup(pb->pool, fb->name), "");
+              break;
+            case svn_wc__db_status_added:
+              if (eb->ignore_ancestry)
+                fb->ignoring_ancestry = TRUE;
+              else
+                fb->repos_only = TRUE;
+              break;
+            default:
+              SVN_ERR_MALFUNCTION();
+        }
+
+      if (!fb->repos_only)
+        {
+          /* Add this path to the parent directory's list of elements that
+             have been compared. */
+          fb->right_src = svn_diff__source_create(SVN_INVALID_REVNUM, fb->pool);
+          svn_hash_sets(pb->compared, apr_pstrdup(pb->pool, fb->name), "");
+        }
+    }
+
+  fb->left_src = svn_diff__source_create(eb->revnum, fb->pool);
+
+  SVN_ERR(svn_wc__db_base_get_info(NULL, NULL, NULL, NULL, NULL, NULL, NULL,
+                                   NULL, NULL, NULL, &fb->base_checksum, NULL,
+                                   NULL, NULL, &fb->base_props, NULL,
+                                   eb->db, fb->local_abspath,
+                                   fb->pool, fb->pool));
+
+  SVN_ERR(eb->processor->file_opened(&fb->pfb, &fb->skip,
+                                     fb->relpath,
+                                     fb->left_src,
+                                     fb->right_src,
+                                     NULL /* copyfrom src */,
+                                     pb->pdb,
+                                     eb->processor,
+                                     fb->pool, fb->pool));
+
+  return SVN_NO_ERROR;
+}
+
+/* An svn_delta_editor_t function. */
+static svn_error_t *
+apply_textdelta(void *file_baton,
+                const char *base_checksum_hex,
+                apr_pool_t *pool,
+                svn_txdelta_window_handler_t *handler,
+                void **handler_baton)
+{
+  struct file_baton_t *fb = file_baton;
+  struct edit_baton_t *eb = fb->eb;
+  svn_stream_t *source;
+  svn_stream_t *temp_stream;
+  svn_checksum_t *repos_checksum = NULL;
+
+  if (fb->skip)
+    {
+      *handler = svn_delta_noop_window_handler;
+      *handler_baton = NULL;
+      return SVN_NO_ERROR;
+    }
+
+  if (base_checksum_hex && fb->base_checksum)
+    {
+      const svn_checksum_t *base_md5;
+      SVN_ERR(svn_checksum_parse_hex(&repos_checksum, svn_checksum_md5,
+                                     base_checksum_hex, pool));
+
+      SVN_ERR(svn_wc__db_pristine_get_md5(&base_md5,
+                                          eb->db, eb->anchor_abspath,
+                                          fb->base_checksum,
+                                          pool, pool));
+
+      if (! svn_checksum_match(repos_checksum, base_md5))
+        {
+          /* ### I expect that there are some bad drivers out there
+             ### that used to give bad results. We could look in
+             ### working to see if the expected checksum matches and
+             ### then return the pristine of that... But that only moves
+             ### the problem */
+
+          /* If needed: compare checksum obtained via md5 of working.
+             And if they match set fb->base_checksum and fb->base_props */
+
+          return svn_checksum_mismatch_err(
+                        base_md5,
+                        repos_checksum,
+                        pool,
+                        _("Checksum mismatch for '%s'"),
+                        svn_dirent_local_style(fb->local_abspath,
+                                               pool));
+        }
+
+      SVN_ERR(svn_wc__db_pristine_read(&source, NULL,
+                                       eb->db, fb->local_abspath,
+                                       fb->base_checksum,
+                                       pool, pool));
+    }
+  else if (fb->base_checksum)
+    {
+      SVN_ERR(svn_wc__db_pristine_read(&source, NULL,
+                                       eb->db, fb->local_abspath,
+                                       fb->base_checksum,
+                                       pool, pool));
+    }
+  else
+    source = svn_stream_empty(pool);
+
+  /* This is the file that will contain the pristine repository version. */
+  SVN_ERR(svn_stream_open_unique(&temp_stream, &fb->temp_file_path, NULL,
+                                 svn_io_file_del_on_pool_cleanup,
+                                 fb->pool, fb->pool));
+
+  svn_txdelta_apply(source, temp_stream,
+                    fb->result_digest,
+                    fb->local_abspath /* error_info */,
+                    fb->pool,
+                    handler, handler_baton);
+
+  return SVN_NO_ERROR;
+}
+
+/* An svn_delta_editor_t function.  When the file is closed we have a temporary
+ * file containing a pristine version of the repository file. This can
+ * be compared against the working copy.
+ *
+ * Ignore TEXT_CHECKSUM.
+ */
+static svn_error_t *
+close_file(void *file_baton,
+           const char *expected_md5_digest,
+           apr_pool_t *pool)
+{
+  struct file_baton_t *fb = file_baton;
+  struct dir_baton_t *pb = fb->parent_baton;
+  struct edit_baton_t *eb = fb->eb;
+  apr_pool_t *scratch_pool = fb->pool;
+
+  /* The repository information; constructed from BASE + Changes */
+  const char *repos_file;
+  apr_hash_t *repos_props;
+
+  if (!fb->skip && expected_md5_digest != NULL)
+    {
+      svn_checksum_t *expected_checksum;
+      const svn_checksum_t *result_checksum;
+
+      if (fb->temp_file_path)
+        result_checksum = svn_checksum__from_digest_md5(fb->result_digest,
+                                                        scratch_pool);
+      else
+        result_checksum = fb->base_checksum;
+
+      SVN_ERR(svn_checksum_parse_hex(&expected_checksum, svn_checksum_md5,
+                                     expected_md5_digest, scratch_pool));
+
+      if (result_checksum->kind != svn_checksum_md5)
+        SVN_ERR(svn_wc__db_pristine_get_md5(&result_checksum,
+                                            eb->db, fb->local_abspath,
+                                            result_checksum,
+                                            scratch_pool, scratch_pool));
+
+      if (!svn_checksum_match(expected_checksum, result_checksum))
+        return svn_checksum_mismatch_err(
+                            expected_checksum,
+                            result_checksum,
+                            pool,
+                            _("Checksum mismatch for '%s'"),
+                            svn_dirent_local_style(fb->local_abspath,
+                                                   scratch_pool));
+    }
+
+  if (eb->local_before_remote && !fb->repos_only && !fb->ignoring_ancestry)
+    SVN_ERR(handle_local_only(pb, fb->name, scratch_pool));
+
+  {
+    apr_hash_t *prop_base;
+
+    if (fb->added)
+      prop_base = apr_hash_make(scratch_pool);
+    else
+      prop_base = fb->base_props;
+
+    /* includes entry props */
+    repos_props = svn_prop__patch(prop_base, fb->propchanges, scratch_pool);
+
+    repos_file = fb->temp_file_path;
+    if (! repos_file)
+      {
+        assert(fb->base_checksum);
+        SVN_ERR(svn_wc__db_pristine_get_path(&repos_file,
+                                             eb->db, eb->anchor_abspath,
+                                             fb->base_checksum,
+                                             scratch_pool, scratch_pool));
+      }
+  }
+
+  if (fb->skip)
+    {
+      /* Diff processor requested skipping information */
+    }
+  else if (fb->repos_only)
+    {
+      SVN_ERR(eb->processor->file_deleted(fb->relpath,
+                                          fb->left_src,
+                                          fb->temp_file_path,
+                                          repos_props,
+                                          fb->pfb,
+                                          eb->processor,
+                                          scratch_pool));
+    }
+  else
+    {
+      /* Produce a diff of actual or pristine against repos */
+      apr_hash_t *local_props;
+      apr_array_header_t *prop_changes;
+      const char *localfile;
+
+      /* pb->local_info contains some information that might allow optimizing
+         this a bit */
+
+      if (eb->diff_pristine)
+        {
+          const svn_checksum_t *checksum;
+          SVN_ERR(svn_wc__db_read_pristine_info(NULL, NULL, NULL, NULL, NULL,
+                                                NULL, &checksum, NULL, NULL,
+                                                &local_props,
+                                                eb->db, fb->local_abspath,
+                                                scratch_pool, scratch_pool));
+          assert(checksum);
+          SVN_ERR(svn_wc__db_pristine_get_path(&localfile,
+                                               eb->db, eb->anchor_abspath,
+                                               checksum,
+                                               scratch_pool, scratch_pool));
+        }
+      else
+        {
+          SVN_ERR(svn_wc__db_read_props(&local_props,
+                                        eb->db, fb->local_abspath,
+                                        scratch_pool, scratch_pool));
+
+          /* a detranslated version of the working file */
+          SVN_ERR(svn_wc__internal_translated_file(
+                    &localfile, fb->local_abspath, eb->db, fb->local_abspath,
+                    SVN_WC_TRANSLATE_TO_NF | SVN_WC_TRANSLATE_USE_GLOBAL_TMP,
+                    eb->cancel_func, eb->cancel_baton,
+                    scratch_pool, scratch_pool));
+        }
+
+      SVN_ERR(svn_prop_diffs(&prop_changes, local_props, repos_props,
+                             scratch_pool));
+
+
+      /* ### as a good diff processor we should now only report changes, and
+             report file_closed() in other cases */
+      SVN_ERR(eb->processor->file_changed(fb->relpath,
+                                          fb->left_src,
+                                          fb->right_src,
+                                          repos_file /* left file */,
+                                          localfile /* right file */,
+                                          repos_props /* left_props */,
+                                          local_props /* right props */,
+                                          TRUE /* ### file_modified */,
+                                          prop_changes,
+                                          fb->pfb,
+                                          eb->processor,
+                                          scratch_pool));
+    }
+
+  if (!eb->local_before_remote && !fb->repos_only && !fb->ignoring_ancestry)
+    SVN_ERR(handle_local_only(pb, fb->name, scratch_pool));
+
+  svn_pool_destroy(fb->pool); /* destroys scratch_pool and fb */
+  SVN_ERR(maybe_done(pb));
+  return SVN_NO_ERROR;
+}
+
+
+/* An svn_delta_editor_t function. */
+static svn_error_t *
+change_file_prop(void *file_baton,
+                 const char *name,
+                 const svn_string_t *value,
+                 apr_pool_t *pool)
+{
+  struct file_baton_t *fb = file_baton;
+  svn_prop_t *propchange;
+  svn_prop_kind_t propkind;
+
+  propkind = svn_property_kind2(name);
+  if (propkind == svn_prop_wc_kind)
+    return SVN_NO_ERROR;
+  else if (propkind == svn_prop_regular_kind)
+    fb->has_propchange = TRUE;
+
+  propchange = apr_array_push(fb->propchanges);
+  propchange->name = apr_pstrdup(fb->pool, name);
+  propchange->value = value ? svn_string_dup(value, fb->pool) : NULL;
+
+  return SVN_NO_ERROR;
+}
+
+
+/* An svn_delta_editor_t function. */
+static svn_error_t *
+change_dir_prop(void *dir_baton,
+                const char *name,
+                const svn_string_t *value,
+                apr_pool_t *pool)
+{
+  struct dir_baton_t *db = dir_baton;
+  svn_prop_t *propchange;
+  svn_prop_kind_t propkind;
+
+  propkind = svn_property_kind2(name);
+  if (propkind == svn_prop_wc_kind)
+    return SVN_NO_ERROR;
+  else if (propkind == svn_prop_regular_kind)
+    db->has_propchange = TRUE;
+
+  propchange = apr_array_push(db->propchanges);
+  propchange->name = apr_pstrdup(db->pool, name);
+  propchange->value = value ? svn_string_dup(value, db->pool) : NULL;
+
+  return SVN_NO_ERROR;
+}
+
+
+/* An svn_delta_editor_t function. */
+static svn_error_t *
+close_edit(void *edit_baton,
+           apr_pool_t *pool)
+{
+  struct edit_baton_t *eb = edit_baton;
+
+  if (!eb->root_opened)
+    {
+      SVN_ERR(walk_local_nodes_diff(eb,
+                                    eb->anchor_abspath,
+                                    "",
+                                    eb->depth,
+                                    NULL /* compared */,
+                                    NULL /* No parent_baton */,
+                                    eb->pool));
+    }
+
+  return SVN_NO_ERROR;
+}
+
+/* Public Interface */
+
+
+/* Create a diff editor and baton. */
+svn_error_t *
+svn_wc__get_diff_editor(const svn_delta_editor_t **editor,
+                        void **edit_baton,
+                        svn_wc_context_t *wc_ctx,
+                        const char *anchor_abspath,
+                        const char *target,
+                        svn_depth_t depth,
+                        svn_boolean_t ignore_ancestry,
+                        svn_boolean_t show_copies_as_adds,
+                        svn_boolean_t use_git_diff_format,
+                        svn_boolean_t use_text_base,
+                        svn_boolean_t reverse_order,
+                        svn_boolean_t server_performs_filtering,
+                        const apr_array_header_t *changelist_filter,
+                        const svn_wc_diff_callbacks4_t *callbacks,
+                        void *callback_baton,
+                        svn_cancel_func_t cancel_func,
+                        void *cancel_baton,
+                        apr_pool_t *result_pool,
+                        apr_pool_t *scratch_pool)
+{
+  struct edit_baton_t *eb;
+  void *inner_baton;
+  svn_delta_editor_t *tree_editor;
+  const svn_delta_editor_t *inner_editor;
+  struct svn_wc__shim_fetch_baton_t *sfb;
+  svn_delta_shim_callbacks_t *shim_callbacks =
+                                svn_delta_shim_callbacks_default(result_pool);
+
+  SVN_ERR_ASSERT(svn_dirent_is_absolute(anchor_abspath));
+
+  /* --git implies --show-copies-as-adds */
+  if (use_git_diff_format)
+    show_copies_as_adds = TRUE;
+
+  SVN_ERR(make_edit_baton(&eb,
+                          wc_ctx->db,
+                          anchor_abspath, target,
+                          callbacks, callback_baton,
+                          depth, ignore_ancestry, show_copies_as_adds,
+                          use_text_base, reverse_order, changelist_filter,
+                          cancel_func, cancel_baton,
+                          result_pool));
+
+  tree_editor = svn_delta_default_editor(eb->pool);
+
+  tree_editor->set_target_revision = set_target_revision;
+  tree_editor->open_root = open_root;
+  tree_editor->delete_entry = delete_entry;
+  tree_editor->add_directory = add_directory;
+  tree_editor->open_directory = open_directory;
+  tree_editor->close_directory = close_directory;
+  tree_editor->add_file = add_file;
+  tree_editor->open_file = open_file;
+  tree_editor->apply_textdelta = apply_textdelta;
+  tree_editor->change_file_prop = change_file_prop;
+  tree_editor->change_dir_prop = change_dir_prop;
+  tree_editor->close_file = close_file;
+  tree_editor->close_edit = close_edit;
+
+  inner_editor = tree_editor;
+  inner_baton = eb;
+
+  if (!server_performs_filtering
+      && depth == svn_depth_unknown)
+    SVN_ERR(svn_wc__ambient_depth_filter_editor(&inner_editor,
+                                                &inner_baton,
+                                                wc_ctx->db,
+                                                anchor_abspath,
+                                                target,
+                                                inner_editor,
+                                                inner_baton,
+                                                result_pool));
+
+  SVN_ERR(svn_delta_get_cancellation_editor(cancel_func,
+                                            cancel_baton,
+                                            inner_editor,
+                                            inner_baton,
+                                            editor,
+                                            edit_baton,
+                                            result_pool));
+
+  sfb = apr_palloc(result_pool, sizeof(*sfb));
+  sfb->db = wc_ctx->db;
+  sfb->base_abspath = eb->anchor_abspath;
+  sfb->fetch_base = TRUE;
+
+  shim_callbacks->fetch_kind_func = svn_wc__fetch_kind_func;
+  shim_callbacks->fetch_props_func = svn_wc__fetch_props_func;
+  shim_callbacks->fetch_base_func = svn_wc__fetch_base_func;
+  shim_callbacks->fetch_baton = sfb;
+
+
+  SVN_ERR(svn_editor__insert_shims(editor, edit_baton, *editor, *edit_baton,
+                                   NULL, NULL, shim_callbacks,
+                                   result_pool, scratch_pool));
+
+  return SVN_NO_ERROR;
+}
+
+/* Wrapping svn_wc_diff_callbacks4_t as svn_diff_tree_processor_t */
+
+/* baton for the svn_diff_tree_processor_t wrapper */
+typedef struct wc_diff_wrap_baton_t
+{
+  const svn_wc_diff_callbacks4_t *callbacks;
+  void *callback_baton;
+
+  svn_boolean_t walk_deleted_dirs;
+
+  apr_pool_t *result_pool;
+  const char *empty_file;
+
+} wc_diff_wrap_baton_t;
+
+static svn_error_t *
+wrap_ensure_empty_file(wc_diff_wrap_baton_t *wb,
+                       apr_pool_t *scratch_pool)
+{
+  if (wb->empty_file)
+    return SVN_NO_ERROR;
+
+  /* Create a unique file in the tempdir */
+  SVN_ERR(svn_io_open_unique_file3(NULL, &wb->empty_file, NULL,
+                                   svn_io_file_del_on_pool_cleanup,
+                                   wb->result_pool, scratch_pool));
+
+  return SVN_NO_ERROR;
+}
+
+/* svn_diff_tree_processor_t function */
+static svn_error_t *
+wrap_dir_opened(void **new_dir_baton,
+                svn_boolean_t *skip,
+                svn_boolean_t *skip_children,
+                const char *relpath,
+                const svn_diff_source_t *left_source,
+                const svn_diff_source_t *right_source,
+                const svn_diff_source_t *copyfrom_source,
+                void *parent_dir_baton,
+                const svn_diff_tree_processor_t *processor,
+                apr_pool_t *result_pool,
+                apr_pool_t *scratch_pool)
+{
+  wc_diff_wrap_baton_t *wb = processor->baton;
+  svn_boolean_t tree_conflicted = FALSE;
+
+  assert(left_source || right_source);
+  assert(!copyfrom_source || !right_source);
+
+  /* Maybe store state and tree_conflicted in baton? */
+  if (left_source != NULL)
+    {
+      /* Open for change or delete */
+      SVN_ERR(wb->callbacks->dir_opened(&tree_conflicted, skip, skip_children,
+                                        relpath,
+                                        right_source
+                                            ? right_source->revision
+                                            : (left_source
+                                                    ? left_source->revision
+                                                    : SVN_INVALID_REVNUM),
+                                        wb->callback_baton,
+                                        scratch_pool));
+
+      if (! right_source && !wb->walk_deleted_dirs)
+        *skip_children = TRUE;
+    }
+  else /* left_source == NULL -> Add */
+    {
+      svn_wc_notify_state_t state = svn_wc_notify_state_inapplicable;
+      SVN_ERR(wb->callbacks->dir_added(&state, &tree_conflicted,
+                                       skip, skip_children,
+                                       relpath,
+                                       right_source->revision,
+                                       copyfrom_source
+                                            ? copyfrom_source->repos_relpath
+                                            : NULL,
+                                       copyfrom_source
+                                            ? copyfrom_source->revision
+                                            : SVN_INVALID_REVNUM,
+                                       wb->callback_baton,
+                                       scratch_pool));
+    }
+
+  *new_dir_baton = NULL;
+
+  return SVN_NO_ERROR;
+}
+
+/* svn_diff_tree_processor_t function */
+static svn_error_t *
+wrap_dir_added(const char *relpath,
+               const svn_diff_source_t *right_source,
+               const svn_diff_source_t *copyfrom_source,
+               /*const*/ apr_hash_t *copyfrom_props,
+               /*const*/ apr_hash_t *right_props,
+               void *dir_baton,
+               const svn_diff_tree_processor_t *processor,
+               apr_pool_t *scratch_pool)
+{
+  wc_diff_wrap_baton_t *wb = processor->baton;
+  svn_boolean_t tree_conflicted = FALSE;
+  svn_wc_notify_state_t state = svn_wc_notify_state_unknown;
+  svn_wc_notify_state_t prop_state = svn_wc_notify_state_unknown;
+  apr_hash_t *pristine_props = copyfrom_props;
+  apr_array_header_t *prop_changes = NULL;
+
+  if (right_props && apr_hash_count(right_props))
+    {
+      if (!pristine_props)
+        pristine_props = apr_hash_make(scratch_pool);
+
+      SVN_ERR(svn_prop_diffs(&prop_changes, right_props, pristine_props,
+                             scratch_pool));
+
+      SVN_ERR(wb->callbacks->dir_props_changed(&prop_state,
+                                               &tree_conflicted,
+                                               relpath,
+                                               TRUE /* dir_was_added */,
+                                               prop_changes, pristine_props,
+                                               wb->callback_baton,
+                                               scratch_pool));
+    }
+
+  SVN_ERR(wb->callbacks->dir_closed(&state, &prop_state,
+                                   &tree_conflicted,
+                                   relpath,
+                                   TRUE /* dir_was_added */,
+                                   wb->callback_baton,
+                                   scratch_pool));
+  return SVN_NO_ERROR;
+}
+
+/* svn_diff_tree_processor_t function */
+static svn_error_t *
+wrap_dir_deleted(const char *relpath,
+                 const svn_diff_source_t *left_source,
+                 /*const*/ apr_hash_t *left_props,
+                 void *dir_baton,
+                 const svn_diff_tree_processor_t *processor,
+                 apr_pool_t *scratch_pool)
+{
+  wc_diff_wrap_baton_t *wb = processor->baton;
+  svn_boolean_t tree_conflicted = FALSE;
+  svn_wc_notify_state_t state = svn_wc_notify_state_inapplicable;
+
+  SVN_ERR(wb->callbacks->dir_deleted(&state, &tree_conflicted,
+                                     relpath,
+                                     wb->callback_baton,
+                                     scratch_pool));
+
+  return SVN_NO_ERROR;
+}
+
+/* svn_diff_tree_processor_t function */
+static svn_error_t *
+wrap_dir_closed(const char *relpath,
+                const svn_diff_source_t *left_source,
+                const svn_diff_source_t *right_source,
+                void *dir_baton,
+                const svn_diff_tree_processor_t *processor,
+                apr_pool_t *scratch_pool)
+{
+  wc_diff_wrap_baton_t *wb = processor->baton;
+
+  /* No previous implementations provided these arguments, so we
+     are not providing them either */
+  SVN_ERR(wb->callbacks->dir_closed(NULL, NULL, NULL,
+                                    relpath,
+                                    FALSE /* added */,
+                                    wb->callback_baton,
+                                    scratch_pool));
+
+return SVN_NO_ERROR;
+}
+
+/* svn_diff_tree_processor_t function */
+static svn_error_t *
+wrap_dir_changed(const char *relpath,
+                 const svn_diff_source_t *left_source,
+                 const svn_diff_source_t *right_source,
+                 /*const*/ apr_hash_t *left_props,
+                 /*const*/ apr_hash_t *right_props,
+                 const apr_array_header_t *prop_changes,
+                 void *dir_baton,
+                 const struct svn_diff_tree_processor_t *processor,
+                 apr_pool_t *scratch_pool)
+{
+  wc_diff_wrap_baton_t *wb = processor->baton;
+  svn_boolean_t tree_conflicted = FALSE;
+  svn_wc_notify_state_t prop_state = svn_wc_notify_state_inapplicable;
+
+  assert(left_source && right_source);
+
+  SVN_ERR(wb->callbacks->dir_props_changed(&prop_state, &tree_conflicted,
+                                           relpath,
+                                           FALSE /* dir_was_added */,
+                                           prop_changes,
+                                           left_props,
+                                           wb->callback_baton,
+                                           scratch_pool));
+
+  /* And call dir_closed, etc */
+  SVN_ERR(wrap_dir_closed(relpath, left_source, right_source,
+                          dir_baton, processor,
+                          scratch_pool));
+  return SVN_NO_ERROR;
+}
+
+/* svn_diff_tree_processor_t function */
+static svn_error_t *
+wrap_file_opened(void **new_file_baton,
+                 svn_boolean_t *skip,
+                 const char *relpath,
+                 const svn_diff_source_t *left_source,
+                 const svn_diff_source_t *right_source,
+                 const svn_diff_source_t *copyfrom_source,
+                 void *dir_baton,
+                 const svn_diff_tree_processor_t *processor,
+                 apr_pool_t *result_pool,
+                 apr_pool_t *scratch_pool)
+{
+  wc_diff_wrap_baton_t *wb = processor->baton;
+  svn_boolean_t tree_conflicted = FALSE;
+
+  if (left_source) /* If ! added */
+    SVN_ERR(wb->callbacks->file_opened(&tree_conflicted, skip, relpath,
+                                       right_source
+                                            ? right_source->revision
+                                            : (left_source
+                                                    ? left_source->revision
+                                                    : SVN_INVALID_REVNUM),
+                                       wb->callback_baton, scratch_pool));
+
+  /* No old implementation used the output arguments for notify */
+
+  *new_file_baton = NULL;
+  return SVN_NO_ERROR;
+}
+
+/* svn_diff_tree_processor_t function */
+static svn_error_t *
+wrap_file_added(const char *relpath,
+                const svn_diff_source_t *copyfrom_source,
+                const svn_diff_source_t *right_source,
+                const char *copyfrom_file,
+                const char *right_file,
+                /*const*/ apr_hash_t *copyfrom_props,
+                /*const*/ apr_hash_t *right_props,
+                void *file_baton,
+                const svn_diff_tree_processor_t *processor,
+                apr_pool_t *scratch_pool)
+{
+  wc_diff_wrap_baton_t *wb = processor->baton;
+  svn_boolean_t tree_conflicted = FALSE;
+  svn_wc_notify_state_t state = svn_wc_notify_state_inapplicable;
+  svn_wc_notify_state_t prop_state = svn_wc_notify_state_inapplicable;
+  apr_array_header_t *prop_changes;
+
+  if (! copyfrom_props)
+    copyfrom_props = apr_hash_make(scratch_pool);
+
+  SVN_ERR(svn_prop_diffs(&prop_changes, right_props, copyfrom_props,
+                         scratch_pool));
+
+  if (! copyfrom_source)
+    SVN_ERR(wrap_ensure_empty_file(wb, scratch_pool));
+
+  SVN_ERR(wb->callbacks->file_added(&state, &prop_state, &tree_conflicted,
+                                    relpath,
+                                    copyfrom_source
+                                        ? copyfrom_file
+                                        : wb->empty_file,
+                                    right_file,
+                                    0,
+                                    right_source->revision,
+                                    copyfrom_props
+                                     ? svn_prop_get_value(copyfrom_props,
+                                                          SVN_PROP_MIME_TYPE)
+                                     : NULL,
+                                    right_props
+                                     ? svn_prop_get_value(right_props,
+                                                          SVN_PROP_MIME_TYPE)
+                                     : NULL,
+                                    copyfrom_source
+                                            ? copyfrom_source->repos_relpath
+                                            : NULL,
+                                    copyfrom_source
+                                            ? copyfrom_source->revision
+                                            : SVN_INVALID_REVNUM,
+                                    prop_changes, copyfrom_props,
+                                    wb->callback_baton,
+                                    scratch_pool));
+  return SVN_NO_ERROR;
+}
+
+static svn_error_t *
+wrap_file_deleted(const char *relpath,
+                  const svn_diff_source_t *left_source,
+                  const char *left_file,
+                  apr_hash_t *left_props,
+                  void *file_baton,
+                  const svn_diff_tree_processor_t *processor,
+                  apr_pool_t *scratch_pool)
+{
+  wc_diff_wrap_baton_t *wb = processor->baton;
+  svn_boolean_t tree_conflicted = FALSE;
+  svn_wc_notify_state_t state = svn_wc_notify_state_inapplicable;
+
+  SVN_ERR(wrap_ensure_empty_file(wb, scratch_pool));
+
+  SVN_ERR(wb->callbacks->file_deleted(&state, &tree_conflicted,
+                                      relpath,
+                                      left_file, wb->empty_file,
+                                      left_props
+                                       ? svn_prop_get_value(left_props,
+                                                            SVN_PROP_MIME_TYPE)
+                                       : NULL,
+                                      NULL,
+                                      left_props,
+                                      wb->callback_baton,
+                                      scratch_pool));
+  return SVN_NO_ERROR;
+}
+
+/* svn_diff_tree_processor_t function */
+static svn_error_t *
+wrap_file_changed(const char *relpath,
+                  const svn_diff_source_t *left_source,
+                  const svn_diff_source_t *right_source,
+                  const char *left_file,
+                  const char *right_file,
+                  /*const*/ apr_hash_t *left_props,
+                  /*const*/ apr_hash_t *right_props,
+                  svn_boolean_t file_modified,
+                  const apr_array_header_t *prop_changes,
+                  void *file_baton,
+                  const svn_diff_tree_processor_t *processor,
+                  apr_pool_t *scratch_pool)
+{
+  wc_diff_wrap_baton_t *wb = processor->baton;
+  svn_boolean_t tree_conflicted = FALSE;
+  svn_wc_notify_state_t state = svn_wc_notify_state_inapplicable;
+  svn_wc_notify_state_t prop_state = svn_wc_notify_state_inapplicable;
+
+  SVN_ERR(wrap_ensure_empty_file(wb, scratch_pool));
+
+  assert(left_source && right_source);
+
+  SVN_ERR(wb->callbacks->file_changed(&state, &prop_state, &tree_conflicted,
+                                      relpath,
+                                      file_modified ? left_file : NULL,
+                                      file_modified ? right_file : NULL,
+                                      left_source->revision,
+                                      right_source->revision,
+                                      left_props
+                                       ? svn_prop_get_value(left_props,
+                                                            SVN_PROP_MIME_TYPE)
+                                       : NULL,
+                                      right_props
+                                       ? svn_prop_get_value(right_props,
+                                                            SVN_PROP_MIME_TYPE)
+                                       : NULL,
+                                       prop_changes,
+                                      left_props,
+                                      wb->callback_baton,
+                                      scratch_pool));
+  return SVN_NO_ERROR;
+}
+
+svn_error_t *
+svn_wc__wrap_diff_callbacks(const svn_diff_tree_processor_t **diff_processor,
+                            const svn_wc_diff_callbacks4_t *callbacks,
+                            void *callback_baton,
+                            svn_boolean_t walk_deleted_dirs,
+                            apr_pool_t *result_pool,
+                            apr_pool_t *scratch_pool)
+{
+  wc_diff_wrap_baton_t *wrap_baton;
+  svn_diff_tree_processor_t *processor;
+
+  wrap_baton = apr_pcalloc(result_pool, sizeof(*wrap_baton));
+
+  wrap_baton->result_pool = result_pool;
+  wrap_baton->callbacks = callbacks;
+  wrap_baton->callback_baton = callback_baton;
+  wrap_baton->empty_file = NULL;
+  wrap_baton->walk_deleted_dirs = walk_deleted_dirs;
+
+  processor = svn_diff__tree_processor_create(wrap_baton, result_pool);
+
+  processor->dir_opened   = wrap_dir_opened;
+  processor->dir_added    = wrap_dir_added;
+  processor->dir_deleted  = wrap_dir_deleted;
+  processor->dir_changed  = wrap_dir_changed;
+  processor->dir_closed   = wrap_dir_closed;
+
+  processor->file_opened   = wrap_file_opened;
+  processor->file_added    = wrap_file_added;
+  processor->file_deleted  = wrap_file_deleted;
+  processor->file_changed  = wrap_file_changed;
+  /*processor->file_closed   = wrap_file_closed*/; /* Not needed */
+
+  *diff_processor = processor;
+  return SVN_NO_ERROR;
+}