subversion-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From prabh...@apache.org
Subject svn commit: r1457684 [8/22] - in /subversion/branches/verify-keep-going: ./ build/ build/ac-macros/ build/generator/ build/generator/templates/ notes/ subversion/bindings/javahl/native/ subversion/bindings/javahl/src/org/apache/subversion/javahl/ subve...
Date Mon, 18 Mar 2013 09:35:29 GMT
Modified: subversion/branches/verify-keep-going/subversion/libsvn_wc/adm_crawler.c
URL: http://svn.apache.org/viewvc/subversion/branches/verify-keep-going/subversion/libsvn_wc/adm_crawler.c?rev=1457684&r1=1457683&r2=1457684&view=diff
==============================================================================
--- subversion/branches/verify-keep-going/subversion/libsvn_wc/adm_crawler.c (original)
+++ subversion/branches/verify-keep-going/subversion/libsvn_wc/adm_crawler.c Mon Mar 18 09:35:24 2013
@@ -102,7 +102,7 @@ svn_wc_restore(svn_wc_context_t *wc_ctx,
                apr_pool_t *scratch_pool)
 {
   svn_wc__db_status_t status;
-  svn_kind_t kind;
+  svn_node_kind_t kind;
   svn_node_kind_t disk_kind;
   const svn_checksum_t *checksum;
 
@@ -124,9 +124,9 @@ svn_wc_restore(svn_wc_context_t *wc_ctx,
   if (status != svn_wc__db_status_normal
       && !((status == svn_wc__db_status_added 
             || status == svn_wc__db_status_incomplete)
-           && (kind == svn_kind_dir
-               || (kind == svn_kind_file && checksum != NULL)
-               /* || (kind == svn_kind_symlink && target)*/)))
+           && (kind == svn_node_dir
+               || (kind == svn_node_file && checksum != NULL)
+               /* || (kind == svn_node_symlink && target)*/)))
     {
       return svn_error_createf(SVN_ERR_WC_PATH_UNEXPECTED_STATUS, NULL,
                                _("The node '%s' can not be restored."),
@@ -134,7 +134,7 @@ svn_wc_restore(svn_wc_context_t *wc_ctx,
                                                       scratch_pool));
     }
 
-  if (kind == svn_kind_file || kind == svn_kind_symlink)
+  if (kind == svn_node_file || kind == svn_node_symlink)
     SVN_ERR(restore_file(wc_ctx->db, local_abspath, use_commit_times,
                          FALSE /*mark_resolved_text_conflict*/,
                          scratch_pool));
@@ -154,20 +154,20 @@ svn_wc_restore(svn_wc_context_t *wc_ctx,
 static svn_error_t *
 restore_node(svn_wc__db_t *db,
              const char *local_abspath,
-             svn_kind_t kind,
+             svn_node_kind_t kind,
              svn_boolean_t use_commit_times,
              svn_wc_notify_func2_t notify_func,
              void *notify_baton,
              apr_pool_t *scratch_pool)
 {
-  if (kind == svn_kind_file || kind == svn_kind_symlink)
+  if (kind == svn_node_file || kind == svn_node_symlink)
     {
       /* Recreate file from text-base; mark any text conflict as resolved */
       SVN_ERR(restore_file(db, local_abspath, use_commit_times,
                            TRUE /*mark_resolved_text_conflict*/,
                            scratch_pool));
     }
-  else if (kind == svn_kind_dir)
+  else if (kind == svn_node_dir)
     {
       /* Recreating a directory is just a mkdir */
       SVN_ERR(svn_io_dir_make(local_abspath, APR_OS_DEFAULT, scratch_pool));
@@ -372,27 +372,20 @@ report_revisions_and_depths(svn_wc__db_t
           && apr_hash_get(dirents, child, APR_HASH_KEY_STRING) == NULL)
         {
           svn_wc__db_status_t wrk_status;
-          svn_kind_t wrk_kind;
+          svn_node_kind_t wrk_kind;
+          const svn_checksum_t *checksum;
 
           SVN_ERR(svn_wc__db_read_info(&wrk_status, &wrk_kind, NULL, NULL,
                                        NULL, NULL, NULL, NULL, NULL, NULL,
-                                       NULL, NULL, NULL, NULL, NULL, NULL,
+                                       &checksum, NULL, NULL, NULL, NULL, NULL,
                                        NULL, NULL, NULL, NULL, NULL, NULL,
                                        NULL, NULL, NULL, NULL, NULL,
                                        db, this_abspath, iterpool, iterpool));
 
-          if (wrk_status == svn_wc__db_status_added)
-            SVN_ERR(svn_wc__db_scan_addition(&wrk_status, NULL, NULL, NULL,
-                                             NULL, NULL, NULL, NULL, NULL,
-                                             NULL, NULL, db, this_abspath,
-                                             iterpool, iterpool));
-
-          if (wrk_status == svn_wc__db_status_normal
-              || wrk_status == svn_wc__db_status_copied
-              || wrk_status == svn_wc__db_status_moved_here
-              || (wrk_kind == svn_kind_dir
-                  && (wrk_status == svn_wc__db_status_added
-                      || wrk_status == svn_wc__db_status_incomplete)))
+          if ((wrk_status == svn_wc__db_status_normal
+               || wrk_status == svn_wc__db_status_added
+               || wrk_status == svn_wc__db_status_incomplete)
+              && (wrk_kind == svn_node_dir || checksum))
             {
               svn_node_kind_t dirent_kind;
 
@@ -433,8 +426,8 @@ report_revisions_and_depths(svn_wc__db_t
         ths->depth = svn_depth_infinity;
 
       /*** Files ***/
-      if (ths->kind == svn_kind_file ||
-               ths->kind == svn_kind_symlink)
+      if (ths->kind == svn_node_file
+          || ths->kind == svn_node_symlink)
         {
           if (report_everything)
             {
@@ -487,7 +480,7 @@ report_revisions_and_depths(svn_wc__db_t
         } /* end file case */
 
       /*** Directories (in recursive mode) ***/
-      else if (ths->kind == svn_kind_dir
+      else if (ths->kind == svn_node_dir
                && (depth > svn_depth_files
                    || depth == svn_depth_unknown))
         {
@@ -644,7 +637,7 @@ svn_wc_crawl_revisions5(svn_wc_context_t
   svn_revnum_t target_rev = SVN_INVALID_REVNUM;
   svn_boolean_t start_empty;
   svn_wc__db_status_t status;
-  svn_kind_t target_kind;
+  svn_node_kind_t target_kind;
   const char *repos_relpath, *repos_root_url;
   svn_depth_t target_depth;
   svn_wc__db_lock_t *target_lock;
@@ -712,9 +705,11 @@ svn_wc_crawl_revisions5(svn_wc_context_t
       && disk_kind == svn_node_none)
     {
       svn_wc__db_status_t wrk_status;
-      svn_kind_t wrk_kind;
+      svn_node_kind_t wrk_kind;
+      const svn_checksum_t *checksum;
+
       err = svn_wc__db_read_info(&wrk_status, &wrk_kind, NULL, NULL, NULL,
-                                 NULL, NULL, NULL, NULL, NULL, NULL, NULL,
+                                 NULL, NULL, NULL, NULL, NULL, &checksum, NULL,
                                  NULL, NULL, NULL, NULL, NULL, NULL, NULL,
                                  NULL, NULL, NULL, NULL, NULL, NULL, NULL,
                                  NULL,
@@ -726,23 +721,15 @@ svn_wc_crawl_revisions5(svn_wc_context_t
         {
           svn_error_clear(err);
           wrk_status = svn_wc__db_status_not_present;
-          wrk_kind = svn_kind_file;
+          wrk_kind = svn_node_file;
         }
       else
         SVN_ERR(err);
 
-      if (wrk_status == svn_wc__db_status_added)
-        SVN_ERR(svn_wc__db_scan_addition(&wrk_status, NULL, NULL, NULL, NULL,
-                                         NULL, NULL, NULL, NULL, NULL, NULL,
-                                         db, local_abspath,
-                                         scratch_pool, scratch_pool));
-
-      if (wrk_status == svn_wc__db_status_normal
-          || wrk_status == svn_wc__db_status_copied
-          || wrk_status == svn_wc__db_status_moved_here
-          || (wrk_kind == svn_kind_dir
-              && (wrk_status == svn_wc__db_status_added
-                  || wrk_status == svn_wc__db_status_incomplete)))
+      if ((wrk_status == svn_wc__db_status_normal
+          || wrk_status == svn_wc__db_status_added
+          || wrk_status == svn_wc__db_status_incomplete)
+          && (wrk_kind == svn_node_dir || checksum))
         {
           SVN_ERR(restore_node(wc_ctx->db, local_abspath,
                                wrk_kind, use_commit_times,
@@ -765,7 +752,7 @@ svn_wc_crawl_revisions5(svn_wc_context_t
     SVN_ERR(reporter->set_path(report_baton, "", target_rev, report_depth,
                                start_empty, NULL, scratch_pool));
   }
-  if (target_kind == svn_kind_dir)
+  if (target_kind == svn_node_dir)
     {
       if (depth != svn_depth_empty)
         {
@@ -792,7 +779,7 @@ svn_wc_crawl_revisions5(svn_wc_context_t
         }
     }
 
-  else if (target_kind == svn_kind_file || target_kind == svn_kind_symlink)
+  else if (target_kind == svn_node_file || target_kind == svn_node_symlink)
     {
       const char *parent_abspath, *base;
       svn_wc__db_status_t parent_status;
@@ -1203,13 +1190,19 @@ svn_wc__internal_transmit_prop_deltas(sv
   apr_pool_t *iterpool = svn_pool_create(scratch_pool);
   int i;
   apr_array_header_t *propmods;
-  svn_kind_t kind;
+  svn_node_kind_t kind;
 
   SVN_ERR(svn_wc__db_read_kind(&kind, db, local_abspath,
                                FALSE /* allow_missing */,
+                               FALSE /* show_deleted */,
                                FALSE /* show_hidden */,
                                iterpool));
 
+  if (kind == svn_node_none)
+    return svn_error_createf(SVN_ERR_WC_PATH_NOT_FOUND, NULL,
+                             _("The node '%s' was not found."),
+                             svn_dirent_local_style(local_abspath, iterpool));
+
   /* Get an array of local changes by comparing the hashes. */
   SVN_ERR(svn_wc__internal_propdiff(&propmods, NULL, db, local_abspath,
                                     scratch_pool, iterpool));
@@ -1221,7 +1214,7 @@ svn_wc__internal_transmit_prop_deltas(sv
 
       svn_pool_clear(iterpool);
 
-      if (kind == svn_kind_file)
+      if (kind == svn_node_file)
         SVN_ERR(editor->change_file_prop(baton, p->name, p->value,
                                          iterpool));
       else

Modified: subversion/branches/verify-keep-going/subversion/libsvn_wc/adm_files.c
URL: http://svn.apache.org/viewvc/subversion/branches/verify-keep-going/subversion/libsvn_wc/adm_files.c?rev=1457684&r1=1457683&r2=1457684&view=diff
==============================================================================
--- subversion/branches/verify-keep-going/subversion/libsvn_wc/adm_files.c (original)
+++ subversion/branches/verify-keep-going/subversion/libsvn_wc/adm_files.c Mon Mar 18 09:35:24 2013
@@ -171,7 +171,7 @@ svn_wc__text_base_path_to_read(const cha
                                apr_pool_t *scratch_pool)
 {
   svn_wc__db_status_t status;
-  svn_kind_t kind;
+  svn_node_kind_t kind;
   const svn_checksum_t *checksum;
 
   SVN_ERR(svn_wc__db_read_pristine_info(&status, &kind, NULL, NULL, NULL, NULL,
@@ -180,7 +180,7 @@ svn_wc__text_base_path_to_read(const cha
                                         scratch_pool, scratch_pool));
 
   /* Sanity */
-  if (kind != svn_kind_file)
+  if (kind != svn_node_file)
     return svn_error_createf(SVN_ERR_NODE_UNEXPECTED_KIND, NULL,
                              _("Can only get the pristine contents of files; "
                                "'%s' is not a file"),
@@ -224,7 +224,7 @@ svn_wc__get_pristine_contents(svn_stream
                               apr_pool_t *scratch_pool)
 {
   svn_wc__db_status_t status;
-  svn_kind_t kind;
+  svn_node_kind_t kind;
   const svn_checksum_t *sha1_checksum;
 
   if (size)
@@ -236,7 +236,7 @@ svn_wc__get_pristine_contents(svn_stream
                                         scratch_pool, scratch_pool));
 
   /* Sanity */
-  if (kind != svn_kind_file)
+  if (kind != svn_node_file)
     return svn_error_createf(SVN_ERR_NODE_UNEXPECTED_KIND, NULL,
                              _("Can only get the pristine contents of files; "
                                "'%s' is not a file"),
@@ -460,8 +460,8 @@ svn_wc__internal_ensure_adm(svn_wc__db_t
                                              &db_repos_relpath,
                                              &db_repos_root_url,
                                              &db_repos_uuid,
-                                             NULL, NULL, NULL, NULL, NULL,
-                                             NULL, db, local_abspath,
+                                             NULL, NULL, NULL, NULL,
+                                             db, local_abspath,
                                              scratch_pool, scratch_pool));
           else
             SVN_ERR(svn_wc__db_scan_base_repos(&db_repos_relpath,

Modified: subversion/branches/verify-keep-going/subversion/libsvn_wc/adm_ops.c
URL: http://svn.apache.org/viewvc/subversion/branches/verify-keep-going/subversion/libsvn_wc/adm_ops.c?rev=1457684&r1=1457683&r2=1457684&view=diff
==============================================================================
--- subversion/branches/verify-keep-going/subversion/libsvn_wc/adm_ops.c (original)
+++ subversion/branches/verify-keep-going/subversion/libsvn_wc/adm_ops.c Mon Mar 18 09:35:24 2013
@@ -113,7 +113,7 @@ process_committed_leaf(svn_wc__db_t *db,
                        const char *local_abspath,
                        svn_boolean_t via_recurse,
                        svn_wc__db_status_t status,
-                       svn_kind_t kind,
+                       svn_node_kind_t kind,
                        svn_boolean_t prop_mods,
                        const svn_checksum_t *old_checksum,
                        svn_revnum_t new_revnum,
@@ -133,7 +133,7 @@ process_committed_leaf(svn_wc__db_t *db,
   {
     const char *adm_abspath;
 
-    if (kind == svn_kind_dir)
+    if (kind == svn_node_dir)
       adm_abspath = local_abspath;
     else
       adm_abspath = svn_dirent_dirname(local_abspath, scratch_pool);
@@ -167,7 +167,7 @@ process_committed_leaf(svn_wc__db_t *db,
                  || status == svn_wc__db_status_incomplete
                  || status == svn_wc__db_status_added);
 
-  if (kind != svn_kind_dir)
+  if (kind != svn_node_dir)
     {
       /* If we sent a delta (meaning: post-copy modification),
          then this file will appear in the queue and so we should have
@@ -241,7 +241,7 @@ svn_wc__process_committed_internal(svn_w
                                    apr_pool_t *scratch_pool)
 {
   svn_wc__db_status_t status;
-  svn_kind_t kind;
+  svn_node_kind_t kind;
   const svn_checksum_t *old_checksum;
   svn_boolean_t prop_mods;
 
@@ -264,7 +264,7 @@ svn_wc__process_committed_internal(svn_w
                                  scratch_pool));
 
   /* Only check for recursion on nodes that have children */
-  if (kind != svn_kind_file
+  if (kind != svn_node_file
       || status == svn_wc__db_status_not_present
       || status == svn_wc__db_status_excluded
       || status == svn_wc__db_status_server_excluded
@@ -579,7 +579,7 @@ check_can_add_to_parent(const char **rep
 {
   const char *parent_abspath = svn_dirent_dirname(local_abspath, scratch_pool);
   svn_wc__db_status_t parent_status;
-  svn_kind_t parent_kind;
+  svn_node_kind_t parent_kind;
   svn_error_t *err;
 
   SVN_ERR(svn_wc__write_check(db, parent_abspath, scratch_pool));
@@ -612,7 +612,7 @@ check_can_add_to_parent(const char **rep
                           svn_dirent_local_style(local_abspath,
                                                  scratch_pool));
     }
-  else if (parent_kind != svn_kind_dir)
+  else if (parent_kind != svn_node_dir)
     return svn_error_createf(SVN_ERR_NODE_UNEXPECTED_KIND, NULL,
                              _("Can't schedule an addition of '%s'"
                                " below a not-directory node"),
@@ -626,7 +626,7 @@ check_can_add_to_parent(const char **rep
       if (parent_status == svn_wc__db_status_added)
         SVN_ERR(svn_wc__db_scan_addition(NULL, NULL, NULL,
                                          repos_root_url, repos_uuid, NULL,
-                                         NULL, NULL, NULL, NULL, NULL,
+                                         NULL, NULL, NULL,
                                          db, parent_abspath,
                                          result_pool, scratch_pool));
       else

Modified: subversion/branches/verify-keep-going/subversion/libsvn_wc/ambient_depth_filter_editor.c
URL: http://svn.apache.org/viewvc/subversion/branches/verify-keep-going/subversion/libsvn_wc/ambient_depth_filter_editor.c?rev=1457684&r1=1457683&r2=1457684&view=diff
==============================================================================
--- subversion/branches/verify-keep-going/subversion/libsvn_wc/ambient_depth_filter_editor.c (original)
+++ subversion/branches/verify-keep-going/subversion/libsvn_wc/ambient_depth_filter_editor.c Mon Mar 18 09:35:24 2013
@@ -121,7 +121,7 @@ struct dir_baton
  */
 static svn_error_t *
 ambient_read_info(svn_wc__db_status_t *status,
-                  svn_kind_t *kind,
+                  svn_node_kind_t *kind,
                   svn_depth_t *depth,
                   svn_wc__db_t *db,
                   const char *local_abspath,
@@ -140,7 +140,7 @@ ambient_read_info(svn_wc__db_status_t *s
     {
       svn_error_clear(err);
 
-      *kind = svn_kind_unknown;
+      *kind = svn_node_unknown;
       if (status)
         *status = svn_wc__db_status_normal;
       if (depth)
@@ -190,7 +190,7 @@ make_dir_baton(struct dir_baton **d_p,
     {
       svn_boolean_t exclude;
       svn_wc__db_status_t status;
-      svn_kind_t kind;
+      svn_node_kind_t kind;
       svn_boolean_t exists = TRUE;
 
       if (!added)
@@ -201,10 +201,10 @@ make_dir_baton(struct dir_baton **d_p,
       else
         {
           status = svn_wc__db_status_not_present;
-          kind = svn_kind_unknown;
+          kind = svn_node_unknown;
         }
 
-      exists = (kind != svn_kind_unknown);
+      exists = (kind != svn_node_unknown);
 
       if (pb->ambient_depth == svn_depth_empty
           || pb->ambient_depth == svn_depth_files)
@@ -250,7 +250,7 @@ make_file_baton(struct file_baton **f_p,
   struct file_baton *f = apr_pcalloc(pool, sizeof(*f));
   struct edit_baton *eb = pb->edit_baton;
   svn_wc__db_status_t status;
-  svn_kind_t kind;
+  svn_node_kind_t kind;
   const char *abspath;
 
   SVN_ERR_ASSERT(path);
@@ -272,7 +272,7 @@ make_file_baton(struct file_baton **f_p,
   else
     {
       status = svn_wc__db_status_not_present;
-      kind = svn_kind_unknown;
+      kind = svn_node_unknown;
     }
 
   if (pb->ambient_depth == svn_depth_empty)
@@ -285,7 +285,7 @@ make_file_baton(struct file_baton **f_p,
       if (status == svn_wc__db_status_not_present
           || status == svn_wc__db_status_server_excluded
           || status == svn_wc__db_status_excluded
-          || kind == svn_kind_unknown)
+          || kind == svn_node_unknown)
         {
           f->ambiently_excluded = TRUE;
           *f_p = f;
@@ -344,7 +344,7 @@ open_root(void *edit_baton,
   if (! *eb->target)
     {
       /* For an update with a NULL target, this is equivalent to open_dir(): */
-      svn_kind_t kind;
+      svn_node_kind_t kind;
       svn_wc__db_status_t status;
       svn_depth_t depth;
 
@@ -353,7 +353,7 @@ open_root(void *edit_baton,
                                 eb->db, eb->anchor_abspath,
                                 pool));
 
-      if (kind != svn_kind_unknown
+      if (kind != svn_node_unknown
           && status != svn_wc__db_status_not_present
           && status != svn_wc__db_status_excluded
           && status != svn_wc__db_status_server_excluded)
@@ -384,7 +384,7 @@ delete_entry(const char *path,
       /* If the entry we want to delete doesn't exist, that's OK.
          It's probably an old server that doesn't understand
          depths. */
-      svn_kind_t kind;
+      svn_node_kind_t kind;
       svn_wc__db_status_t status;
       const char *abspath;
 
@@ -393,7 +393,7 @@ delete_entry(const char *path,
       SVN_ERR(ambient_read_info(&status, &kind, NULL,
                                 eb->db, abspath, pool));
 
-      if (kind == svn_kind_unknown
+      if (kind == svn_node_unknown
           || status == svn_wc__db_status_not_present
           || status == svn_wc__db_status_excluded
           || status == svn_wc__db_status_server_excluded)
@@ -462,7 +462,7 @@ open_directory(const char *path,
   struct edit_baton *eb = pb->edit_baton;
   struct dir_baton *b;
   const char *local_abspath;
-  svn_kind_t kind;
+  svn_node_kind_t kind;
   svn_wc__db_status_t status;
   svn_depth_t depth;
 
@@ -484,7 +484,7 @@ open_directory(const char *path,
   SVN_ERR(ambient_read_info(&status, &kind, &depth,
                             eb->db, local_abspath, pool));
 
-  if (kind != svn_kind_unknown
+  if (kind != svn_node_unknown
       && status != svn_wc__db_status_not_present
       && status != svn_wc__db_status_excluded
       && status != svn_wc__db_status_server_excluded)

Modified: subversion/branches/verify-keep-going/subversion/libsvn_wc/cleanup.c
URL: http://svn.apache.org/viewvc/subversion/branches/verify-keep-going/subversion/libsvn_wc/cleanup.c?rev=1457684&r1=1457683&r2=1457684&view=diff
==============================================================================
--- subversion/branches/verify-keep-going/subversion/libsvn_wc/cleanup.c (original)
+++ subversion/branches/verify-keep-going/subversion/libsvn_wc/cleanup.c Mon Mar 18 09:35:24 2013
@@ -76,7 +76,7 @@ repair_timestamps(svn_wc__db_t *db,
                   void *cancel_baton,
                   apr_pool_t *scratch_pool)
 {
-  svn_kind_t kind;
+  svn_node_kind_t kind;
   svn_wc__db_status_t status;
 
   if (cancel_func)
@@ -95,15 +95,15 @@ repair_timestamps(svn_wc__db_t *db,
       || status == svn_wc__db_status_not_present)
     return SVN_NO_ERROR;
 
-  if (kind == svn_kind_file
-      || kind == svn_kind_symlink)
+  if (kind == svn_node_file
+      || kind == svn_node_symlink)
     {
       svn_boolean_t modified;
       SVN_ERR(svn_wc__internal_file_modified_p(&modified,
                                                db, local_abspath, FALSE,
                                                scratch_pool));
     }
-  else if (kind == svn_kind_dir)
+  else if (kind == svn_node_dir)
     {
       apr_pool_t *iterpool = svn_pool_create(scratch_pool);
       const apr_array_header_t *children;

Modified: subversion/branches/verify-keep-going/subversion/libsvn_wc/conflicts.c
URL: http://svn.apache.org/viewvc/subversion/branches/verify-keep-going/subversion/libsvn_wc/conflicts.c?rev=1457684&r1=1457683&r2=1457684&view=diff
==============================================================================
--- subversion/branches/verify-keep-going/subversion/libsvn_wc/conflicts.c (original)
+++ subversion/branches/verify-keep-going/subversion/libsvn_wc/conflicts.c Mon Mar 18 09:35:24 2013
@@ -1283,15 +1283,24 @@ generate_propconflict(svn_boolean_t *con
   svn_wc_conflict_result_t *result = NULL;
   svn_wc_conflict_description2_t *cdesc;
   const char *dirpath = svn_dirent_dirname(local_abspath, scratch_pool);
-  svn_kind_t kind;
+  svn_node_kind_t kind;
   const svn_string_t *new_value = NULL;
 
-  SVN_ERR(svn_wc__db_read_kind(&kind, db, local_abspath, FALSE, FALSE,
+  SVN_ERR(svn_wc__db_read_kind(&kind, db, local_abspath,
+                               FALSE /* allow_missing */,
+                               FALSE /* show_deleted */,
+                               FALSE /* show_hidden */,
                                scratch_pool));
 
+  if (kind == svn_node_none)
+    return svn_error_createf(SVN_ERR_WC_PATH_NOT_FOUND, NULL,
+                             _("The node '%s' was not found."),
+                             svn_dirent_local_style(local_abspath,
+                                                    scratch_pool));
+
   cdesc = svn_wc_conflict_description_create_prop2(
                 local_abspath,
-                (kind == svn_kind_dir) ? svn_node_dir : svn_node_file,
+                (kind == svn_node_dir) ? svn_node_dir : svn_node_file,
                 propname, scratch_pool);
 
   cdesc->operation = operation;
@@ -2302,15 +2311,456 @@ svn_wc__read_conflicts(const apr_array_h
 
 /*** Resolving a conflict automatically ***/
 
+/*
+ * Resolve the text conflict found in DB/LOCAL_ABSPATH/CONFLICTS
+ * according to CONFLICT_CHOICE.  (Don't mark it as resolved.)
+ *
+ * If there were any marker files recorded and present on disk, append to
+ * *WORK_ITEMS work items to remove them, and set *REMOVED_REJECT_FILES
+ * to TRUE.  Otherwise, don't change *REMOVED_REJECT_FILES.
+ *
+ * It is an error if there is no text conflict.
+ *
+ * Note: When there are no conflict markers to remove there is no existing
+ * text conflict; just a database containing old information, which we should
+ * remove to avoid checking all the time. Resolving a text conflict by
+ * removing all the marker files is a fully supported scenario since
+ * Subversion 1.0.
+ */
+static svn_error_t *
+resolve_text_conflict_on_node(svn_boolean_t *removed_reject_files,
+                              svn_skel_t **work_items,
+                              svn_wc__db_t *db,
+                              const char *local_abspath,
+                              svn_wc_operation_t operation,
+                              svn_skel_t *conflicts,
+                              svn_wc_conflict_choice_t conflict_choice,
+                              apr_pool_t *scratch_pool)
+{
+  const char *conflict_old = NULL;
+  const char *conflict_new = NULL;
+  const char *conflict_working = NULL;
+  const char *auto_resolve_src;
+  svn_node_kind_t node_kind;
+  svn_skel_t *work_item;
+
+  SVN_ERR(svn_wc__conflict_read_text_conflict(&conflict_working,
+                                              &conflict_old,
+                                              &conflict_new,
+                                              db, local_abspath, conflicts,
+                                              scratch_pool, scratch_pool));
+
+  /* Handle automatic conflict resolution before the temporary files are
+   * deleted, if necessary. */
+  switch (conflict_choice)
+    {
+    case svn_wc_conflict_choose_base:
+      auto_resolve_src = conflict_old;
+      break;
+    case svn_wc_conflict_choose_mine_full:
+      auto_resolve_src = conflict_working;
+      break;
+    case svn_wc_conflict_choose_theirs_full:
+      auto_resolve_src = conflict_new;
+      break;
+    case svn_wc_conflict_choose_merged:
+      auto_resolve_src = NULL;
+      break;
+    case svn_wc_conflict_choose_theirs_conflict:
+    case svn_wc_conflict_choose_mine_conflict:
+      {
+        if (conflict_old && conflict_working && conflict_new)
+          {
+            const char *temp_dir;
+            svn_stream_t *tmp_stream = NULL;
+            svn_diff_t *diff;
+            svn_diff_conflict_display_style_t style =
+              conflict_choice == svn_wc_conflict_choose_theirs_conflict
+              ? svn_diff_conflict_display_latest
+              : svn_diff_conflict_display_modified;
+
+            SVN_ERR(svn_wc__db_temp_wcroot_tempdir(&temp_dir, db,
+                                                   local_abspath,
+                                                   scratch_pool,
+                                                   scratch_pool));
+            SVN_ERR(svn_stream_open_unique(&tmp_stream,
+                                           &auto_resolve_src,
+                                           temp_dir,
+                                           svn_io_file_del_on_pool_cleanup,
+                                           scratch_pool, scratch_pool));
+
+            SVN_ERR(svn_diff_file_diff3_2(&diff,
+                                          conflict_old,
+                                          conflict_working,
+                                          conflict_new,
+                                          svn_diff_file_options_create(
+                                            scratch_pool),
+                                          scratch_pool));
+            SVN_ERR(svn_diff_file_output_merge2(tmp_stream, diff,
+                                                conflict_old,
+                                                conflict_working,
+                                                conflict_new,
+                                                /* markers ignored */
+                                                NULL, NULL, NULL, NULL,
+                                                style,
+                                                scratch_pool));
+            SVN_ERR(svn_stream_close(tmp_stream));
+          }
+        else
+          auto_resolve_src = NULL;
+        break;
+      }
+    default:
+      return svn_error_create(SVN_ERR_INCORRECT_PARAMS, NULL,
+                              _("Invalid 'conflict_result' argument"));
+    }
+
+  if (auto_resolve_src)
+    {
+      SVN_ERR(svn_wc__wq_build_file_copy_translated(
+                &work_item, db, local_abspath,
+                auto_resolve_src, local_abspath, scratch_pool, scratch_pool));
+      *work_items = svn_wc__wq_merge(*work_items, work_item, scratch_pool);
+
+      SVN_ERR(svn_wc__wq_build_sync_file_flags(&work_item, db,
+                                               local_abspath,
+                                               scratch_pool, scratch_pool));
+      *work_items = svn_wc__wq_merge(*work_items, work_item, scratch_pool);
+    }
+
+  /* Legacy behavior: Only report text conflicts as resolved when at least
+     one conflict marker file exists.
+
+     If not the UI shows the conflict as already resolved
+     (and in this case we just remove the in-db conflict) */
+
+  if (conflict_old)
+    {
+      SVN_ERR(svn_io_check_path(conflict_old, &node_kind, scratch_pool));
+      if (node_kind == svn_node_file)
+        {
+          SVN_ERR(svn_wc__wq_build_file_remove(&work_item, db,
+                                               local_abspath,
+                                               conflict_old,
+                                               scratch_pool, scratch_pool));
+          *work_items = svn_wc__wq_merge(*work_items, work_item, scratch_pool);
+          *removed_reject_files = TRUE;
+        }
+    }
+
+  if (conflict_new)
+    {
+      SVN_ERR(svn_io_check_path(conflict_new, &node_kind, scratch_pool));
+      if (node_kind == svn_node_file)
+        {
+          SVN_ERR(svn_wc__wq_build_file_remove(&work_item, db,
+                                               local_abspath,
+                                               conflict_new,
+                                               scratch_pool, scratch_pool));
+          *work_items = svn_wc__wq_merge(*work_items, work_item, scratch_pool);
+          *removed_reject_files = TRUE;
+        }
+    }
+
+  if (conflict_working)
+    {
+      SVN_ERR(svn_io_check_path(conflict_working, &node_kind, scratch_pool));
+      if (node_kind == svn_node_file)
+        {
+          SVN_ERR(svn_wc__wq_build_file_remove(&work_item, db,
+                                               local_abspath,
+                                               conflict_working,
+                                               scratch_pool, scratch_pool));
+          *work_items = svn_wc__wq_merge(*work_items, work_item, scratch_pool);
+          *removed_reject_files = TRUE;
+        }
+    }
+
+  return SVN_NO_ERROR;
+}
+
+/*
+ * Resolve the property conflicts found in DB/LOCAL_ABSPATH/CONFLICTS
+ * according to CONFLICT_CHOICE.  (Don't mark it as resolved.)
+ *
+ * If there was a reject file recorded and present on disk, append to
+ * *WORK_ITEMS a work item to remove it, and set *REMOVED_REJECT_FILE
+ * to TRUE.  Otherwise, don't change *REMOVED_REJECT_FILE.
+ *
+ * It is an error if there is no prop conflict.
+ *
+ * Note: When there are no conflict markers on-disk to remove there is
+ * no existing text conflict (unless we are still in the process of
+ * creating the text conflict and we didn't register a marker file yet).
+ * In this case the database contains old information, which we should
+ * remove to avoid checking the next time. Resolving a property conflict
+ * by just removing the marker file is a fully supported scenario since
+ * Subversion 1.0.
+ *
+ * ### TODO [JAF] The '*_full' and '*_conflict' choices should differ.
+ *     In my opinion, 'mine_full'/'theirs_full' should select
+ *     the entire set of properties from 'mine' or 'theirs' respectively,
+ *     while 'mine_conflict'/'theirs_conflict' should select just the
+ *     properties that are in conflict.  Or, '_full' should select the
+ *     entire property whereas '_conflict' should do a text merge within
+ *     each property, selecting hunks.  Or all three kinds of behaviour
+ *     should be available (full set of props, full value of conflicting
+ *     props, or conflicting text hunks).
+ * ### BH: If we make *_full select the full set of properties, we should
+ *     check if we shouldn't make it also select the full text for files.
+ *
+ * ### TODO [JAF] All this complexity should not be down here in libsvn_wc
+ *     but in a layer above.
+ *
+ * ### TODO [JAF] Options for 'base' should be like options for 'mine' and
+ *     for 'theirs' -- choose full set of props, full value of conflicting
+ *     props, or conflicting text hunks.
+ *
+ */
+static svn_error_t *
+resolve_prop_conflict_on_node(svn_boolean_t *removed_reject_file,
+                              svn_skel_t **work_items,
+                              svn_wc__db_t *db,
+                              const char *local_abspath,
+                              svn_wc_operation_t operation,
+                              svn_skel_t *conflicts,
+                              svn_wc_conflict_choice_t conflict_choice,
+                              apr_pool_t *scratch_pool)
+{
+  svn_node_kind_t node_kind;
+  const char *prop_reject_file;
+  apr_hash_t *mine_props;
+  apr_hash_t *their_old_props;
+  apr_hash_t *their_props;
+  apr_hash_t *conflicted_props;
+  apr_hash_t *old_props;
+  apr_hash_t *resolve_from = NULL;
+
+  SVN_ERR(svn_wc__conflict_read_prop_conflict(&prop_reject_file,
+                                              &mine_props, &their_old_props,
+                                              &their_props, &conflicted_props,
+                                              db, local_abspath, conflicts,
+                                              scratch_pool, scratch_pool));
+
+  if (operation == svn_wc_operation_merge)
+      SVN_ERR(svn_wc__db_read_pristine_props(&old_props, db, local_abspath,
+                                             scratch_pool, scratch_pool));
+    else
+      old_props = their_old_props;
+
+  /* We currently handle *_conflict as *_full as this argument is currently
+     always applied for all conflicts on a node at the same time. Giving
+     an error would break some tests that assumed that this would just
+     resolve property conflicts to working.
+
+     An alternative way to handle these conflicts would be to just copy all
+     property state from mine/theirs on the _full option instead of just the
+     conflicted properties. In some ways this feels like a sensible option as
+     that would take both properties and text from mine/theirs, but when not
+     both properties and text are conflicted we would fail in doing so.
+   */
+  switch (conflict_choice)
+    {
+    case svn_wc_conflict_choose_base:
+      resolve_from = their_old_props ? their_old_props : old_props;
+      break;
+    case svn_wc_conflict_choose_mine_full:
+    case svn_wc_conflict_choose_mine_conflict:
+      resolve_from = mine_props;
+      break;
+    case svn_wc_conflict_choose_theirs_full:
+    case svn_wc_conflict_choose_theirs_conflict:
+      resolve_from = their_props;
+      break;
+    case svn_wc_conflict_choose_merged:
+      resolve_from = NULL;
+      break;
+    default:
+      return svn_error_create(SVN_ERR_INCORRECT_PARAMS, NULL,
+                              _("Invalid 'conflict_result' argument"));
+    }
+
+  if (conflicted_props && apr_hash_count(conflicted_props) && resolve_from)
+    {
+      apr_hash_index_t *hi;
+      apr_hash_t *actual_props;
+
+      SVN_ERR(svn_wc__db_read_props(&actual_props, db, local_abspath,
+                                    scratch_pool, scratch_pool));
+
+      for (hi = apr_hash_first(scratch_pool, conflicted_props);
+           hi;
+           hi = apr_hash_next(hi))
+        {
+          const char *propname = svn__apr_hash_index_key(hi);
+          svn_string_t *new_value = NULL;
+
+          new_value = apr_hash_get(resolve_from, propname,
+                                   APR_HASH_KEY_STRING);
+
+          apr_hash_set(actual_props, propname, APR_HASH_KEY_STRING,
+                       new_value);
+        }
+      SVN_ERR(svn_wc__db_op_set_props(db, local_abspath, actual_props,
+                                      FALSE, NULL, NULL,
+                                      scratch_pool));
+    }
+
+  /* Legacy behavior: Only report property conflicts as resolved when the
+     property reject file exists
+
+     If not the UI shows the conflict as already resolved
+     (and in this case we just remove the in-db conflict) */
+
+  if (prop_reject_file)
+    {
+      SVN_ERR(svn_io_check_path(prop_reject_file, &node_kind, scratch_pool));
+      if (node_kind == svn_node_file)
+        {
+          svn_skel_t *work_item;
+
+          SVN_ERR(svn_wc__wq_build_file_remove(&work_item, db,
+                                               local_abspath,
+                                               prop_reject_file,
+                                               scratch_pool, scratch_pool));
+          *work_items = svn_wc__wq_merge(*work_items, work_item, scratch_pool);
+          *removed_reject_file = TRUE;
+        }
+    }
+
+  return SVN_NO_ERROR;
+}
+
+/*
+ * Resolve the tree conflict found in DB/LOCAL_ABSPATH/CONFLICTS
+ * according to CONFLICT_CHOICE.  (Don't mark it as resolved.)
+ *
+ * ### ... append to *WORK_ITEMS work items to ...?
+ *
+ * It is an error if there is no tree conflict.
+ */
+static svn_error_t *
+resolve_tree_conflict_on_node(svn_skel_t **work_items,
+                              svn_wc__db_t *db,
+                              const char *local_abspath,
+                              svn_wc_operation_t operation,
+                              svn_skel_t *conflicts,
+                              svn_wc_conflict_choice_t conflict_choice,
+                              svn_wc_notify_func2_t notify_func,
+                              void *notify_baton,
+                              svn_cancel_func_t cancel_func,
+                              void *cancel_baton,
+                              apr_pool_t *scratch_pool)
+{
+  svn_wc_conflict_reason_t reason;
+  svn_wc_conflict_action_t action;
+  svn_boolean_t did_resolve = FALSE;
+
+  SVN_ERR(svn_wc__conflict_read_tree_conflict(&reason, &action, NULL, 
+                                              db, local_abspath,
+                                              conflicts,
+                                              scratch_pool, scratch_pool));
+
+  if (operation == svn_wc_operation_update
+      || operation == svn_wc_operation_switch)
+    {
+      if (reason == svn_wc_conflict_reason_deleted ||
+          reason == svn_wc_conflict_reason_replaced)
+        {
+          if (conflict_choice == svn_wc_conflict_choose_merged)
+            {
+              /* Break moves for any children moved out of this directory,
+               * and leave this directory deleted. */
+              SVN_ERR(svn_wc__db_resolve_break_moved_away_children(
+                        db, local_abspath, notify_func, notify_baton,
+                        scratch_pool));
+              did_resolve = TRUE;
+            }
+          else if (conflict_choice == svn_wc_conflict_choose_mine_conflict)
+            {
+              /* Raised moved-away conflicts on any children moved out of
+               * this directory, and leave this directory deleted.
+               * The newly conflicted moved-away children will be updated
+               * if they are resolved with 'mine_conflict' as well. */
+              SVN_ERR(svn_wc__db_resolve_delete_raise_moved_away(
+                        db, local_abspath, notify_func, notify_baton,
+                        scratch_pool));
+              did_resolve = TRUE;
+            }
+          else
+            return svn_error_createf(SVN_ERR_WC_CONFLICT_RESOLVER_FAILURE,
+                                     NULL,
+                                     _("Tree conflict can only be resolved to "
+                                       "'working' or 'mine-conflict' state; "
+                                       "'%s' not resolved"),
+                                     svn_dirent_local_style(local_abspath,
+                                                            scratch_pool));
+        }
+      else if (reason == svn_wc_conflict_reason_moved_away
+              && action == svn_wc_conflict_action_edit)
+        {
+          /* After updates, we can resolve local moved-away
+           * vs. any incoming change, either by updating the
+           * moved-away node (mine-conflict) or by breaking the
+           * move (theirs-conflict). */
+          if (conflict_choice == svn_wc_conflict_choose_mine_conflict)
+            {
+              SVN_ERR(svn_wc__db_update_moved_away_conflict_victim(
+                        db, local_abspath,
+                        notify_func, notify_baton,
+                        cancel_func, cancel_baton,
+                        scratch_pool));
+              did_resolve = TRUE;
+            }
+          else if (conflict_choice == svn_wc_conflict_choose_merged)
+            {
+              /* We must break the move if the user accepts the current
+               * working copy state instead of updating the move.
+               * Else the move would be left in an invalid state. */
+
+              /* ### This breaks the move but leaves the conflict
+                 ### involving the move until
+                 ### svn_wc__db_op_mark_resolved. */
+              SVN_ERR(svn_wc__db_resolve_break_moved_away(db, local_abspath,
+                                                          notify_func,
+                                                          notify_baton,
+                                                          scratch_pool));
+              did_resolve = TRUE;
+            }
+          else
+            return svn_error_createf(SVN_ERR_WC_CONFLICT_RESOLVER_FAILURE,
+                                     NULL,
+                                     _("Tree conflict can only be resolved to "
+                                       "'working' or 'mine-conflict' state; "
+                                       "'%s' not resolved"),
+                                     svn_dirent_local_style(local_abspath,
+                                                            scratch_pool));
+        }
+    }
+
+  if (! did_resolve && conflict_choice != svn_wc_conflict_choose_merged)
+    {
+      /* For other tree conflicts, there is no way to pick
+       * theirs-full or mine-full, etc. Throw an error if the
+       * user expects us to be smarter than we really are. */
+      return svn_error_createf(SVN_ERR_WC_CONFLICT_RESOLVER_FAILURE,
+                               NULL,
+                               _("Tree conflict can only be "
+                                 "resolved to 'working' state; "
+                                 "'%s' not resolved"),
+                               svn_dirent_local_style(local_abspath,
+                                                      scratch_pool));
+    }
+
+  return SVN_NO_ERROR;
+}
+
 /* Conflict resolution involves removing the conflict files, if they exist,
    and clearing the conflict filenames from the entry.  The latter needs to
    be done whether or not the conflict files exist.
 
    ### This func combines *resolving* and *marking as resolved* -- seems poor.
 
-   ### Resolving is shared between this func and its caller
-       'conflict_status_walker()' -- seems poor.
-
    LOCAL_ABSPATH in DB is the path to the item to be resolved.
    RESOLVE_TEXT, RESOLVE_PROPS and RESOLVE_TREE are TRUE iff text, property
    and tree conflicts respectively are to be resolved.
@@ -2337,7 +2787,6 @@ resolve_conflict_on_node(svn_boolean_t *
                          svn_boolean_t resolve_props,
                          svn_boolean_t resolve_tree,
                          svn_wc_conflict_choice_t conflict_choice,
-                         svn_skel_t *work_items,
                          svn_wc_notify_func2_t notify_func,
                          void *notify_baton,
                          svn_cancel_func_t cancel_func,
@@ -2349,8 +2798,7 @@ resolve_conflict_on_node(svn_boolean_t *
   svn_boolean_t text_conflicted;
   svn_boolean_t prop_conflicted;
   svn_boolean_t tree_conflicted;
-  svn_skel_t *work_item;
-  apr_pool_t *pool = scratch_pool;
+  svn_skel_t *work_items = NULL;
 
   *did_resolve = FALSE;
 
@@ -2366,319 +2814,28 @@ resolve_conflict_on_node(svn_boolean_t *
                                      scratch_pool, scratch_pool));
 
   if (resolve_text && text_conflicted)
-    {
-      const char *conflict_old = NULL;
-      const char *conflict_new = NULL;
-      const char *conflict_working = NULL;
-      const char *auto_resolve_src;
-      svn_node_kind_t node_kind;
-
-      SVN_ERR(svn_wc__conflict_read_text_conflict(&conflict_working,
-                                                  &conflict_old,
-                                                  &conflict_new,
-                                                  db, local_abspath, conflicts,
-                                                  scratch_pool, scratch_pool));
-
-      /* Handle automatic conflict resolution before the temporary files are
-       * deleted, if necessary. */
-      switch (conflict_choice)
-        {
-        case svn_wc_conflict_choose_base:
-          auto_resolve_src = conflict_old;
-          break;
-        case svn_wc_conflict_choose_mine_full:
-          auto_resolve_src = conflict_working;
-          break;
-        case svn_wc_conflict_choose_theirs_full:
-          auto_resolve_src = conflict_new;
-          break;
-        case svn_wc_conflict_choose_merged:
-          auto_resolve_src = NULL;
-          break;
-        case svn_wc_conflict_choose_theirs_conflict:
-        case svn_wc_conflict_choose_mine_conflict:
-          {
-            if (conflict_old && conflict_working && conflict_new)
-              {
-                const char *temp_dir;
-                svn_stream_t *tmp_stream = NULL;
-                svn_diff_t *diff;
-                svn_diff_conflict_display_style_t style =
-                  conflict_choice == svn_wc_conflict_choose_theirs_conflict
-                  ? svn_diff_conflict_display_latest
-                  : svn_diff_conflict_display_modified;
-
-                SVN_ERR(svn_wc__db_temp_wcroot_tempdir(&temp_dir, db,
-                                                       local_abspath,
-                                                       pool, pool));
-                SVN_ERR(svn_stream_open_unique(&tmp_stream,
-                                               &auto_resolve_src,
-                                               temp_dir,
-                                               svn_io_file_del_on_pool_cleanup,
-                                               pool, pool));
-
-                SVN_ERR(svn_diff_file_diff3_2(&diff,
-                                              conflict_old,
-                                              conflict_working,
-                                              conflict_new,
-                                              svn_diff_file_options_create(pool),
-                                              pool));
-                SVN_ERR(svn_diff_file_output_merge2(tmp_stream, diff,
-                                                    conflict_old,
-                                                    conflict_working,
-                                                    conflict_new,
-                                                    /* markers ignored */
-                                                    NULL, NULL, NULL, NULL,
-                                                    style,
-                                                    pool));
-                SVN_ERR(svn_stream_close(tmp_stream));
-              }
-            else
-              auto_resolve_src = NULL;
-            break;
-          }
-        default:
-          return svn_error_create(SVN_ERR_INCORRECT_PARAMS, NULL,
-                                  _("Invalid 'conflict_result' argument"));
-        }
-
-      if (auto_resolve_src)
-        {
-          SVN_ERR(svn_wc__wq_build_file_copy_translated(
-                    &work_item, db, local_abspath,
-                    auto_resolve_src, local_abspath, pool, pool));
-          work_items = svn_wc__wq_merge(work_items, work_item, pool);
-
-          SVN_ERR(svn_wc__wq_build_sync_file_flags(&work_item, db,
-                                                   local_abspath,
-                                                   pool, pool));
-          work_items = svn_wc__wq_merge(work_items, work_item, pool);
-        }
-
-      /* Legacy behavior: Only report text conflicts as resolved when at least
-         one conflict marker file exists.
-
-         If not the UI shows the conflict as already resolved
-         (and in this case we just remove the in-db conflict) */
-
-      if (conflict_old)
-        {
-          SVN_ERR(svn_io_check_path(conflict_old, &node_kind, pool));
-          if (node_kind == svn_node_file)
-            {
-              SVN_ERR(svn_wc__wq_build_file_remove(&work_item, db,
-                                                   local_abspath,
-                                                   conflict_old,
-                                                   pool, pool));
-              work_items = svn_wc__wq_merge(work_items, work_item, pool);
-              *did_resolve = TRUE;
-            }
-        }
-
-      if (conflict_new)
-        {
-          SVN_ERR(svn_io_check_path(conflict_new, &node_kind, pool));
-          if (node_kind == svn_node_file)
-            {
-              SVN_ERR(svn_wc__wq_build_file_remove(&work_item, db,
-                                                   local_abspath,
-                                                   conflict_new,
-                                                   pool, pool));
-              work_items = svn_wc__wq_merge(work_items, work_item, pool);
-              *did_resolve = TRUE;
-            }
-        }
-
-      if (conflict_working)
-        {
-          SVN_ERR(svn_io_check_path(conflict_working, &node_kind, pool));
-          if (node_kind == svn_node_file)
-            {
-              SVN_ERR(svn_wc__wq_build_file_remove(&work_item, db,
-                                                   local_abspath,
-                                                   conflict_working,
-                                                   pool, pool));
-              work_items = svn_wc__wq_merge(work_items, work_item, pool);
-              *did_resolve = TRUE;
-            }
-        }
-    }
+    SVN_ERR(resolve_text_conflict_on_node(did_resolve, &work_items,
+                                          db, local_abspath,
+                                          operation, conflicts,
+                                          conflict_choice,
+                                          scratch_pool));
 
   if (resolve_props && prop_conflicted)
-    {
-      svn_node_kind_t node_kind;
-      const char *prop_reject_file;
-      apr_hash_t *mine_props;
-      apr_hash_t *their_old_props;
-      apr_hash_t *their_props;
-      apr_hash_t *conflicted_props;
-      apr_hash_t *old_props;
-      apr_hash_t *resolve_from = NULL;
-
-      SVN_ERR(svn_wc__conflict_read_prop_conflict(&prop_reject_file,
-                                                  &mine_props, &their_old_props,
-                                                  &their_props, &conflicted_props,
-                                                  db, local_abspath, conflicts,
-                                                  scratch_pool, scratch_pool));
-
-      if (operation == svn_wc_operation_merge)
-          SVN_ERR(svn_wc__db_read_pristine_props(&old_props, db, local_abspath,
-                                                 scratch_pool, scratch_pool));
-        else
-          old_props = their_old_props;
-
-      /* We currently handle *_conflict as *_full as this argument is currently
-         always applied for all conflicts on a node at the same time. Giving
-         an error would break some tests that assumed that this would just
-         resolve property conflicts to working.
-
-         An alternative way to handle these conflicts would be to just copy all
-         property state from mine/theirs on the _full option instead of just the
-         conflicted properties. In some ways this feels like a sensible option as
-         that would take both properties and text from mine/theirs, but when not
-         both properties and text are conflicted we would fail in doing so.
-       */
-      switch (conflict_choice)
-        {
-        case svn_wc_conflict_choose_base:
-          resolve_from = their_old_props ? their_old_props : old_props;
-          break;
-        case svn_wc_conflict_choose_mine_full:
-        case svn_wc_conflict_choose_mine_conflict:
-          resolve_from = mine_props;
-          break;
-        case svn_wc_conflict_choose_theirs_full:
-        case svn_wc_conflict_choose_theirs_conflict:
-          resolve_from = their_props;
-          break;
-        case svn_wc_conflict_choose_merged:
-          resolve_from = NULL;
-          break;
-        default:
-          return svn_error_create(SVN_ERR_INCORRECT_PARAMS, NULL,
-                                  _("Invalid 'conflict_result' argument"));
-        }
-
-      if (conflicted_props && apr_hash_count(conflicted_props) && resolve_from)
-        {
-          apr_hash_index_t *hi;
-          apr_hash_t *actual_props;
-
-          SVN_ERR(svn_wc__db_read_props(&actual_props, db, local_abspath,
-                                        scratch_pool, scratch_pool));
-
-          for (hi = apr_hash_first(scratch_pool, conflicted_props);
-               hi;
-               hi = apr_hash_next(hi))
-            {
-              const char *propname = svn__apr_hash_index_key(hi);
-              svn_string_t *new_value = NULL;
-
-              new_value = apr_hash_get(resolve_from, propname,
-                                       APR_HASH_KEY_STRING);
-
-              apr_hash_set(actual_props, propname, APR_HASH_KEY_STRING,
-                           new_value);
-            }
-          SVN_ERR(svn_wc__db_op_set_props(db, local_abspath, actual_props,
-                                          FALSE, NULL, NULL,
+    SVN_ERR(resolve_prop_conflict_on_node(did_resolve, &work_items,
+                                          db, local_abspath,
+                                          operation, conflicts,
+                                          conflict_choice,
                                           scratch_pool));
-        }
-
-      /* Legacy behavior: Only report property conflicts as resolved when the
-         property reject file exists
-
-         If not the UI shows the conflict as already resolved
-         (and in this case we just remove the in-db conflict) */
-
-      if (prop_reject_file)
-        {
-          SVN_ERR(svn_io_check_path(prop_reject_file, &node_kind, pool));
-          if (node_kind == svn_node_file)
-            {
-              SVN_ERR(svn_wc__wq_build_file_remove(&work_item, db,
-                                                   local_abspath,
-                                                   prop_reject_file,
-                                                   pool, pool));
-              work_items = svn_wc__wq_merge(work_items, work_item, pool);
-              *did_resolve = TRUE;
-            }
-        }
-    }
 
   if (resolve_tree)
     {
-      svn_wc_conflict_reason_t reason;
-      svn_wc_conflict_action_t action;
-
-      SVN_ERR(svn_wc__conflict_read_tree_conflict(&reason, &action, NULL, 
-                                                  db, local_abspath,
-                                                  conflicts,
-                                                  scratch_pool, scratch_pool));
-
-      if (operation == svn_wc_operation_update
-          || operation == svn_wc_operation_switch)
-        {
-          if (reason == svn_wc_conflict_reason_deleted)
-            {
-              if (conflict_choice == svn_wc_conflict_choose_merged)
-                {
-                  SVN_ERR(svn_wc__db_resolve_delete_raise_moved_away(
-                            db, local_abspath, notify_func, notify_baton,
-                            scratch_pool));
-                  *did_resolve = TRUE;
-                }
-            }
-          else if (reason == svn_wc_conflict_reason_moved_away
-                  && action == svn_wc_conflict_action_edit)
-            {
-              /* After updates, we can resolve local moved-away
-               * vs. any incoming change, either by updating the
-               * moved-away node (mine-conflict) or by breaking the
-               * move (theirs-conflict). */
-              if (conflict_choice == svn_wc_conflict_choose_mine_conflict)
-                {
-                  SVN_ERR(svn_wc__db_update_moved_away_conflict_victim(
-                            &work_items,
-                            db, local_abspath,
-                            notify_func, notify_baton,
-                            cancel_func, cancel_baton,
-                            scratch_pool, scratch_pool));
-                  *did_resolve = TRUE;
-                }
-              else if (conflict_choice == svn_wc_conflict_choose_theirs_conflict
-                       || conflict_choice == svn_wc_conflict_choose_merged)
-                {
-                  /* We must break the move even if the user accepts
-                   * the current working copy state (choose_merged)
-                   * instead of updating the move. Else the move would
-                   * be left in an invalid state. */
-
-                  /* ### This breaks the move but leaves the conflict
-                     ### involving the move until
-                     ### svn_wc__db_op_mark_resolved. */
-                  SVN_ERR(svn_wc__db_resolve_break_moved_away(db, local_abspath,
-                                                              scratch_pool));
-                  *did_resolve = TRUE;
-                }
-            }
-        }
-
-      if (*did_resolve == FALSE &&
-          conflict_choice != svn_wc_conflict_choose_merged)
-        {
-          /* For other tree conflicts, there is no way to pick
-           * theirs-full or mine-full, etc. Throw an error if the
-           * user expects us to be smarter than we really are. */
-          return svn_error_createf(SVN_ERR_WC_CONFLICT_RESOLVER_FAILURE,
-                                   NULL,
-                                   _("Tree conflict can only be "
-                                     "resolved to 'working' state; "
-                                     "'%s' not resolved"),
-                                   svn_dirent_local_style(local_abspath,
-                                                          scratch_pool));
-        }
-
+      SVN_ERR(resolve_tree_conflict_on_node(&work_items,
+                                            db, local_abspath,
+                                            operation, conflicts,
+                                            conflict_choice,
+                                            notify_func, notify_baton,
+                                            cancel_func, cancel_baton,
+                                            scratch_pool));
       *did_resolve = TRUE;
     }
 
@@ -2686,12 +2843,13 @@ resolve_conflict_on_node(svn_boolean_t *
     {
       SVN_ERR(svn_wc__db_op_mark_resolved(db, local_abspath,
                                           resolve_text, resolve_props,
-                                          resolve_tree, work_items, pool));
+                                          resolve_tree, work_items,
+                                          scratch_pool));
 
       /* Run the work queue to remove conflict marker files. */
       SVN_ERR(svn_wc__wq_run(db, local_abspath,
                              cancel_func, cancel_baton,
-                             pool));
+                             scratch_pool));
     }
 
   return SVN_NO_ERROR;
@@ -2712,7 +2870,6 @@ svn_wc__mark_resolved_text_conflict(svn_
                            FALSE /* resolve_props */,
                            FALSE /* resolve_tree */,
                            svn_wc_conflict_choose_merged,
-                           NULL,
                            NULL, NULL, /* notify_func */
                            NULL, NULL, /* cancel_func */
                            scratch_pool));
@@ -2732,7 +2889,6 @@ svn_wc__mark_resolved_prop_conflicts(svn
                            TRUE /* resolve_props */,
                            FALSE /* resolve_tree */,
                            svn_wc_conflict_choose_merged,
-                           NULL /* work_items */,
                            NULL, NULL, /* notify_func */
                            NULL, NULL, /* cancel_func */
                            scratch_pool));
@@ -2755,7 +2911,10 @@ struct conflict_status_walker_baton
   void *notify_baton;
 };
 
-/* Implements svn_wc_status4_t to walk all conflicts to resolve */
+/* Implements svn_wc_status4_t to walk all conflicts to resolve.
+ *
+ * ### Bug: ignores the resolver callback's 'result->merged_file' output.
+ */
 static svn_error_t *
 conflict_status_walker(void *baton,
                        const char *local_abspath,
@@ -2783,8 +2942,6 @@ conflict_status_walker(void *baton,
       const svn_wc_conflict_description2_t *cd;
       svn_boolean_t did_resolve;
       svn_wc_conflict_choice_t my_choice = cswb->conflict_choice;
-      svn_skel_t *work_items = NULL;
-
 
       cd = APR_ARRAY_IDX(conflicts, i, const svn_wc_conflict_description2_t *);
 
@@ -2803,6 +2960,7 @@ conflict_status_walker(void *baton,
                                       iterpool, iterpool));
 
           my_choice = result->choice;
+          /* ### Bug: ignores result->merged_file (and ->save_merged) */
         }
 
 
@@ -2821,7 +2979,6 @@ conflict_status_walker(void *baton,
                                              FALSE /* resolve_props */,
                                              TRUE /* resolve_tree */,
                                              my_choice,
-                                             work_items,
                                              cswb->notify_func,
                                              cswb->notify_baton,
                                              cswb->cancel_func,
@@ -2842,7 +2999,6 @@ conflict_status_walker(void *baton,
                                              FALSE /* resolve_props */,
                                              FALSE /* resolve_tree */,
                                              my_choice,
-                                             NULL,
                                              cswb->notify_func,
                                              cswb->notify_baton,
                                              cswb->cancel_func,
@@ -2874,7 +3030,6 @@ conflict_status_walker(void *baton,
                                              TRUE /* resolve_props */,
                                              FALSE /* resolve_tree */,
                                              my_choice,
-                                             NULL,
                                              cswb->notify_func,
                                              cswb->notify_baton,
                                              cswb->cancel_func,
@@ -2920,7 +3075,7 @@ svn_wc__resolve_conflicts(svn_wc_context
                           void *notify_baton,
                           apr_pool_t *scratch_pool)
 {
-  svn_kind_t kind;
+  svn_node_kind_t kind;
   svn_boolean_t conflicted;
   struct conflict_status_walker_baton cswb;
 
@@ -2942,7 +3097,7 @@ svn_wc__resolve_conflicts(svn_wc_context
 
   /* When the implementation still used the entry walker, depth
      unknown was translated to infinity. */
-  if (kind != svn_kind_dir)
+  if (kind != svn_node_dir)
     depth = svn_depth_empty;
   else if (depth == svn_depth_unknown)
     depth = svn_depth_infinity;

Modified: subversion/branches/verify-keep-going/subversion/libsvn_wc/conflicts.h
URL: http://svn.apache.org/viewvc/subversion/branches/verify-keep-going/subversion/libsvn_wc/conflicts.h?rev=1457684&r1=1457683&r2=1457684&view=diff
==============================================================================
--- subversion/branches/verify-keep-going/subversion/libsvn_wc/conflicts.h (original)
+++ subversion/branches/verify-keep-going/subversion/libsvn_wc/conflicts.h Mon Mar 18 09:35:24 2013
@@ -163,6 +163,8 @@ svn_wc__conflict_skel_add_text_conflict(
    The DB, WRI_ABSPATH pair specifies in which working copy the conflict
    will be recorded. (Needed for making the paths relative).
 
+   The MARKER_ABSPATH is NULL when raising a conflict in v1.8+.  See below.
+
    The MINE_PROPS, THEIR_OLD_PROPS and THEIR_PROPS are hashes mapping a
    const char * property name to a const svn_string_t* value.
 
@@ -174,8 +176,14 @@ svn_wc__conflict_skel_add_text_conflict(
    ### Maybe useful for calling (legacy) conflict resolvers that expect one
    ### property conflict per invocation.
 
-   It is an error to add another text conflict to a conflict skel that
-   already contains a text conflict.
+   When raising a property conflict in the course of upgrading an old WC,
+   MARKER_ABSPATH is the path to the file containing a human-readable
+   description of the conflict, MINE_PROPS and THEIR_OLD_PROPS and
+   THEIR_PROPS are all NULL, and CONFLICTED_PROP_NAMES is an empty hash.
+
+   It is an error to add another prop conflict to a conflict skel that
+   already contains a prop conflict.  (A single call to this function can
+   record that multiple properties are in conflict.)
 
    Do temporary allocations in SCRATCH_POOL.
 */
@@ -198,9 +206,6 @@ svn_wc__conflict_skel_add_prop_conflict(
    LOCAL_CHANGE is the local tree change made to the node.
    INCOMING_CHANGE is the incoming change made to the node.
 
-   It is an error to add another tree conflict to a conflict skel that
-   already contains a tree conflict.
-
    MOVE_SRC_OP_ROOT_ABSPATH must be set when LOCAL_CHANGE is
    svn_wc_conflict_reason_moved_away and NULL otherwise and the operation
    is svn_wc_operation_update or svn_wc_operation_switch.  It should be
@@ -215,7 +220,9 @@ svn_wc__conflict_skel_add_prop_conflict(
    with (1), MOVE_SRC_OP_ROOT_ABSPATH should be A/B for a conflict
    associated with (2).
 
-   ### Is it an error to add a tree conflict to any existing conflict?
+   It is an error to add another tree conflict to a conflict skel that
+   already contains a tree conflict.  (It is not an error, at this level,
+   to add a tree conflict to an existing text or property conflict skel.)
 
    Do temporary allocations in SCRATCH_POOL.
 */

Modified: subversion/branches/verify-keep-going/subversion/libsvn_wc/copy.c
URL: http://svn.apache.org/viewvc/subversion/branches/verify-keep-going/subversion/libsvn_wc/copy.c?rev=1457684&r1=1457683&r2=1457684&view=diff
==============================================================================
--- subversion/branches/verify-keep-going/subversion/libsvn_wc/copy.c (original)
+++ subversion/branches/verify-keep-going/subversion/libsvn_wc/copy.c Mon Mar 18 09:35:24 2013
@@ -171,7 +171,7 @@ copy_to_tmpdir(svn_skel_t **work_item,
    versioned file itself.
 
    This also works for versioned symlinks that are stored in the db as
-   svn_kind_file with svn:special set. */
+   svn_node_file with svn:special set. */
 static svn_error_t *
 copy_versioned_file(svn_wc__db_t *db,
                     const char *src_abspath,
@@ -381,7 +381,7 @@ copy_versioned_dir(svn_wc__db_t *db,
           || info->status == svn_wc__db_status_added)
         {
           /* We have more work to do than just changing the DB */
-          if (info->kind == svn_kind_file)
+          if (info->kind == svn_node_file)
             {
               /* We should skip this node if this child is a file external
                  (issues #3589, #4000) */
@@ -397,7 +397,7 @@ copy_versioned_dir(svn_wc__db_t *db,
                                             NULL, NULL,
                                             iterpool));
             }
-          else if (info->kind == svn_kind_dir)
+          else if (info->kind == svn_node_dir)
             SVN_ERR(copy_versioned_dir(db,
                                        child_src_abspath, child_dst_abspath,
                                        dst_op_root_abspath, tmpdir_abspath,
@@ -429,7 +429,7 @@ copy_versioned_dir(svn_wc__db_t *db,
              copy as much as possible, or give up early? */
           return svn_error_createf(SVN_ERR_WC_PATH_UNEXPECTED_STATUS, NULL,
                                    _("Cannot handle status of '%s'"),
-                                   svn_dirent_local_style(src_abspath,
+                                   svn_dirent_local_style(child_src_abspath,
                                                           iterpool));
         }
       else
@@ -438,7 +438,7 @@ copy_versioned_dir(svn_wc__db_t *db,
 
           return svn_error_createf(SVN_ERR_WC_PATH_UNEXPECTED_STATUS, NULL,
                                    _("Cannot copy '%s' excluded by server"),
-                                   svn_dirent_local_style(src_abspath,
+                                   svn_dirent_local_style(child_src_abspath,
                                                           iterpool));
         }
 
@@ -524,13 +524,14 @@ copy_or_move(svn_boolean_t *move_degrade
              apr_pool_t *scratch_pool)
 {
   svn_wc__db_t *db = wc_ctx->db;
-  svn_kind_t src_db_kind;
+  svn_node_kind_t src_db_kind;
   const char *dstdir_abspath;
   svn_boolean_t conflicted;
   const char *tmpdir_abspath;
   const char *src_wcroot_abspath;
   const char *dst_wcroot_abspath;
   svn_boolean_t within_one_wc;
+  svn_wc__db_status_t src_status;
   svn_error_t *err;
 
   SVN_ERR_ASSERT(svn_dirent_is_absolute(src_abspath));
@@ -541,15 +542,17 @@ copy_or_move(svn_boolean_t *move_degrade
   /* Ensure DSTDIR_ABSPATH belongs to the same repository as SRC_ABSPATH;
      throw an error if not. */
   {
-    svn_wc__db_status_t src_status, dstdir_status;
+    svn_wc__db_status_t dstdir_status;
     const char *src_repos_root_url, *dst_repos_root_url;
     const char *src_repos_uuid, *dst_repos_uuid;
+    const char *src_repos_relpath;
 
-    err = svn_wc__db_read_info(&src_status, &src_db_kind, NULL, NULL,
-                               &src_repos_root_url, &src_repos_uuid, NULL,
-                               NULL, NULL, NULL, NULL, NULL, NULL, NULL,
-                               NULL, NULL, NULL, NULL, NULL, NULL, &conflicted,
-                               NULL, NULL, NULL, NULL, NULL, NULL,
+    err = svn_wc__db_read_info(&src_status, &src_db_kind, NULL,
+                               &src_repos_relpath, &src_repos_root_url,
+                               &src_repos_uuid, NULL, NULL, NULL, NULL, NULL,
+                               NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
+                               NULL, &conflicted, NULL, NULL, NULL, NULL,
+                               NULL, NULL,
                                db, src_abspath, scratch_pool, scratch_pool);
 
     if (err && err->apr_err == SVN_ERR_WC_PATH_NOT_FOUND)
@@ -587,6 +590,23 @@ copy_or_move(svn_boolean_t *move_degrade
           break;
       }
 
+     if (is_move && ! strcmp(src_abspath, src_wcroot_abspath))
+      {
+        return svn_error_createf(SVN_ERR_WC_PATH_UNEXPECTED_STATUS, NULL,
+                                 _("'%s' is the root of a working copy and "
+                                   "cannot be moved"),
+                                   svn_dirent_local_style(src_abspath,
+                                                          scratch_pool));
+      }
+    if (is_move && src_repos_relpath && !src_repos_relpath[0])
+      {
+        return svn_error_createf(SVN_ERR_WC_PATH_UNEXPECTED_STATUS, NULL,
+                                 _("'%s' represents the repository root "
+                                   "and cannot be moved"),
+                                 svn_dirent_local_style(src_abspath,
+                                                        scratch_pool));
+      }
+
     err = svn_wc__db_read_info(&dstdir_status, NULL, NULL, NULL,
                                &dst_repos_root_url, &dst_repos_uuid, NULL,
                                NULL, NULL, NULL, NULL, NULL, NULL, NULL,
@@ -618,7 +638,7 @@ copy_or_move(svn_boolean_t *move_degrade
           SVN_ERR(svn_wc__db_scan_addition(NULL, NULL, NULL,
                                            &src_repos_root_url,
                                            &src_repos_uuid, NULL, NULL, NULL,
-                                           NULL, NULL, NULL,
+                                           NULL,
                                            db, src_abspath,
                                            scratch_pool, scratch_pool));
         else
@@ -635,7 +655,7 @@ copy_or_move(svn_boolean_t *move_degrade
           SVN_ERR(svn_wc__db_scan_addition(NULL, NULL, NULL,
                                            &dst_repos_root_url,
                                            &dst_repos_uuid, NULL, NULL, NULL,
-                                           NULL, NULL, NULL,
+                                           NULL,
                                            db, dstdir_abspath,
                                            scratch_pool, scratch_pool));
         else
@@ -728,13 +748,13 @@ copy_or_move(svn_boolean_t *move_degrade
 
   within_one_wc = (strcmp(src_wcroot_abspath, dst_wcroot_abspath) == 0);
 
-  if (move_degraded_to_copy != NULL)
+  if (is_move
+      && !within_one_wc)
     {
-      /* Cross-WC moves cannot be tracked.
-       * Degrade such moves to a copy+delete. */
-      *move_degraded_to_copy = (is_move && !within_one_wc);
-      if (*move_degraded_to_copy)
-        is_move = FALSE;
+      if (move_degraded_to_copy)
+        *move_degraded_to_copy = TRUE;
+
+      is_move = FALSE;
     }
 
   if (!within_one_wc)
@@ -742,8 +762,8 @@ copy_or_move(svn_boolean_t *move_degrade
                                          cancel_func, cancel_baton,
                                          scratch_pool));
 
-  if (src_db_kind == svn_kind_file
-      || src_db_kind == svn_kind_symlink)
+  if (src_db_kind == svn_node_file
+      || src_db_kind == svn_node_symlink)
     {
       err = copy_versioned_file(db, src_abspath, dst_abspath, dst_abspath,
                                 tmpdir_abspath,
@@ -754,7 +774,8 @@ copy_or_move(svn_boolean_t *move_degrade
     }
   else
     {
-      if (is_move && !allow_mixed_revisions)
+      if (is_move
+          && src_status == svn_wc__db_status_normal)
         {
           svn_revnum_t min_rev;
           svn_revnum_t max_rev;
@@ -764,12 +785,20 @@ copy_or_move(svn_boolean_t *move_degrade
                                                src_abspath, FALSE, scratch_pool));
           if (SVN_IS_VALID_REVNUM(min_rev) && SVN_IS_VALID_REVNUM(max_rev) &&
               min_rev != max_rev)
-            return svn_error_createf(SVN_ERR_WC_MIXED_REVISIONS, NULL,
-                                     _("Cannot move mixed-revision subtree '%s' "
-                                       "[%ld:%ld]; try updating it first"),
-                                       svn_dirent_local_style(src_abspath,
-                                                              scratch_pool),
-                                       min_rev, max_rev);
+            {
+              if (!allow_mixed_revisions)
+                return svn_error_createf(SVN_ERR_WC_MIXED_REVISIONS, NULL,
+                                         _("Cannot move mixed-revision "
+                                           "subtree '%s' [%ld:%ld]; "
+                                           "try updating it first"),
+                                         svn_dirent_local_style(src_abspath,
+                                                                scratch_pool),
+                                         min_rev, max_rev);
+
+              is_move = FALSE;
+              if (move_degraded_to_copy)
+                *move_degraded_to_copy = TRUE;
+            }
         }
 
       err = copy_versioned_dir(db, src_abspath, dst_abspath, dst_abspath,
@@ -782,6 +811,13 @@ copy_or_move(svn_boolean_t *move_degrade
   if (err && svn_error_find_cause(err, SVN_ERR_CANCELLED))
     return svn_error_trace(err);
 
+  if (is_move)
+    err = svn_error_compose_create(err,
+                svn_wc__db_op_handle_move_back(NULL,
+                                               db, dst_abspath, src_abspath,
+                                               NULL /* work_items */,
+                                               scratch_pool));
+
   /* Run the work queue with the remaining work */
   SVN_ERR(svn_error_compose_create(
                                 err,
@@ -836,7 +872,7 @@ remove_node_conflict_markers(svn_wc__db_
   svn_skel_t *conflict;
 
   SVN_ERR(svn_wc__db_read_conflict(&conflict, db, src_abspath,
-                                 scratch_pool, scratch_pool));
+                                   scratch_pool, scratch_pool));
 
   /* Do we have conflict markers that should be removed? */
   if (conflict != NULL)
@@ -918,7 +954,7 @@ remove_all_conflict_markers(svn_wc__db_t
                             svn_dirent_join(wc_dir_abspath, name, iterpool),
                             iterpool));
         }
-      if (info->kind == svn_kind_dir)
+      if (info->kind == svn_node_dir)
         {
           svn_pool_clear(iterpool);
           SVN_ERR(remove_all_conflict_markers(
@@ -947,6 +983,8 @@ svn_wc__move2(svn_wc_context_t *wc_ctx,
 {
   svn_wc__db_t *db = wc_ctx->db;
   svn_boolean_t move_degraded_to_copy = FALSE;
+  svn_node_kind_t kind;
+  svn_boolean_t conflicted;
 
   /* Verify that we have the required write locks. */
   SVN_ERR(svn_wc__write_check(wc_ctx->db,
@@ -965,7 +1003,7 @@ svn_wc__move2(svn_wc_context_t *wc_ctx,
                        notify_func, notify_baton,
                        scratch_pool));
 
-  /* An iterrupt at this point will leave the new copy marked as
+  /* An interrupt at this point will leave the new copy marked as
      moved-here but the source has not yet been deleted or marked as
      moved-to. */
 
@@ -982,32 +1020,29 @@ svn_wc__move2(svn_wc_context_t *wc_ctx,
   if (!metadata_only)
     SVN_ERR(svn_io_file_rename(src_abspath, dst_abspath, scratch_pool));
 
-  {
-    svn_kind_t kind;
-    svn_boolean_t conflicted;
+  SVN_ERR(svn_wc__db_read_info(NULL, &kind, NULL, NULL, NULL, NULL, NULL,
+                               NULL, NULL, NULL, NULL, NULL, NULL, NULL,
+                               NULL, NULL, NULL, NULL, NULL, NULL,
+                               &conflicted, NULL, NULL, NULL,
+                               NULL, NULL, NULL,
+                               db, src_abspath,
+                               scratch_pool, scratch_pool));
 
-    SVN_ERR(svn_wc__db_read_info(NULL, &kind, NULL, NULL, NULL, NULL, NULL,
-                                 NULL, NULL, NULL, NULL, NULL, NULL, NULL,
-                                 NULL, NULL, NULL, NULL, NULL, NULL,
-                                 &conflicted, NULL, NULL, NULL,
-                                 NULL, NULL, NULL,
-                                 db, src_abspath,
-                                 scratch_pool, scratch_pool));
-
-    if (kind == svn_kind_dir)
-      SVN_ERR(remove_all_conflict_markers(db, src_abspath, dst_abspath,
-                                          scratch_pool));
-
-    if (conflicted)
-      SVN_ERR(remove_node_conflict_markers(db, src_abspath, dst_abspath,
-                                           scratch_pool));
-  }
+  if (kind == svn_node_dir)
+    SVN_ERR(remove_all_conflict_markers(db, src_abspath, dst_abspath,
+                                        scratch_pool));
 
-  SVN_ERR(svn_wc__delete_internal(wc_ctx, src_abspath, TRUE, FALSE,
-                                  move_degraded_to_copy ? NULL : dst_abspath,
-                                  cancel_func, cancel_baton,
-                                  notify_func, notify_baton,
-                                  scratch_pool));
+  if (conflicted)
+    SVN_ERR(remove_node_conflict_markers(db, src_abspath, dst_abspath,
+                                         scratch_pool));
+
+  SVN_ERR(svn_wc__db_op_delete(db, src_abspath,
+                               move_degraded_to_copy ? NULL : dst_abspath,
+                               TRUE /* delete_dir_externals */,
+                               NULL /* conflict */, NULL /* work_items */,
+                               cancel_func, cancel_baton,
+                               notify_func, notify_baton,
+                               scratch_pool));
 
   return SVN_NO_ERROR;
 }

Modified: subversion/branches/verify-keep-going/subversion/libsvn_wc/crop.c
URL: http://svn.apache.org/viewvc/subversion/branches/verify-keep-going/subversion/libsvn_wc/crop.c?rev=1457684&r1=1457683&r2=1457684&view=diff
==============================================================================
--- subversion/branches/verify-keep-going/subversion/libsvn_wc/crop.c (original)
+++ subversion/branches/verify-keep-going/subversion/libsvn_wc/crop.c Mon Mar 18 09:35:24 2013
@@ -84,7 +84,7 @@ crop_children(svn_wc__db_t *db,
       const char *child_name = APR_ARRAY_IDX(children, i, const char *);
       const char *child_abspath;
       svn_wc__db_status_t child_status;
-      svn_kind_t kind;
+      svn_node_kind_t kind;
       svn_depth_t child_depth;
 
       svn_pool_clear(iterpool);
@@ -103,7 +103,7 @@ crop_children(svn_wc__db_t *db,
           child_status == svn_wc__db_status_excluded ||
           child_status == svn_wc__db_status_not_present)
         {
-          svn_depth_t remove_below = (kind == svn_kind_dir)
+          svn_depth_t remove_below = (kind == svn_node_dir)
                                             ? svn_depth_immediates
                                             : svn_depth_files;
           if (new_depth < remove_below)
@@ -115,7 +115,7 @@ crop_children(svn_wc__db_t *db,
 
           continue;
         }
-      else if (kind == svn_kind_file)
+      else if (kind == svn_node_file)
         {
           if (new_depth == svn_depth_empty)
             SVN_ERR(svn_wc__db_op_remove_node(NULL,
@@ -124,7 +124,7 @@ crop_children(svn_wc__db_t *db,
                                               FALSE /* destroy_changes */,
                                               SVN_INVALID_REVNUM,
                                               svn_wc__db_status_not_present,
-                                              svn_kind_none,
+                                              svn_node_none,
                                               NULL, NULL,
                                               cancel_func, cancel_baton,
                                               iterpool));
@@ -132,7 +132,7 @@ crop_children(svn_wc__db_t *db,
             continue;
 
         }
-      else if (kind == svn_kind_dir)
+      else if (kind == svn_node_dir)
         {
           if (new_depth < svn_depth_immediates)
             {
@@ -142,7 +142,7 @@ crop_children(svn_wc__db_t *db,
                                                 FALSE /* destroy_changes */,
                                                 SVN_INVALID_REVNUM,
                                                 svn_wc__db_status_not_present,
-                                                svn_kind_none,
+                                                svn_node_none,
                                                 NULL, NULL,
                                                 cancel_func, cancel_baton,
                                                 iterpool));
@@ -194,7 +194,7 @@ svn_wc_exclude(svn_wc_context_t *wc_ctx,
 {
   svn_boolean_t is_root, is_switched;
   svn_wc__db_status_t status;
-  svn_kind_t kind;
+  svn_node_kind_t kind;
   svn_revnum_t revision;
   const char *repos_relpath, *repos_root, *repos_uuid;
 
@@ -297,7 +297,7 @@ svn_wc_crop_tree2(svn_wc_context_t *wc_c
 {
   svn_wc__db_t *db = wc_ctx->db;
   svn_wc__db_status_t status;
-  svn_kind_t kind;
+  svn_node_kind_t kind;
   svn_depth_t dir_depth;
 
   /* Only makes sense when the depth is restrictive. */
@@ -314,7 +314,7 @@ svn_wc_crop_tree2(svn_wc_context_t *wc_c
                                db, local_abspath,
                                scratch_pool, scratch_pool));
 
-  if (kind != svn_kind_dir)
+  if (kind != svn_node_dir)
     return svn_error_create(SVN_ERR_UNSUPPORTED_FEATURE, NULL,
       _("Can only crop directories"));
 



Mime
View raw message