dev/svnmover/svnmover.c

/*
 * svnmover.c: Concept Demo for Move Tracking and Branching
 *
 * ====================================================================
 *    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.
 * ====================================================================
 */

#include <stdio.h>
#include <string.h>
#include <assert.h>

#include <apr_lib.h>

#include "svn_private_config.h"
#include "svn_hash.h"
#include "svn_iter.h"
#include "svn_client.h"
#include "svn_cmdline.h"
#include "svn_config.h"
#include "svn_error.h"
#include "svn_path.h"
#include "svn_pools.h"
#include "svn_props.h"
#include "svn_string.h"
#include "svn_subst.h"
#include "svn_utf.h"
#include "svn_version.h"
#include "svnmover.h"

#include "private/svn_cmdline_private.h"
#include "private/svn_subr_private.h"
#include "private/svn_branch_repos.h"
#include "private/svn_branch_nested.h"
#include "private/svn_branch_compat.h"
#include "private/svn_ra_private.h"
#include "private/svn_string_private.h"
#include "private/svn_sorts_private.h"
#include "private/svn_token.h"
#include "private/svn_client_private.h"
#include "private/svn_delta_private.h"

#ifdef HAVE_LINENOISE
#include "linenoise/linenoise.h"
#endif

/* Version compatibility check */
static svn_error_t *
check_lib_versions(void)
{
  static const svn_version_checklist_t checklist[] =
    {
      { "svn_client", svn_client_version },
      { "svn_subr",   svn_subr_version },
      { "svn_ra",     svn_ra_version },
      { NULL, NULL }
    };
  SVN_VERSION_DEFINE(my_version);

  return svn_ver_check_list2(&my_version, checklist, svn_ver_equal);
}

static svn_boolean_t quiet = FALSE;

/* UI mode: whether to display output in terms of paths or elements */
int the_ui_mode = UI_MODE_EIDS;
static const svn_token_map_t ui_mode_map[]
  = { {"eids", UI_MODE_EIDS},
      {"e", UI_MODE_EIDS},
      {"paths", UI_MODE_PATHS},
      {"p", UI_MODE_PATHS},
      {"serial", UI_MODE_SERIAL},
      {"s", UI_MODE_SERIAL},
      {NULL, SVN_TOKEN_UNKNOWN} };

#define is_branch_root_element(branch, eid) \
  (svn_branch__root_eid(branch) == (eid))

/* Is BRANCH1 the same branch as BRANCH2? Compare by full branch-ids; don't
   require identical branch objects. */
#define BRANCH_IS_SAME_BRANCH(branch1, branch2, scratch_pool) \
  (strcmp(svn_branch__get_id(branch1, scratch_pool), \
          svn_branch__get_id(branch2, scratch_pool)) == 0)

static svn_boolean_t use_coloured_output = FALSE;

#ifndef WIN32

/* Some ANSI escape codes for controlling text colour in terminal output. */
#define TEXT_RESET      "\x1b[0m"
#define TEXT_FG_BLACK   "\x1b[30m"
#define TEXT_FG_RED     "\x1b[31m"
#define TEXT_FG_GREEN   "\x1b[32m"
#define TEXT_FG_YELLOW  "\x1b[33m"
#define TEXT_FG_BLUE    "\x1b[34m"
#define TEXT_FG_MAGENTA "\x1b[35m"
#define TEXT_FG_CYAN    "\x1b[36m"
#define TEXT_FG_WHITE   "\x1b[37m"
#define TEXT_BG_BLACK   "\x1b[40m"
#define TEXT_BG_RED     "\x1b[41m"
#define TEXT_BG_GREEN   "\x1b[42m"
#define TEXT_BG_YELLOW  "\x1b[43m"
#define TEXT_BG_BLUE    "\x1b[44m"
#define TEXT_BG_MAGENTA "\x1b[45m"
#define TEXT_BG_CYAN    "\x1b[46m"
#define TEXT_BG_WHITE   "\x1b[47m"

#define settext(text_attr) \
  do { \
    if (use_coloured_output) \
      { fputs(text_attr, stdout); fflush(stdout); } \
  } while (0)
#define settext_stderr(text_attr) \
  do { \
    if (use_coloured_output) \
      { fputs(text_attr, stderr); fflush(stderr); } \
  } while (0)

#else

/* To support colour on Windows, we could try:
 *
 * https://github.com/mattn/ansicolor-w32.c
 *
 * (I notice some obvious bugs in its puts/fputs implementations: the #defines
 * point to _fprintf_w32 instead of _fputs_w32, and puts() fails to append a
 * newline).
 */

#define settext(code)
#define settext_stderr(code)

#endif

__attribute__((format(printf, 1, 2)))
void
svnmover_notify(const char *fmt,
                ...)
{
  va_list ap;

  settext(TEXT_FG_GREEN);
  va_start(ap, fmt);
  vprintf(fmt, ap);
  va_end(ap);
  settext(TEXT_RESET);
  printf("\n");
}

__attribute__((format(printf, 1, 2)))
void
svnmover_notify_v(const char *fmt,
                  ...)
{
  va_list ap;

  if (! quiet)
    {
      settext(TEXT_FG_BLUE);
      va_start(ap, fmt);
      vprintf(fmt, ap);
      va_end(ap);
      settext(TEXT_RESET);
      printf("\n");
    }
}

#define SVN_CL__LOG_SEP_STRING \
  "------------------------------------------------------------------------\n"

/* ====================================================================== */

/* Set the WC base revision of element EID to BASE_REV.
 */
static void
svnmover_wc_set_base_rev(svnmover_wc_t *wc,
                         svn_branch__state_t *branch,
                         int eid,
                         svn_revnum_t base_rev)
{
  apr_hash_t *branch_base_revs = svn_hash_gets(wc->base_revs, branch->bid);
  void *val = apr_pmemdup(wc->pool, &base_rev, sizeof(base_rev));

  if (!branch_base_revs)
    {
      branch_base_revs = apr_hash_make(wc->pool);
      svn_hash_sets(wc->base_revs, apr_pstrdup(wc->pool, branch->bid),
                    branch_base_revs);
    }
  svn_eid__hash_set(branch_base_revs, eid, val);
}

/* Get the WC base revision of element EID, or SVN_INVALID_REVNUM if
 * element EID is not present in the WC base.
 */
static svn_revnum_t
svnmover_wc_get_base_rev(svnmover_wc_t *wc,
                         svn_branch__state_t *branch,
                         int eid,
                         apr_pool_t *scratch_pool)
{
  apr_hash_t *branch_base_revs = svn_hash_gets(wc->base_revs, branch->bid);
  svn_error_t *err;
  svn_element__content_t *element;
  svn_revnum_t *base_rev_p;

  if (!branch_base_revs)
    {
      return SVN_INVALID_REVNUM;
    }
  err = svn_branch__state_get_element(branch, &element, eid, scratch_pool);
  if (err || !element)
    {
      svn_error_clear(err);
      return SVN_INVALID_REVNUM;
    }

  base_rev_p = svn_eid__hash_get(branch_base_revs, eid);
  if (! base_rev_p)
    return SVN_INVALID_REVNUM;
  return *base_rev_p;
}

/* Set the WC base revision to BASE_REV for each element in WC base branch
 * BRANCH, including nested branches.
 */
static svn_error_t *
svnmover_wc_set_base_revs_r(svnmover_wc_t *wc,
                            svn_branch__state_t *branch,
                            svn_revnum_t base_rev,
                            apr_pool_t *scratch_pool)
{
  svn_element__tree_t *elements;
  apr_hash_index_t *hi;

  SVN_ERR(svn_branch__state_get_elements(branch, &elements, scratch_pool));
  for (hi = apr_hash_first(scratch_pool, elements->e_map);
       hi; hi = apr_hash_next(hi))
    {
      int eid = svn_eid__hash_this_key(hi);
      svn_element__content_t *element;

      svnmover_wc_set_base_rev(wc, branch, eid, base_rev);

      /* recurse into nested branches */
      SVN_ERR(svn_branch__state_get_element(branch, &element, eid,
                                            scratch_pool));
      if (element->payload->is_subbranch_root)
        {
          const char *subbranch_id
            = svn_branch__id_nest(branch->bid, eid, scratch_pool);
          svn_branch__state_t *subbranch
            = svn_branch__txn_get_branch_by_id(branch->txn, subbranch_id,
                                               scratch_pool);

          SVN_ERR(svnmover_wc_set_base_revs_r(wc, subbranch,
                                              base_rev, scratch_pool));
        }
    }

  return SVN_NO_ERROR;
}

/* Set the WC base revision to BASE_REV for each element in WC base branch
 * BRANCH, including nested branches.
 */
static svn_error_t *
svnmover_wc_set_base_revs(svnmover_wc_t *wc,
                          svn_branch__state_t *branch,
                          svn_revnum_t base_rev,
                          apr_pool_t *scratch_pool)
{
  wc->base_revs = apr_hash_make(wc->pool);
  SVN_ERR(svnmover_wc_set_base_revs_r(wc, branch, base_rev, scratch_pool));
  return SVN_NO_ERROR;
}

/* Get the lowest and highest base revision numbers in WC base branch
 * BRANCH, including nested branches.
 */
static svn_error_t *
svnmover_wc_get_base_revs_r(svnmover_wc_t *wc,
                            svn_revnum_t *base_rev_min,
                            svn_revnum_t *base_rev_max,
                            svn_branch__state_t *branch,
                            apr_pool_t *scratch_pool)
{
  svn_element__tree_t *base_elements;
  apr_hash_index_t *hi;

  SVN_ERR(svn_branch__state_get_elements(branch, &base_elements,
                                         scratch_pool));

  for (hi = apr_hash_first(scratch_pool, base_elements->e_map);
       hi; hi = apr_hash_next(hi))
    {
      int eid = svn_eid__hash_this_key(hi);
      svn_revnum_t rev = svnmover_wc_get_base_rev(wc, branch, eid,
                                                  scratch_pool);
      svn_element__content_t *element;

      if (*base_rev_min == SVN_INVALID_REVNUM
          || rev < *base_rev_min)
        *base_rev_min = rev;
      if (*base_rev_max == SVN_INVALID_REVNUM
          || rev > *base_rev_max)
        *base_rev_max = rev;

      /* recurse into nested branches */
      SVN_ERR(svn_branch__state_get_element(branch, &element, eid,
                                            scratch_pool));
      if (element->payload->is_subbranch_root)
        {
          const char *subbranch_id
            = svn_branch__id_nest(branch->bid, eid, scratch_pool);
          svn_branch__state_t *subbranch
            = svn_branch__txn_get_branch_by_id(branch->txn, subbranch_id,
                                               scratch_pool);

          SVN_ERR(svnmover_wc_get_base_revs_r(wc, base_rev_min, base_rev_max,
                                              subbranch, scratch_pool));
        }
    }

  return SVN_NO_ERROR;
}

/* Get the lowest and highest base revision numbers in WC.
 */
static svn_error_t *
svnmover_wc_get_base_revs(svnmover_wc_t *wc,
                          svn_revnum_t *base_rev_min,
                          svn_revnum_t *base_rev_max,
                          apr_pool_t *scratch_pool)
{
  *base_rev_min = SVN_INVALID_REVNUM;
  *base_rev_max = SVN_INVALID_REVNUM;
  SVN_ERR(svnmover_wc_get_base_revs_r(wc, base_rev_min, base_rev_max,
                                      wc->base->branch, scratch_pool));
  return SVN_NO_ERROR;
}

/* Update the WC to revision BASE_REVISION (SVN_INVALID_REVNUM means HEAD).
 *
 * Requires these fields in WC:
 *   head_revision
 *   repos_root_url
 *   ra_session
 *   pool
 *
 * Initializes these fields in WC:
 *   base_revision
 *   base_branch_id
 *   base_branch
 *   working_branch_id
 *   working_branch
 *   editor
 *
 * Assumes there are no changes in the WC: throws away the existing txn
 * and starts a new one.
 */
static svn_error_t *
wc_checkout(svnmover_wc_t *wc,
            svn_revnum_t base_revision,
            const char *base_branch_id,
            apr_pool_t *scratch_pool)
{
  const char *branch_info_dir = NULL;
  svn_branch__compat_fetch_func_t fetch_func;
  void *fetch_baton;
  svn_branch__txn_t *base_txn;

  /* Validate and store the new base revision number */
  if (! SVN_IS_VALID_REVNUM(base_revision))
    base_revision = wc->head_revision;
  else if (base_revision > wc->head_revision)
    return svn_error_createf(SVN_ERR_FS_NO_SUCH_REVISION, NULL,
                             _("No such revision %ld (HEAD is %ld)"),
                             base_revision, wc->head_revision);

  /* Choose whether to store branching info in a local dir or in revprops.
     (For now, just to exercise the options, we choose local files for
     RA-local and revprops for a remote repo.) */
  if (strncmp(wc->repos_root_url, "file://", 7) == 0)
    {
      const char *repos_dir;

      SVN_ERR(svn_uri_get_dirent_from_file_url(&repos_dir, wc->repos_root_url,
                                               scratch_pool));
      branch_info_dir = svn_dirent_join(repos_dir, "branch-info", scratch_pool);
    }

  /* Get a mutable transaction based on that rev. (This implementation
     re-reads all the move-tracking data from the repository.) */
  SVN_ERR(svn_ra_load_branching_state(&wc->edit_txn,
                                      &fetch_func, &fetch_baton,
                                      wc->ra_session, branch_info_dir,
                                      base_revision,
                                      wc->pool, scratch_pool));

  wc->edit_txn = svn_branch__nested_txn_create(wc->edit_txn, wc->pool);

  /* Store the WC base state */
  base_txn = svn_branch__repos_get_base_revision_root(wc->edit_txn);
  wc->base = apr_pcalloc(wc->pool, sizeof(*wc->base));
  wc->base->revision = base_revision;
  wc->base->branch
    = svn_branch__txn_get_branch_by_id(base_txn, base_branch_id, scratch_pool);
  if (! wc->base->branch)
    return svn_error_createf(SVN_BRANCH__ERR, NULL,
                             "Cannot check out WC: branch %s not found in r%ld",
                             base_branch_id, base_revision);
  SVN_ERR(svnmover_wc_set_base_revs(wc, wc->base->branch,
                                    base_revision, scratch_pool));

  wc->working = apr_pcalloc(wc->pool, sizeof(*wc->working));
  wc->working->revision = SVN_INVALID_REVNUM;
  wc->working->branch
    = svn_branch__txn_get_branch_by_id(wc->edit_txn, base_branch_id,
                                       scratch_pool);
  SVN_ERR_ASSERT(wc->working->branch);

  return SVN_NO_ERROR;
}

/* Create a simulated WC, in memory.
 *
 * Initializes these fields in WC:
 *   head_revision
 *   repos_root_url
 *   ra_session
 *   made_changes
 *   ctx
 *   pool
 *
 * BASE_REVISION is the revision to work on, or SVN_INVALID_REVNUM for HEAD.
 */
static svn_error_t *
wc_create(svnmover_wc_t **wc_p,
          const char *anchor_url,
          svn_revnum_t base_revision,
          const char *base_branch_id,
          svn_client_ctx_t *ctx,
          apr_pool_t *result_pool,
          apr_pool_t *scratch_pool)
{
  apr_pool_t *wc_pool = svn_pool_create(result_pool);
  svnmover_wc_t *wc = apr_pcalloc(wc_pool, sizeof(*wc));

  wc->pool = wc_pool;
  wc->ctx = ctx;

  SVN_ERR(svn_client_open_ra_session2(&wc->ra_session, anchor_url,
                                      NULL /* wri_abspath */, ctx,
                                      wc_pool, scratch_pool));

  SVN_ERR(svn_ra_get_repos_root2(wc->ra_session, &wc->repos_root_url,
                                 result_pool));
  SVN_ERR(svn_ra_get_latest_revnum(wc->ra_session, &wc->head_revision,
                                   scratch_pool));
  SVN_ERR(svn_ra_reparent(wc->ra_session, wc->repos_root_url, scratch_pool));

  SVN_ERR(wc_checkout(wc, base_revision, base_branch_id, scratch_pool));
  *wc_p = wc;
  return SVN_NO_ERROR;
}

svn_error_t *
svnmover_element_differences(apr_hash_t **diff_p,
                             const svn_element__tree_t *left,
                             const svn_element__tree_t *right,
                             apr_hash_t *elements,
                             apr_pool_t *result_pool,
                             apr_pool_t *scratch_pool)
{
  apr_hash_t *diff = apr_hash_make(result_pool);
  apr_hash_index_t *hi;

  if (! left)
    left = svn_element__tree_create(NULL, 0 /*root_eid*/, scratch_pool);
  if (! right)
    right = svn_element__tree_create(NULL, 0 /*root_eid*/, scratch_pool);

  /*SVN_DBG(("element_differences(b%s r%ld, b%s r%ld, e%d)",
           svn_branch__get_id(left->branch, scratch_pool), left->rev,
           svn_branch__get_id(right->branch, scratch_pool), right->rev,
           right->eid));*/

  if (!elements)
    elements = hash_overlay(left->e_map, right->e_map);

  for (hi = apr_hash_first(scratch_pool, elements);
       hi; hi = apr_hash_next(hi))
    {
      int e = svn_eid__hash_this_key(hi);
      svn_element__content_t *element_left
        = svn_element__tree_get(left, e);
      svn_element__content_t *element_right
        = svn_element__tree_get(right, e);

      if (! svn_element__content_equal(element_left, element_right,
                                       scratch_pool))
        {
          svn_element__content_t **contents
            = apr_palloc(result_pool, 2 * sizeof(void *));

          contents[0] = element_left;
          contents[1] = element_right;
          svn_eid__hash_set(diff, e, contents);
        }
    }

  *diff_p = diff;
  return SVN_NO_ERROR;
}

/*  */
static const char *
rev_bid_str(const svn_branch__rev_bid_t *rev_bid,
            apr_pool_t *result_pool)
{
  if (!rev_bid)
    return "<nil>";
  return apr_psprintf(result_pool, "r%ld.%s", rev_bid->rev, rev_bid->bid);
}

/*  */
static const char *
list_parents(svn_branch__history_t *history,
             apr_pool_t *result_pool)
{
  const char *result = "";
  apr_hash_index_t *hi;

  for (hi = apr_hash_first(result_pool, history->parents);
       hi; hi = apr_hash_next(hi))
    {
      svn_branch__rev_bid_t *parent = apr_hash_this_val(hi);
      const char *parent_str = rev_bid_str(parent, result_pool);

      result = apr_psprintf(result_pool, "%s%s%s",
                            result, result[0] ? ", " : "", parent_str);
    }
  return result;
}

/* Return a string representation of HISTORY.
 */
static const char *
history_str(svn_branch__history_t *history,
            apr_pool_t *result_pool)
{
  const char *result
    = list_parents(history, result_pool);

  return apr_psprintf(result_pool, "parents={%s}", result);
}

/*
 */
static svn_error_t *
svn_branch__history_add_parent(svn_branch__history_t *history,
                               svn_revnum_t rev,
                               const char *branch_id,
                               apr_pool_t *scratch_pool)
{
  apr_pool_t *pool = apr_hash_pool_get(history->parents);
  svn_branch__rev_bid_t *new_parent;

  new_parent = svn_branch__rev_bid_create(rev, branch_id, pool);
  svn_hash_sets(history->parents, apr_pstrdup(pool, branch_id), new_parent);
  return SVN_NO_ERROR;
}

/* Set *DIFFERENCE_P to some sort of indication of the difference between
 * HISTORY1 and HISTORY2, or to null if there is no difference.
 *
 * Inputs may be null.
 */
static svn_error_t *
history_diff(const char **difference_p,
             svn_branch__history_t *history1,
             svn_branch__history_t *history2,
             apr_pool_t *result_pool,
             apr_pool_t *scratch_pool)
{
  apr_hash_t *combined;
  apr_hash_index_t *hi;
  svn_boolean_t different = FALSE;

  if (! history1)
    history1 = svn_branch__history_create_empty(scratch_pool);
  if (! history2)
    history2 = svn_branch__history_create_empty(scratch_pool);
  combined = hash_overlay(history1->parents,
                          history2->parents);

  for (hi = apr_hash_first(scratch_pool, combined);
       hi; hi = apr_hash_next(hi))
    {
      const char *bid = apr_hash_this_key(hi);
      svn_branch__rev_bid_t *parent1 = svn_hash_gets(history1->parents, bid);
      svn_branch__rev_bid_t *parent2 = svn_hash_gets(history2->parents, bid);

      if (!(parent1 && parent2
            && svn_branch__rev_bid_equal(parent1, parent2)))
        {
          different = TRUE;
          break;
        }
    }
  if (different)
    {
      *difference_p = apr_psprintf(result_pool, "%s -> %s",
                                   history_str(history1, scratch_pool),
                                   history_str(history2, scratch_pool));
    }
  else
    {
      *difference_p = NULL;
    }
  return SVN_NO_ERROR;
}

/* Set *IS_CHANGED to true if EDIT_TXN differs from its base txn, else to
 * false.
 *
 * Notice only a difference in content: branches deleted or added, or branch
 * contents different. Ignore any differences in branch history metadata.
 *
 * ### At least we must ignore the "this branch" parent changing from
 *     old-revision to new-revision. However we should probably notice
 *     if a merge parent is added (which means we want to make a commit
 *     recording this merge, even if no content changed), and perhaps
 *     other cases.
 */
static svn_error_t *
txn_is_changed(svn_branch__txn_t *edit_txn,
               svn_boolean_t *is_changed,
               apr_pool_t *scratch_pool)
{
  int i;
  svn_branch__txn_t *base_txn
    = svn_branch__repos_get_base_revision_root(edit_txn);
  apr_array_header_t *edit_branches
    = svn_branch__txn_get_branches(edit_txn, scratch_pool);
  apr_array_header_t *base_branches
    = svn_branch__txn_get_branches(base_txn, scratch_pool);

  *is_changed = FALSE;

  /* If any previous branch is now missing, that's a change. */
  for (i = 0; i < base_branches->nelts; i++)
    {
      svn_branch__state_t *base_branch = APR_ARRAY_IDX(base_branches, i, void *);
      svn_branch__state_t *edit_branch
        = svn_branch__txn_get_branch_by_id(edit_txn, base_branch->bid,
                                           scratch_pool);

      if (! edit_branch)
        {
          *is_changed = TRUE;
          return SVN_NO_ERROR;
        }
    }

  /* If any current branch is new or changed, that's a change. */
  for (i = 0; i < edit_branches->nelts; i++)
    {
      svn_branch__state_t *edit_branch = APR_ARRAY_IDX(edit_branches, i, void *);
      svn_branch__state_t *base_branch
        = svn_branch__txn_get_branch_by_id(base_txn, edit_branch->bid,
                                           scratch_pool);
      svn_element__tree_t *edit_branch_elements, *base_branch_elements;
      apr_hash_t *diff;

      if (! base_branch)
        {
          *is_changed = TRUE;
          return SVN_NO_ERROR;
        }

#if 0
      /* Compare histories */
      /* ### No, don't. Ignore any differences in branch history metadata. */
      {
      svn_branch__history_t *edit_branch_history;
      svn_branch__history_t *base_branch_history;
      const char *history_difference;

      SVN_ERR(svn_branch__state_get_history(edit_branch, &edit_branch_history,
                                            scratch_pool));
      SVN_ERR(svn_branch__state_get_history(base_branch, &base_branch_history,
                                            scratch_pool));
      SVN_ERR(history_diff(&history_difference,
                           edit_branch_history,
                           base_branch_history,
                           scratch_pool, scratch_pool));
      if (history_difference)
        {
          *is_changed = TRUE;
          return SVN_NO_ERROR;
        }
      }
#endif

      /* Compare elements */
      SVN_ERR(svn_branch__state_get_elements(edit_branch, &edit_branch_elements,
                                             scratch_pool));
      SVN_ERR(svn_branch__state_get_elements(base_branch, &base_branch_elements,
                                             scratch_pool));
      SVN_ERR(svnmover_element_differences(&diff,
                                           edit_branch_elements,
                                           base_branch_elements,
                                           NULL /*all elements*/,
                                           scratch_pool, scratch_pool));
      if (apr_hash_count(diff))
        {
          *is_changed = TRUE;
          return SVN_NO_ERROR;
        }
    }

  return SVN_NO_ERROR;
}

/* Replay the whole-element changes between LEFT_BRANCH and RIGHT_BRANCH
 * into EDIT_BRANCH.
 *
 * Replaying means, for each element E that is changed (added, modified
 * or deleted) between left and right branches, we set element E in
 * EDIT_BRANCH to whole value of E in RIGHT_BRANCH. This is not like
 * merging: each change resets an element's whole value.
 *
 * ELEMENTS_TO_DIFF (eid -> [anything]) says which elements to diff; if
 * null, diff all elements in the union of left & right branches.
 *
 * LEFT_BRANCH and/or RIGHT_BRANCH may be null which means the equivalent
 * of an empty branch.
 *
 * Non-recursive: single branch only.
 */
static svn_error_t *
branch_elements_replay(svn_branch__state_t *edit_branch,
                       const svn_branch__state_t *left_branch,
                       const svn_branch__state_t *right_branch,
                       apr_hash_t *elements_to_diff,
                       apr_pool_t *scratch_pool)
{
  svn_element__tree_t *s_left = NULL, *s_right = NULL;
  apr_hash_t *diff_left_right;
  apr_hash_index_t *hi;

  if (left_branch)
    SVN_ERR(svn_branch__state_get_elements(left_branch, &s_left,
                                           scratch_pool));
  if (right_branch)
    SVN_ERR(svn_branch__state_get_elements(right_branch, &s_right,
                                           scratch_pool));
  SVN_ERR(svnmover_element_differences(&diff_left_right,
                                       s_left, s_right,
                                       elements_to_diff,
                                       scratch_pool, scratch_pool));

  /* Go through the per-element differences. */
  for (hi = apr_hash_first(scratch_pool, diff_left_right);
       hi; hi = apr_hash_next(hi))
    {
      int eid = svn_eid__hash_this_key(hi);
      svn_element__content_t **e_pair = apr_hash_this_val(hi);
      svn_element__content_t *e0 = e_pair[0], *e1 = e_pair[1];

      SVN_ERR_ASSERT(!e0
                     || svn_element__payload_invariants(e0->payload));
      SVN_ERR_ASSERT(!e1
                     || svn_element__payload_invariants(e1->payload));
      SVN_ERR(svn_branch__state_set_element(edit_branch, eid,
                                            e1, scratch_pool));
    }

  return SVN_NO_ERROR;
}

/*  */
static svn_error_t *
get_union_of_subbranches(apr_hash_t **all_subbranches_p,
                         svn_branch__state_t *left_branch,
                         svn_branch__state_t *right_branch,
                         apr_pool_t *result_pool)
{
  apr_hash_t *all_subbranches;
  svn_branch__subtree_t *s_left = NULL;
  svn_branch__subtree_t *s_right = NULL;

  if (left_branch)
    SVN_ERR(svn_branch__get_subtree(left_branch, &s_left,
                                    svn_branch__root_eid(left_branch),
                                    result_pool));
  if (right_branch)
    SVN_ERR(svn_branch__get_subtree(right_branch, &s_right,
                                    svn_branch__root_eid(right_branch),
                                    result_pool));
  all_subbranches
    = (s_left && s_right) ? hash_overlay(s_left->subbranches,
                                         s_right->subbranches)
        : s_left ? s_left->subbranches
        : s_right ? s_right->subbranches
        : apr_hash_make(result_pool);

  *all_subbranches_p = all_subbranches;
  return SVN_NO_ERROR;
}

/* Replay differences between S_LEFT and S_RIGHT into EDITOR:EDIT_BRANCH.
 *
 * S_LEFT or S_RIGHT (but not both) may be null meaning an empty set.
 *
 * Recurse into subbranches.
 */
static svn_error_t *
svn_branch__replay(svn_branch__txn_t *edit_txn,
                   svn_branch__state_t *edit_branch,
                   svn_branch__state_t *left_branch,
                   svn_branch__state_t *right_branch,
                   apr_pool_t *scratch_pool)
{
  assert((left_branch && right_branch)
         ? (svn_branch__root_eid(left_branch) == svn_branch__root_eid(right_branch))
         : (left_branch || right_branch));

  if (right_branch)
    {
      /* Replay this branch */
      apr_hash_t *elements_to_diff = NULL;  /*means the union of left & right*/

      SVN_ERR(branch_elements_replay(edit_branch, left_branch, right_branch,
                                     elements_to_diff, scratch_pool));
    }
  else
    {
      /* deleted branch LEFT */
      /* nothing to do -- it will go away because we deleted the outer-branch
         element where it was attached */
    }

  /* Replay any change in history */
  /* ### Actually, here we just set the output history to the right-hand-side
     history if that differs from left-hand-side.
     This doesn't seem right, in general. It's OK if we're just copying
     a txn into a fresh txn, as for example we do during commit. */
  {
    svn_branch__history_t *left_history = NULL;
    svn_branch__history_t *right_history = NULL;
    const char *history_difference;

    if (left_branch)
      SVN_ERR(svn_branch__state_get_history(left_branch, &left_history,
                                            scratch_pool));
    if (right_branch)
      SVN_ERR(svn_branch__state_get_history(right_branch, &right_history,
                                            scratch_pool));
    SVN_ERR(history_diff(&history_difference, left_history, right_history,
                         scratch_pool, scratch_pool));
    if (history_difference)
      {
        SVN_ERR(svn_branch__state_set_history(edit_branch, right_history,
                                              scratch_pool));
      }
  }

  /* Replay its subbranches, recursively.
     (If we're deleting the current branch, we don't also need to
     explicitly delete its subbranches... do we?) */
  if (right_branch)
    {
      apr_hash_t *all_subbranches;
      apr_hash_index_t *hi;

      SVN_ERR(get_union_of_subbranches(&all_subbranches,
                                       left_branch, right_branch, scratch_pool));
      for (hi = apr_hash_first(scratch_pool, all_subbranches);
           hi; hi = apr_hash_next(hi))
        {
          int this_eid = svn_eid__hash_this_key(hi);
          svn_branch__state_t *left_subbranch = NULL;
          svn_branch__state_t *right_subbranch = NULL;
          svn_branch__state_t *edit_subbranch = NULL;

          if (left_branch)
            SVN_ERR(svn_branch__get_subbranch_at_eid(
                      left_branch, &left_subbranch, this_eid, scratch_pool));
          if (right_branch)
            SVN_ERR(svn_branch__get_subbranch_at_eid(
                      right_branch, &right_subbranch, this_eid, scratch_pool));
          /* If the subbranch is to be edited or added, first look up the
             corresponding edit subbranch, or, if not found, create one. */
          if (right_subbranch)
            {
              const char *new_branch_id
                = svn_branch__id_nest(edit_branch->bid, this_eid, scratch_pool);

              SVN_ERR(svn_branch__txn_open_branch(edit_txn, &edit_subbranch,
                                                  new_branch_id,
                                                  svn_branch__root_eid(right_subbranch),
                                                  NULL /*tree_ref*/,
                                                  scratch_pool, scratch_pool));
            }

          /* recurse */
          if (edit_subbranch)
            {
              SVN_ERR(svn_branch__replay(edit_txn, edit_subbranch,
                                        left_subbranch, right_subbranch,
                                        scratch_pool));
            }
        }
    }

  return SVN_NO_ERROR;
}

/* Replay differences between LEFT_BRANCH and RIGHT_BRANCH into
 * EDIT_ROOT_BRANCH.
 * (Recurse into subbranches.)
 */
static svn_error_t *
replay(svn_branch__txn_t *edit_txn,
       svn_branch__state_t *edit_root_branch,
       svn_branch__state_t *left_branch,
       svn_branch__state_t *right_branch,
       apr_pool_t *scratch_pool)
{
  SVN_ERR_ASSERT(left_branch || right_branch);

  SVN_ERR(svn_branch__replay(edit_txn, edit_root_branch,
                            left_branch, right_branch, scratch_pool));
  return SVN_NO_ERROR;
}

static svn_error_t *
commit_callback(const svn_commit_info_t *commit_info,
                void *baton,
                apr_pool_t *pool);

/* Baton for commit_callback(). */
typedef struct commit_callback_baton_t
{
  svn_branch__txn_t *edit_txn;
  const char *wc_base_branch_id;
  const char *wc_commit_branch_id;

  /* just-committed revision */
  svn_revnum_t revision;
} commit_callback_baton_t;

static svn_error_t *
display_diff_of_commit(const commit_callback_baton_t *ccbb,
                       apr_pool_t *scratch_pool);

static svn_error_t *
do_topbranch(svn_branch__state_t **new_branch_p,
             svn_branch__txn_t *txn,
             svn_branch__rev_bid_eid_t *from,
             apr_pool_t *result_pool,
             apr_pool_t *scratch_pool);

/* Allocate the same number of new EIDs in NEW_TXN as are already
 * allocated in OLD_TXN.
 */
static svn_error_t *
allocate_eids(svn_branch__txn_t *new_txn,
              const svn_branch__txn_t *old_txn,
              apr_pool_t *scratch_pool)
{
  int num_new_eids;
  int i;

  SVN_ERR(svn_branch__txn_get_num_new_eids(old_txn, &num_new_eids,
                                           scratch_pool));
  for (i = 0; i < num_new_eids; i++)
    {
      SVN_ERR(svn_branch__txn_new_eid(new_txn, NULL, scratch_pool));
    }

  return SVN_NO_ERROR;
}

/* Update the EIDs, given that a commit has translated all new EIDs
 * (negative numbers) to regular EIDs (positive numbers).
 *
 * ### TODO: This will need to take and use a new-EID-translation rule
 *     that must be returned by the commit, as we must not guess (as we
 *     presently do) what translation the server performed. This guess
 *     will fail once the server does rebasing on commit.
 */
static svn_error_t *
update_wc_eids(svnmover_wc_t *wc,
               apr_pool_t *scratch_pool)
{
  SVN_ERR(allocate_eids(wc->base->branch->txn, wc->working->branch->txn,
                        scratch_pool));
  SVN_ERR(svn_branch__txn_finalize_eids(wc->base->branch->txn, scratch_pool));
  SVN_ERR(svn_branch__txn_finalize_eids(wc->working->branch->txn, scratch_pool));
  return SVN_NO_ERROR;
}

/* Update the WC base value of each committed element to match the
 * corresponding WC working element value.
 * Update the WC base revision for each committed element to NEW_REV.
 *
 * The committed elements are determined by diffing base against working.
 * ### TODO: When we allow committing a subset of the WC, we'll need to
 *     pass in a list of the committed elements.
 *
 * BASE_BRANCH and/or WORK_BRANCH may be null.
 */
static svn_error_t *
update_wc_base_r(svnmover_wc_t *wc,
                 svn_branch__state_t *base_branch,
                 svn_branch__state_t *work_branch,
                 svn_revnum_t new_rev,
                 apr_pool_t *scratch_pool)
{
  svn_element__tree_t *base_elements = NULL, *working_elements = NULL;
  apr_hash_t *committed_elements;
  apr_hash_index_t *hi;

  if (base_branch)
    SVN_ERR(svn_branch__state_get_elements(base_branch, &base_elements,
                                           scratch_pool));
  if (work_branch)
    SVN_ERR(svn_branch__state_get_elements(work_branch, &working_elements,
                                           scratch_pool));
  SVN_ERR(svnmover_element_differences(&committed_elements,
                                       base_elements, working_elements,
                                       NULL /*all elements*/,
                                       scratch_pool, scratch_pool));

  for (hi = apr_hash_first(scratch_pool, committed_elements);
       hi; hi = apr_hash_next(hi))
    {
      int eid = svn_eid__hash_this_key(hi);
      svn_element__content_t *content = NULL;

      if (work_branch)
        SVN_ERR(svn_branch__state_get_element(work_branch, &content,
                                              eid, scratch_pool));
      SVN_ERR(svn_branch__state_set_element(base_branch, eid,
                                            content, scratch_pool));
      svnmover_wc_set_base_rev(wc, base_branch, eid, new_rev);

      /* recurse into nested branches that exist in working */
      if (content && content->payload->is_subbranch_root)
        {
          svn_branch__state_t *base_subbranch = NULL;
          svn_branch__state_t *work_subbranch = NULL;

          if (base_branch)
            {
              base_subbranch
                = svn_branch__txn_get_branch_by_id(
                    base_branch->txn,
                    svn_branch__id_nest(base_branch->bid, eid, scratch_pool),
                    scratch_pool);
            }
          if (work_branch)
            {
              work_subbranch
                = svn_branch__txn_get_branch_by_id(
                    work_branch->txn,
                    svn_branch__id_nest(work_branch->bid, eid, scratch_pool),
                    scratch_pool);
            }
          if (work_subbranch && !base_subbranch)
            {
              const char *new_branch_id
                = svn_branch__id_nest(base_branch->bid, eid, scratch_pool);
              svn_branch__history_t *history;

              SVN_ERR(svn_branch__txn_open_branch(base_branch->txn,
                                                  &base_subbranch,
                                                  new_branch_id,
                                                  svn_branch__root_eid(work_subbranch),
                                                  NULL /*tree_ref*/,
                                                  scratch_pool, scratch_pool));
              SVN_ERR(svn_branch__state_get_history(
                        work_subbranch, &history, scratch_pool));
              SVN_ERR(svn_branch__state_set_history(
                        base_subbranch, history, scratch_pool));
            }
          SVN_ERR(update_wc_base_r(wc, base_subbranch, work_subbranch,
                                   new_rev, scratch_pool));
        }
    }

  return SVN_NO_ERROR;
}

/* Update the WC base value of each committed element to match the
 * corresponding WC working element value.
 * Update the WC base revision for each committed element to NEW_REV.
 *
 * The committed elements are determined by diffing base against working.
 * ### TODO: When we allow committing a subset of the WC, we'll need to
 *     pass in a list of the committed elements.
 *
 * ### This should be equivalent to 'replay(base, base, working)'. Use that
 *     instead.
 */
static svn_error_t *
update_wc_base(svnmover_wc_t *wc,
               svn_revnum_t new_rev,
               apr_pool_t *scratch_pool)
{
  svn_branch__state_t *base_branch = wc->base->branch;
  svn_branch__state_t *work_branch = wc->working->branch;
  SVN_ERR(update_wc_base_r(wc, base_branch, work_branch,
                           new_rev, scratch_pool));
  return SVN_NO_ERROR;
}

/* Commit the changes from WC into the repository.
 *
 * Open a new commit txn to the repo. Replay the changes from WC into it.
 * Update the WC base for the committed elements.
 *
 * Set WC->head_revision and *NEW_REV_P to the committed revision number.
 *
 * If there are no changes to commit, set *NEW_REV_P to SVN_INVALID_REVNUM
 * and do not make a commit and do not change WC->head_revision.
 *
 * NEW_REV_P may be null if not wanted.
 */
static svn_error_t *
wc_commit(svn_revnum_t *new_rev_p,
          svnmover_wc_t *wc,
          apr_hash_t *revprops,
          apr_pool_t *scratch_pool)
{
  const char *branch_info_dir = NULL;
  svn_branch__txn_t *commit_txn;
  commit_callback_baton_t ccbb;
  svn_boolean_t change_detected;
  const char *edit_root_branch_id;
  svn_branch__state_t *edit_root_branch;

  SVN_ERR(txn_is_changed(wc->working->branch->txn, &change_detected,
                         scratch_pool));
  if (! change_detected)
    {
      wc->list_of_commands = NULL;
      if (new_rev_p)
        *new_rev_p = SVN_INVALID_REVNUM;
      return SVN_NO_ERROR;
    }

  /* If no log msg provided, use the list of commands */
  if (! svn_hash_gets(revprops, SVN_PROP_REVISION_LOG) && wc->list_of_commands)
    {
      /* Avoid modifying the passed-in revprops hash */
      revprops = apr_hash_copy(scratch_pool, revprops);

      svn_hash_sets(revprops, SVN_PROP_REVISION_LOG,
                    svn_string_create(wc->list_of_commands, scratch_pool));
    }

  /* Choose whether to store branching info in a local dir or in revprops.
     (For now, just to exercise the options, we choose local files for
     RA-local and revprops for a remote repo.) */
  if (strncmp(wc->repos_root_url, "file://", 7) == 0)
    {
      const char *repos_dir;

      SVN_ERR(svn_uri_get_dirent_from_file_url(&repos_dir, wc->repos_root_url,
                                               scratch_pool));
      branch_info_dir = svn_dirent_join(repos_dir, "branch-info", scratch_pool);
    }

  /* Start a new editor for the commit. */
  SVN_ERR(svn_ra_get_commit_txn(wc->ra_session,
                                &commit_txn,
                                revprops,
                                commit_callback, &ccbb,
                                NULL /*lock_tokens*/, FALSE /*keep_locks*/,
                                branch_info_dir,
                                scratch_pool));
  /*SVN_ERR(svn_branch__txn_get_debug(&wc->edit_txn, wc->edit_txn, scratch_pool));*/

  edit_root_branch_id = wc->working->branch->bid;
  edit_root_branch = svn_branch__txn_get_branch_by_id(
                       commit_txn, wc->working->branch->bid, scratch_pool);

  /* We might be creating a new top-level branch in this commit. That is the
     only case in which the working branch will not be found in EDIT_TXN.
     (Creating any other branch can only be done inside a checkout of a
     parent branch.) So, maybe create a new top-level branch. */
  if (! edit_root_branch)
    {
      /* Create a new top-level branch in the edited state. (It will have
         an independent new top-level branch number.) */
      svn_branch__rev_bid_eid_t *from
        = svn_branch__rev_bid_eid_create(wc->base->revision,
                                         wc->base->branch->bid,
                                         svn_branch__root_eid(wc->base->branch),
                                         scratch_pool);

      SVN_ERR(do_topbranch(&edit_root_branch, commit_txn,
                           from, scratch_pool, scratch_pool));
      edit_root_branch_id = edit_root_branch->bid;
    }
  /* Allocate all the new eids we'll need in this new txn */
  SVN_ERR(allocate_eids(commit_txn, wc->working->branch->txn, scratch_pool));
  SVN_ERR(replay(commit_txn, edit_root_branch,
                 wc->base->branch,
                 wc->working->branch,
                 scratch_pool));

  ccbb.edit_txn = commit_txn;
  ccbb.wc_base_branch_id = wc->base->branch->bid;
  ccbb.wc_commit_branch_id = edit_root_branch_id;

  SVN_ERR(svn_branch__txn_complete(commit_txn, scratch_pool));
  SVN_ERR(update_wc_eids(wc, scratch_pool));
  SVN_ERR(update_wc_base(wc, ccbb.revision, scratch_pool));
  SVN_ERR(display_diff_of_commit(&ccbb, scratch_pool));

  wc->head_revision = ccbb.revision;
  if (new_rev_p)
    *new_rev_p = ccbb.revision;

  wc->list_of_commands = NULL;

  return SVN_NO_ERROR;
}

typedef enum action_code_t {
  ACTION_INFO_WC,
  ACTION_INFO,
  ACTION_LIST_CONFLICTS,
  ACTION_RESOLVED_CONFLICT,
  ACTION_DIFF,
  ACTION_LOG,
  ACTION_LIST_BRANCHES,
  ACTION_LIST_BRANCHES_R,
  ACTION_LS,
  ACTION_TBRANCH,
  ACTION_BRANCH,
  ACTION_BRANCH_INTO,
  ACTION_MKBRANCH,
  ACTION_MERGE3,
  ACTION_AUTO_MERGE,
  ACTION_MV,
  ACTION_MKDIR,
  ACTION_PUT_FILE,
  ACTION_CAT,
  ACTION_CP,
  ACTION_RM,
  ACTION_CP_RM,
  ACTION_BR_RM,
  ACTION_BR_INTO_RM,
  ACTION_COMMIT,
  ACTION_UPDATE,
  ACTION_SWITCH,
  ACTION_STATUS,
  ACTION_REVERT,
  ACTION_MIGRATE
} action_code_t;

typedef struct action_defn_t {
  enum action_code_t code;
  const char *name;
  int num_args;
  const char *args_help;
  const char *help;
} action_defn_t;

#define NL "\n                           "
static const action_defn_t action_defn[] =
{
  {ACTION_INFO_WC,          "info-wc", 0, "",
    "print information about the WC"},
  {ACTION_INFO,             "info", 1, "PATH",
    "show info about the element at PATH"},
  {ACTION_LIST_CONFLICTS,   "conflicts", 0, "",
    "list unresolved conflicts"},
  {ACTION_RESOLVED_CONFLICT,"resolved", 1, "CONFLICT_ID",
    "mark conflict as resolved"},
  {ACTION_LIST_BRANCHES,    "branches", 1, "PATH",
    "list all branches rooted at the same element as PATH"},
  {ACTION_LIST_BRANCHES_R,  "ls-br-r", 0, "",
    "list all branches, recursively"},
  {ACTION_LS,               "ls", 1, "PATH",
    "list elements in the branch found at PATH"},
  {ACTION_LOG,              "log", 2, "FROM@REV TO@REV",
    "show per-revision diffs between FROM and TO"},
  {ACTION_TBRANCH,          "tbranch", 1, "SRC",
    "branch the branch-root or branch-subtree at SRC" NL
    "to make a new top-level branch"},
  {ACTION_BRANCH,           "branch", 2, "SRC DST",
    "branch the branch-root or branch-subtree at SRC" NL
    "to make a new branch at DST"},
  {ACTION_BRANCH_INTO,      "branch-into", 2, "SRC DST",
    "make a branch of the existing subtree SRC appear at" NL
    "DST as part of the existing branch that contains DST" NL
    "(like merging the creation of SRC to DST)"},
  {ACTION_MKBRANCH,         "mkbranch", 1, "ROOT",
    "make a directory that's the root of a new subbranch"},
  {ACTION_DIFF,             "diff", 2, "LEFT@REV RIGHT@REV",
    "show differences from subtree LEFT to subtree RIGHT"},
  {ACTION_MERGE3,           "merge", 3, "FROM TO YCA@REV",
    "3-way merge YCA->FROM into TO"},
  {ACTION_AUTO_MERGE,       "automerge", 2, "FROM TO",
    "automatic merge FROM into TO"},
  {ACTION_CP,               "cp", 2, "REV SRC DST",
    "copy SRC@REV to DST"},
  {ACTION_MV,               "mv", 2, "SRC DST",
    "move SRC to DST"},
  {ACTION_RM,               "rm", 1, "PATH",
    "delete PATH"},
  {ACTION_CP_RM,            "copy-and-delete", 2, "SRC DST",
    "copy-and-delete SRC to DST"},
  {ACTION_BR_RM,            "branch-and-delete", 2, "SRC DST",
    "branch-and-delete SRC to DST"},
  {ACTION_BR_INTO_RM,       "branch-into-and-delete", 2, "SRC DST",
    "merge-and-delete SRC to DST"},
  {ACTION_MKDIR,            "mkdir", 1, "PATH",
    "create new directory PATH"},
  {ACTION_PUT_FILE,         "put", 2, "LOCAL_FILE PATH",
    "add or modify file PATH with text copied from" NL
    "LOCAL_FILE (use \"-\" to read from standard input)"},
  {ACTION_CAT,              "cat", 1, "PATH",
    "display text (for a file) and props (if any) of PATH"},
  {ACTION_COMMIT,           "commit", 0, "",
    "commit the changes"},
  {ACTION_UPDATE,           "update", 1, ".@REV",
    "update to revision REV, keeping local changes"},
  {ACTION_SWITCH,           "switch", 1, "TARGET[@REV]",
    "switch to another branch and/or revision, keeping local changes"},
  {ACTION_STATUS,           "status", 0, "",
    "same as 'diff .@base .'"},
  {ACTION_REVERT,           "revert", 0, "",
    "revert all uncommitted changes"},
  {ACTION_MIGRATE,          "migrate", 1, ".@REV",
    "migrate changes from non-move-tracking revision"},
};

typedef struct action_t {
  /* The original command words (const char *) by which the action was
     specified */
  apr_array_header_t *action_args;

  action_code_t action;

  /* argument revisions */
  svn_opt_revision_t rev_spec[3];

  const char *branch_id[3];

  /* argument paths */
  const char *relpath[3];
} action_t;

/* ====================================================================== */

/* Find the deepest branch in the repository of which REVNUM:BRANCH_ID:RELPATH
 * is either the root element or a normal, non-sub-branch element.
 *
 * RELPATH is a repository-relative path. REVNUM is a revision number, or
 * SVN_INVALID_REVNUM meaning the current txn.
 *
 * Return the location of the element in that branch, or with
 * EID=-1 if no element exists there.
 *
 * If BRANCH_ID is null, the default is the WC base branch when REVNUM is
 * specified, and the WC working branch when REVNUM is SVN_INVALID_REVNUM.
 *
 * Return an error if branch BRANCH_ID does not exist in r<REVNUM>; otherwise,
 * the result will never be NULL, as every path is within at least the root
 * branch.
 */
static svn_error_t *
find_el_rev_by_rrpath_rev(svn_branch__el_rev_id_t **el_rev_p,
                          svnmover_wc_t *wc,
                          const svn_opt_revision_t *rev_spec,
                          const char *branch_id,
                          const char *relpath,
                          apr_pool_t *result_pool,
                          apr_pool_t *scratch_pool)
{
  if (rev_spec->kind == svn_opt_revision_number
      || rev_spec->kind == svn_opt_revision_head)
    {
      svn_revnum_t revnum
        = (rev_spec->kind == svn_opt_revision_number)
           ? rev_spec->value.number : wc->head_revision;
      const svn_branch__repos_t *repos = wc->working->branch->txn->repos;

      if (! branch_id)
        branch_id = wc->base->branch->bid;
      SVN_ERR(svn_branch__repos_find_el_rev_by_path_rev(el_rev_p, repos,
                                                        revnum,
                                                        branch_id,
                                                        relpath,
                                                        result_pool,
                                                        scratch_pool));
    }
  else if (rev_spec->kind == svn_opt_revision_unspecified
           || rev_spec->kind == svn_opt_revision_working
           || rev_spec->kind == svn_opt_revision_base
           || rev_spec->kind == svn_opt_revision_committed)
    {
      svn_branch__state_t *branch
        = branch_id ? svn_branch__txn_get_branch_by_id(
                        wc->working->branch->txn, branch_id, scratch_pool)
                    : wc->working->branch;
      svn_branch__el_rev_id_t *el_rev = apr_palloc(result_pool, sizeof(*el_rev));

      if (! branch)
        return svn_error_createf(SVN_BRANCH__ERR, NULL,
                                 _("Branch %s not found in working state"),
                                 branch_id);
      SVN_ERR(svn_branch__find_nested_branch_element_by_relpath(
        &el_rev->branch, &el_rev->eid,
        branch, relpath, scratch_pool));
      if (rev_spec->kind == svn_opt_revision_unspecified
          || rev_spec->kind == svn_opt_revision_working)
        {
          el_rev->rev = SVN_INVALID_REVNUM;
        }
      else
        {
          el_rev->rev = svnmover_wc_get_base_rev(wc, el_rev->branch,
                                                 el_rev->eid, scratch_pool);
        }
      *el_rev_p = el_rev;
    }
  else
    {
      return svn_error_createf(SVN_ERR_INCORRECT_PARAMS, NULL,
                               "'%s@...': revision specifier "
                               "must be a number or 'head', 'base' "
                               "or 'committed'",
                               relpath);
    }
  SVN_ERR_ASSERT(*el_rev_p);
  return SVN_NO_ERROR;
}

/* Return a string suitable for appending to a displayed element name or
 * element id to indicate that it is a subbranch root element for SUBBRANCH.
 * Return "" if SUBBRANCH is null.
 */
static const char *
branch_str(svn_branch__state_t *subbranch,
           apr_pool_t *result_pool)
{
  if (subbranch)
    return apr_psprintf(result_pool,
                      " (branch %s)",
                      svn_branch__get_id(subbranch, result_pool));
  return "";
}

/* Return a string suitable for appending to a displayed element name or
 * element id to indicate that BRANCH:EID is a subbranch root element.
 * Return "" if the element is not a subbranch root element.
 */
static const char *
subbranch_str(svn_branch__state_t *branch,
              int eid,
              apr_pool_t *result_pool)
{
  svn_branch__state_t *subbranch;

  svn_error_clear(svn_branch__get_subbranch_at_eid(branch, &subbranch,
                                                   eid, result_pool));
  return branch_str(subbranch, result_pool);
}

/*  */
static const char *
subtree_subbranch_str(svn_branch__subtree_t *subtree,
                      const char *bid,
                      int eid,
                      apr_pool_t *result_pool)
{
  svn_branch__subtree_t *subbranch
    = svn_branch__subtree_get_subbranch_at_eid(subtree, eid, result_pool);

  if (subbranch)
    return apr_psprintf(result_pool,
                        " (branch %s)",
                        svn_branch__id_nest(bid, eid, result_pool));
  return "";
}

/*  */
static const char *
el_rev_id_to_path(svn_branch__el_rev_id_t *el_rev,
                  apr_pool_t *result_pool)
{
  const char *path
    = svn_branch__get_rrpath_by_eid(el_rev->branch, el_rev->eid, result_pool);

  return path;
}

/*  */
static const char *
branch_peid_name_to_path(svn_branch__state_t *to_branch,
                         int to_parent_eid,
                         const char *to_name,
                         apr_pool_t *result_pool)
{
  const char *path
    = svn_relpath_join(svn_branch__get_rrpath_by_eid(to_branch, to_parent_eid,
                                                     result_pool),
                       to_name, result_pool);

  return path;
}

/* */
static int
sort_compare_eid_mappings_by_path(const svn_sort__item_t *a,
                                  const svn_sort__item_t *b)
{
  const char *astr = a->value, *bstr = b->value;

  return svn_path_compare_paths(astr, bstr);
}

/* List the elements in BRANCH, in path notation.
 *
 * List only the elements for which a relpath is known -- that is, elements
 * whose parents exist all the way up to the branch root.
 */
static svn_error_t *
list_branch_elements(svn_branch__state_t *branch,
                     apr_pool_t *scratch_pool)
{
  apr_hash_t *eid_to_path = apr_hash_make(scratch_pool);
  svn_element__tree_t *elements;
  apr_hash_index_t *hi;
  svn_eid__hash_iter_t *ei;

  SVN_ERR(svn_branch__state_get_elements(branch, &elements, scratch_pool));
  for (hi = apr_hash_first(scratch_pool, elements->e_map);
       hi; hi = apr_hash_next(hi))
    {
      int eid = svn_eid__hash_this_key(hi);
      const char *relpath = svn_branch__get_path_by_eid(branch, eid,
                                                        scratch_pool);

      svn_eid__hash_set(eid_to_path, eid, relpath);
    }
  for (SVN_EID__HASH_ITER_SORTED(ei, eid_to_path,
                                 sort_compare_eid_mappings_by_path,
                                 scratch_pool))
    {
      int eid = ei->eid;
      const char *relpath = ei->val;

      svnmover_notify("    %-20s%s",
                      relpath[0] ? relpath : ".",
                      subbranch_str(branch, eid, scratch_pool));
    }

  return SVN_NO_ERROR;
}

/*  */
static int
sort_compare_items_by_eid(const svn_sort__item_t *a,
                          const svn_sort__item_t *b)
{
  int eid_a = *(const int *)a->key;
  int eid_b = *(const int *)b->key;

  return eid_a - eid_b;
}

static const char *
peid_name(const svn_element__content_t *element,
          apr_pool_t *scratch_pool)
{
  if (element->parent_eid == -1)
    return apr_psprintf(scratch_pool, "%3s %-10s", "", ".");

  return apr_psprintf(scratch_pool, "%3d/%-10s",
                      element->parent_eid, element->name);
}

static const char elements_by_eid_header[]
  = "    eid  parent-eid/name\n"
    "    ---  ----------/----";

/* List all elements in branch BRANCH, in element notation.
 */
static svn_error_t *
list_branch_elements_by_eid(svn_branch__state_t *branch,
                            apr_pool_t *scratch_pool)
{
  svn_element__tree_t *elements;
  svn_eid__hash_iter_t *ei;

  svnmover_notify_v("%s", elements_by_eid_header);
  SVN_ERR(svn_branch__state_get_elements(branch, &elements, scratch_pool));
  for (SVN_EID__HASH_ITER_SORTED_BY_EID(ei, elements->e_map, scratch_pool))
    {
      int eid = ei->eid;
      svn_element__content_t *element = ei->val;

      if (element)
        {
          svnmover_notify("    e%-3d %21s%s",
                          eid,
                          peid_name(element, scratch_pool),
                          subbranch_str(branch, eid, scratch_pool));
        }
    }

  return SVN_NO_ERROR;
}

/*  */
static const char *
branch_id_header_str(const char *prefix,
                     apr_pool_t *result_pool)
{
  if (the_ui_mode == UI_MODE_PATHS)
    {
      return apr_psprintf(result_pool,
                          "%sbranch-id  root-path\n"
                          "%s---------  ---------",
                          prefix, prefix);
    }
  else
    {
      return apr_psprintf(result_pool,
                          "%sbranch-id  branch-name  root-eid\n"
                          "%s---------  -----------  --------",
                          prefix, prefix);
    }
}

/* Show the id and path or root-eid of BRANCH.
 */
static const char *
branch_id_str(svn_branch__state_t *branch,
              apr_pool_t *result_pool)
{
  apr_pool_t *scratch_pool = result_pool;

  if (the_ui_mode == UI_MODE_PATHS)
    {
      return apr_psprintf(result_pool, "%-10s /%s",
                          svn_branch__get_id(branch, scratch_pool),
                          svn_branch__get_root_rrpath(branch, scratch_pool));
    }
  else
    {
      svn_element__content_t *outer_el = NULL;
      svn_branch__state_t *outer_branch;
      int outer_eid;

      svn_branch__get_outer_branch_and_eid(&outer_branch, &outer_eid,
                                           branch, scratch_pool);

      if (outer_branch)
        svn_error_clear(svn_branch__state_get_element(outer_branch, &outer_el,
                                                      outer_eid, scratch_pool));

      return apr_psprintf(result_pool, "%-10s %-12s root=e%d",
                          svn_branch__get_id(branch, scratch_pool),
                          outer_el ? outer_el->name : "/",
                          svn_branch__root_eid(branch));
    }
}

/* List the branch BRANCH.
 *
 * If WITH_ELEMENTS is true, also list the elements in it.
 */
static svn_error_t *
list_branch(svn_branch__state_t *branch,
            svn_boolean_t with_elements,
            apr_pool_t *scratch_pool)
{
  svnmover_notify("  %s", branch_id_str(branch, scratch_pool));

  if (with_elements)
    {
      if (the_ui_mode == UI_MODE_PATHS)
        {
          SVN_ERR(list_branch_elements(branch, scratch_pool));
        }
      else
        {
          SVN_ERR(list_branch_elements_by_eid(branch, scratch_pool));
        }
    }
  return SVN_NO_ERROR;
}

/* List all branches rooted at EID.
 *
 * If WITH_ELEMENTS is true, also list the elements in each branch.
 */
static svn_error_t *
list_branches(svn_branch__txn_t *txn,
              int eid,
              svn_boolean_t with_elements,
              apr_pool_t *scratch_pool)
{
  const apr_array_header_t *branches;
  int i;
  svn_boolean_t printed_header = FALSE;

  svnmover_notify_v("%s", branch_id_header_str("  ", scratch_pool));

  branches = svn_branch__txn_get_branches(txn, scratch_pool);

  for (i = 0; i < branches->nelts; i++)
    {
      svn_branch__state_t *branch = APR_ARRAY_IDX(branches, i, void *);

      if (svn_branch__root_eid(branch) != eid)
        continue;

      SVN_ERR(list_branch(branch, with_elements, scratch_pool));
      if (with_elements) /* separate branches by a blank line */
        svnmover_notify("%s", "");
    }

  for (i = 0; i < branches->nelts; i++)
    {
      svn_branch__state_t *branch = APR_ARRAY_IDX(branches, i, void *);
      svn_element__content_t *element;

      SVN_ERR(svn_branch__state_get_element(branch, &element,
                                            eid, scratch_pool));
      if (! element
          || svn_branch__root_eid(branch) == eid)
        continue;

      if (! printed_header)
        {
          if (the_ui_mode == UI_MODE_PATHS)
            svnmover_notify_v("branches containing but not rooted at that element:");
          else
            svnmover_notify_v("branches containing but not rooted at e%d:", eid);
          printed_header = TRUE;
        }
      SVN_ERR(list_branch(branch, with_elements, scratch_pool));
      if (with_elements) /* separate branches by a blank line */
        svnmover_notify("%s", "");
    }

  return SVN_NO_ERROR;
}

/* List all branches. If WITH_ELEMENTS is true, also list the elements
 * in each branch.
 */
static svn_error_t *
list_all_branches(svn_branch__txn_t *txn,
                  svn_boolean_t with_elements,
                  apr_pool_t *scratch_pool)
{
  const apr_array_header_t *branches;
  int i;

  branches = svn_branch__txn_get_branches(txn, scratch_pool);

  svnmover_notify_v("branches:");

  for (i = 0; i < branches->nelts; i++)
    {
      svn_branch__state_t *branch = APR_ARRAY_IDX(branches, i, void *);

      SVN_ERR(list_branch(branch, with_elements, scratch_pool));
      if (with_elements) /* separate branches by a blank line */
        svnmover_notify("%s", "");
    }

  return SVN_NO_ERROR;
}

/* Switch the WC to revision REVISION (SVN_INVALID_REVNUM means HEAD)
 * and branch TARGET_BRANCH.
 *
 * Merge any changes in the existing txn into the new txn.
 */
static svn_error_t *
do_switch(svnmover_wc_t *wc,
          svn_revnum_t revision,
          svn_branch__state_t *target_branch,
          apr_pool_t *scratch_pool)
{
  const char *target_branch_id
    = svn_branch__get_id(target_branch, scratch_pool);
  /* Keep hold of the previous WC txn */
  svn_branch__state_t *previous_base_br = wc->base->branch;
  svn_branch__state_t *previous_working_br = wc->working->branch;
  svn_boolean_t has_local_changes;

  SVN_ERR(txn_is_changed(previous_working_br->txn,
                         &has_local_changes, scratch_pool));

  /* Usually one would switch the WC to another branch (or just another
     revision) rooted at the same element. Switching to a branch rooted
     at a different element is well defined, but give a warning. */
  if (has_local_changes
      && svn_branch__root_eid(target_branch)
         != svn_branch__root_eid(previous_base_br))
    {
      svnmover_notify(_("Warning: you are switching from %s rooted at e%d "
                        "to %s rooted at e%d, a different root element, "
                        "while there are local changes. "),
             svn_branch__get_id(previous_base_br, scratch_pool),
             svn_branch__root_eid(previous_base_br),
             target_branch_id,
             svn_branch__root_eid(target_branch));
    }

  /* Complete the old edit drive into the 'WC' txn */
  SVN_ERR(svn_branch__txn_sequence_point(wc->edit_txn, scratch_pool));

  /* Check out a new WC, re-using the same data object */
  SVN_ERR(wc_checkout(wc, revision, target_branch_id, scratch_pool));

  if (has_local_changes)
    {
      svn_branch__el_rev_id_t *yca, *src, *tgt;

      /* Merge changes from the old into the new WC */
      yca = svn_branch__el_rev_id_create(previous_base_br,
                                         svn_branch__root_eid(previous_base_br),
                                         previous_base_br->txn->rev,
                                         scratch_pool);
      src = svn_branch__el_rev_id_create(previous_working_br,
                                         svn_branch__root_eid(previous_working_br),
                                         SVN_INVALID_REVNUM, scratch_pool);
      tgt = svn_branch__el_rev_id_create(wc->working->branch,
                                         svn_branch__root_eid(wc->working->branch),
                                         SVN_INVALID_REVNUM, scratch_pool);
      SVN_ERR(svnmover_branch_merge(wc->edit_txn, tgt->branch,
                                    &wc->conflicts,
                                    src, tgt, yca, wc->pool, scratch_pool));

      if (svnmover_any_conflicts(wc->conflicts))
        {
          SVN_ERR(svnmover_display_conflicts(wc->conflicts, scratch_pool));
        }

      /* ### TODO: If the merge raises conflicts, allow the user to revert
             to the pre-update state or resolve the conflicts. Currently
             this leaves the merge partially done and the pre-update state
             is lost. */
    }

  return SVN_NO_ERROR;
}

/*
 */
static svn_error_t *
do_merge(svnmover_wc_t *wc,
         svn_branch__el_rev_id_t *src,
         svn_branch__el_rev_id_t *tgt,
         svn_branch__el_rev_id_t *yca,
         apr_pool_t *scratch_pool)
{
  svn_branch__history_t *history;

  if (src->eid != tgt->eid || src->eid != yca->eid)
    {
      svnmover_notify(_("Warning: root elements differ in the requested merge "
                        "(from: e%d, to: e%d, yca: e%d)"),
                      src->eid, tgt->eid, yca->eid);
    }

  SVN_ERR(svnmover_branch_merge(wc->edit_txn, tgt->branch,
                                &wc->conflicts,
                                src, tgt, yca,
                                wc->pool, scratch_pool));

  /* Update the history */
  SVN_ERR(svn_branch__state_get_history(tgt->branch, &history, scratch_pool));
  /* ### Assume this was a complete merge -- i.e. all changes up to YCA were
     previously merged, so now SRC is a new parent. */
  SVN_ERR(svn_branch__history_add_parent(history, src->rev, src->branch->bid,
                                         scratch_pool));
  SVN_ERR(svn_branch__state_set_history(tgt->branch, history, scratch_pool));
  svnmover_notify_v(_("--- recorded merge parent as: %ld.%s"),
                    src->rev, src->branch->bid);

  if (svnmover_any_conflicts(wc->conflicts))
    {
      SVN_ERR(svnmover_display_conflicts(wc->conflicts, scratch_pool));
    }

  return SVN_NO_ERROR;
}

/*
 */
static svn_error_t *
do_auto_merge(svnmover_wc_t *wc,
              svn_branch__el_rev_id_t *src,
              svn_branch__el_rev_id_t *tgt,
              apr_pool_t *scratch_pool)
{
  svn_branch__rev_bid_t *yca;

  /* Find the Youngest Common Ancestor.
     ### TODO */
  yca = NULL;

  if (yca)
    {
      svn_branch__repos_t *repos = wc->working->branch->txn->repos;
      svn_branch__state_t *yca_branch;
      svn_branch__el_rev_id_t *_yca;

      SVN_ERR(svn_branch__repos_get_branch_by_id(&yca_branch, repos,
                                                 yca->rev, yca->bid,
                                                 scratch_pool));
      _yca = svn_branch__el_rev_id_create(yca_branch,
                                          svn_branch__root_eid(yca_branch),
                                          yca->rev, scratch_pool);

      SVN_ERR(do_merge(wc, src, tgt, _yca, scratch_pool));
    }
  else
    {
      return svn_error_create(SVN_BRANCH__ERR, NULL,
                              _("Cannot perform automatic merge: "
                                "no YCA found"));
    }

  return SVN_NO_ERROR;
}

/* Show the difference in history metadata between BRANCH1 and BRANCH2.
 *
 * If HEADER is non-null, print *HEADER and then set *HEADER to null.
 *
 * BRANCH1 and/or BRANCH2 may be null.
 */
static svn_error_t *
show_history_r(svn_branch__state_t *branch,
               const char *prefix,
               apr_pool_t *scratch_pool)
{
  svn_branch__history_t *history = NULL;
  svn_branch__subtree_t *subtree = NULL;
  apr_hash_index_t *hi;

  if (! branch)
    return SVN_NO_ERROR;

  SVN_ERR(svn_branch__state_get_history(branch, &history, scratch_pool));
  svnmover_notify("%s%s: %s", prefix,
                  branch->bid, history_str(history, scratch_pool));

  /* recurse into each subbranch */
  SVN_ERR(svn_branch__get_subtree(branch, &subtree,
                                  svn_branch__root_eid(branch),
                                  scratch_pool));
   for (hi = apr_hash_first(scratch_pool, subtree->subbranches);
       hi; hi = apr_hash_next(hi))
    {
      int e = svn_eid__hash_this_key(hi);
      svn_branch__state_t *subbranch = NULL;

      SVN_ERR(svn_branch__get_subbranch_at_eid(branch, &subbranch, e,
                                               scratch_pool));
      if (subbranch)
        {
          SVN_ERR(show_history_r(subbranch, prefix, scratch_pool));
        }
    }
  return SVN_NO_ERROR;
}

/*  */
typedef struct diff_item_t
{
  int eid;
  svn_element__content_t *e0, *e1;
  const char *relpath0, *relpath1;
  svn_boolean_t modified, reparented, renamed;
} diff_item_t;

/* Return differences between branch subtrees S_LEFT and S_RIGHT.
 * Diff the union of S_LEFT's and S_RIGHT's elements.
 *
 * Set *DIFF_CHANGES to a hash of (eid -> diff_item_t).
 *
 * ### This requires 'subtrees' only in order to produce the 'relpath'
 *     fields in the output. Other than that, it would work with arbitrary
 *     sets of elements.
 */
static svn_error_t *
subtree_diff(apr_hash_t **diff_changes,
             svn_branch__subtree_t *s_left,
             svn_branch__subtree_t *s_right,
             apr_pool_t *result_pool,
             apr_pool_t *scratch_pool)
{
  apr_hash_t *diff_left_right;
  apr_hash_index_t *hi;

  *diff_changes = apr_hash_make(result_pool);

  SVN_ERR(svnmover_element_differences(&diff_left_right,
                                       s_left->tree, s_right->tree,
                                       NULL /*union of s_left & s_right*/,
                                       result_pool, scratch_pool));

  for (hi = apr_hash_first(scratch_pool, diff_left_right);
       hi; hi = apr_hash_next(hi))
    {
      int eid = svn_eid__hash_this_key(hi);
      svn_element__content_t **e_pair = apr_hash_this_val(hi);
      svn_element__content_t *e0 = e_pair[0], *e1 = e_pair[1];

      if (e0 || e1)
        {
          diff_item_t *item = apr_palloc(result_pool, sizeof(*item));

          item->eid = eid;
          item->e0 = e0;
          item->e1 = e1;
          item->relpath0 = e0 ? svn_element__tree_get_path_by_eid(
                                  s_left->tree, eid, result_pool) : NULL;
          item->relpath1 = e1 ? svn_element__tree_get_path_by_eid(
                                  s_right->tree, eid, result_pool) : NULL;
          item->reparented = (e0 && e1 && e0->parent_eid != e1->parent_eid);
          item->renamed = (e0 && e1 && strcmp(e0->name, e1->name) != 0);

          svn_eid__hash_set(*diff_changes, eid, item);
        }
    }

  return SVN_NO_ERROR;
}

/* Find the relative order of diff items A and B, according to the
 * "major path" of each. The major path means its right-hand relpath, if
 * it exists on the right-hand side of the diff, else its left-hand relpath.
 *
 * Return negative/zero/positive when A sorts before/equal-to/after B.
 */
static int
diff_ordering_major_paths(const struct svn_sort__item_t *a,
                          const struct svn_sort__item_t *b)
{
  const diff_item_t *item_a = a->value, *item_b = b->value;
  int deleted_a = (item_a->e0 && ! item_a->e1);
  int deleted_b = (item_b->e0 && ! item_b->e1);
  const char *major_path_a = (item_a->e1 ? item_a->relpath1 : item_a->relpath0);
  const char *major_path_b = (item_b->e1 ? item_b->relpath1 : item_b->relpath0);

  /* Sort deleted items before all others */
  if (deleted_a != deleted_b)
    return deleted_b - deleted_a;

  /* Sort by path */
  return svn_path_compare_paths(major_path_a, major_path_b);
}

/* Display differences between subtrees LEFT and RIGHT, which are subtrees
 * of branches LEFT_BID and RIGHT_BID respectively.
 *
 * Diff the union of LEFT's and RIGHT's elements.
 *
 * Use EDITOR to fetch content when needed.
 *
 * Write a line containing HEADER before any other output, if it is not
 * null. Write PREFIX at the start of each line of output, including any
 * header line. PREFIX and HEADER should contain no end-of-line characters.
 *
 * The output refers to paths or to elements according to THE_UI_MODE.
 */
static svn_error_t *
show_subtree_diff(svn_branch__subtree_t *left,
                  const char *left_bid,
                  svn_branch__subtree_t *right,
                  const char *right_bid,
                  const char *prefix,
                  const char *header,
                  apr_pool_t *scratch_pool)
{
  apr_hash_t *diff_changes;
  svn_eid__hash_iter_t *ei;

  SVN_ERR_ASSERT(left && left->tree->root_eid != -1
                 && right && right->tree->root_eid != -1);

  SVN_ERR(subtree_diff(&diff_changes, left, right,
                       scratch_pool, scratch_pool));

  if (header && apr_hash_count(diff_changes))
    svnmover_notify("%s%s", prefix, header);

  for (SVN_EID__HASH_ITER_SORTED(ei, diff_changes,
                                 (the_ui_mode == UI_MODE_EIDS)
                                   ? sort_compare_items_by_eid
                                   : diff_ordering_major_paths,
                                 scratch_pool))
    {
      diff_item_t *item = ei->val;
      svn_element__content_t *e0 = item->e0, *e1 = item->e1;
      char status_mod = (e0 && e1) ? 'M' : e0 ? 'D' : 'A';

      /* For a deleted element whose parent was also deleted, mark it is
         less interesting, somehow. (Or we could omit it entirely.) */
      if (status_mod == 'D')
        {
          diff_item_t *parent_item
            = svn_eid__hash_get(diff_changes, e0->parent_eid);

          if (parent_item && ! parent_item->e1)
            status_mod = 'd';
        }

      if (the_ui_mode == UI_MODE_PATHS)
        {
          const char *major_path = (e1 ? item->relpath1 : item->relpath0);
          const char *from = "";

          if (item->reparented || item->renamed)
            {
              if (! item->reparented)
                from = apr_psprintf(scratch_pool,
                                    " (renamed from .../%s)",
                                    e0->name);
              else if (! item->renamed)
                from = apr_psprintf(scratch_pool,
                                    " (moved from %s/...)",
                                    svn_relpath_dirname(item->relpath0,
                                                        scratch_pool));
              else
                from = apr_psprintf(scratch_pool,
                                    " (moved+renamed from %s)",
                                    item->relpath0);
            }
          svnmover_notify("%s%c%c%c %s%s%s",
                          prefix,
                          status_mod,
                          item->reparented ? 'v' : ' ',
                          item->renamed ? 'r' : ' ',
                          major_path,
                          subtree_subbranch_str(e0 ? left : right,
                                                e0 ? left_bid : right_bid,
                                                item->eid, scratch_pool),
                          from);
        }
      else
        {
          svnmover_notify("%s%c%c%c e%-3d  %s%s%s%s%s",
                          prefix,
                          status_mod,
                          item->reparented ? 'v' : ' ',
                          item->renamed ? 'r' : ' ',
                          item->eid,
                          e1 ? peid_name(e1, scratch_pool) : "",
                          subtree_subbranch_str(e0 ? left : right,
                                                e0 ? left_bid : right_bid,
                                                item->eid, scratch_pool),
                          e0 && e1 ? " (from " : "",
                          e0 ? peid_name(e0, scratch_pool) : "",
                          e0 && e1 ? ")" : "");
        }
    }

  return SVN_NO_ERROR;
}

typedef svn_error_t *
svn_branch__diff_func_t(svn_branch__subtree_t *left,
                        const char *left_bid,
                        svn_branch__subtree_t *right,
                        const char *right_bid,
                        const char *prefix,
                        const char *header,
                        apr_pool_t *scratch_pool);

/* Display differences between subtrees LEFT and RIGHT.
 *
 * Recurse into sub-branches.
 */
static svn_error_t *
subtree_diff_r(svn_branch__state_t *left_branch,
               int left_root_eid,
               svn_branch__state_t *right_branch,
               int right_root_eid,
               svn_branch__diff_func_t diff_func,
               const char *prefix,
               apr_pool_t *scratch_pool)
{
  svn_branch__subtree_t *left = NULL;
  svn_branch__subtree_t *right = NULL;
  const char *left_str
    = left_branch
        ? apr_psprintf(scratch_pool, "%s:e%d at /%s",
                       left_branch->bid, left_root_eid,
                       svn_branch__get_root_rrpath(left_branch, scratch_pool))
        : NULL;
  const char *right_str
    = right_branch
        ? apr_psprintf(scratch_pool, "%s:e%d at /%s",
                       right_branch->bid, right_root_eid,
                       svn_branch__get_root_rrpath(right_branch, scratch_pool))
            : NULL;
  const char *header;
  apr_hash_t *subbranches_l, *subbranches_r, *subbranches_all;
  apr_hash_index_t *hi;

  if (left_branch)
    {
      SVN_ERR(svn_branch__get_subtree(left_branch, &left, left_root_eid,
                                      scratch_pool));
    }
  if (right_branch)
    {
      SVN_ERR(svn_branch__get_subtree(right_branch, &right, right_root_eid,
                                      scratch_pool));
    }

  if (!left)
    {
      header = apr_psprintf(scratch_pool,
                 "--- added branch %s",
                 right_str);
      svnmover_notify("%s%s", prefix, header);
    }
  else if (!right)
    {
      header = apr_psprintf(scratch_pool,
                 "--- deleted branch %s",
                 left_str);
      svnmover_notify("%s%s", prefix, header);
    }
  else
    {
      if (strcmp(left_str, right_str) == 0)
        {
          header = apr_psprintf(
                     scratch_pool, "--- diff branch %s",
                     left_str);
        }
      else
        {
          header = apr_psprintf(
                     scratch_pool, "--- diff branch %s : %s",
                     left_str, right_str);
        }
      SVN_ERR(diff_func(left, left_branch->bid, right, right_branch->bid,
                        prefix, header,
                        scratch_pool));
    }

  /* recurse into each subbranch that exists in LEFT and/or in RIGHT */
  subbranches_l = left ? left->subbranches : apr_hash_make(scratch_pool);
  subbranches_r = right ? right->subbranches : apr_hash_make(scratch_pool);
  subbranches_all = hash_overlay(subbranches_l, subbranches_r);

  for (hi = apr_hash_first(scratch_pool, subbranches_all);
       hi; hi = apr_hash_next(hi))
    {
      int e = svn_eid__hash_this_key(hi);
      svn_branch__state_t *left_subbranch = NULL, *right_subbranch = NULL;
      int left_subbranch_eid = -1, right_subbranch_eid = -1;

      /* recurse */
      if (left_branch)
        {
          SVN_ERR(svn_branch__get_subbranch_at_eid(left_branch, &left_subbranch, e,
                                                   scratch_pool));
          if (left_subbranch)
            {
              left_subbranch_eid = svn_branch__root_eid(left_subbranch);
            }
        }
      if (right_branch)
        {
          SVN_ERR(svn_branch__get_subbranch_at_eid(right_branch, &right_subbranch, e,
                                                   scratch_pool));
          if (right_subbranch)
            {
              right_subbranch_eid = svn_branch__root_eid(right_subbranch);
            }
        }
      SVN_ERR(subtree_diff_r(left_subbranch, left_subbranch_eid,
                             right_subbranch, right_subbranch_eid,
                             diff_func, prefix, scratch_pool));
    }
  return SVN_NO_ERROR;
}

/* Display differences between branch subtrees LEFT and RIGHT.
 *
 * Recurse into sub-branches.
 */
static svn_error_t *
branch_diff_r(svn_branch__el_rev_id_t *left,
              svn_branch__el_rev_id_t *right,
              svn_branch__diff_func_t diff_func,
              const char *prefix,
              apr_pool_t *scratch_pool)
{
  SVN_ERR(subtree_diff_r(left->branch, left->eid,
                         right->branch, right->eid,
                         diff_func, prefix, scratch_pool));
  return SVN_NO_ERROR;
}

/*  */
static svn_error_t *
do_copy(svn_branch__el_rev_id_t *from_el_rev,
        svn_branch__state_t *to_branch,
        svn_branch__eid_t to_parent_eid,
        const char *new_name,
        apr_pool_t *scratch_pool)
{
  const char *from_branch_id = svn_branch__get_id(from_el_rev->branch,
                                                  scratch_pool);
  svn_branch__rev_bid_eid_t *src_el_rev
    = svn_branch__rev_bid_eid_create(from_el_rev->rev, from_branch_id,
                                     from_el_rev->eid, scratch_pool);
  const char *from_path = el_rev_id_to_path(from_el_rev, scratch_pool);
  const char *to_path = branch_peid_name_to_path(to_branch, to_parent_eid,
                                                 new_name, scratch_pool);

  SVN_ERR(svn_branch__state_copy_tree(to_branch,
                                      src_el_rev, to_parent_eid, new_name,
                                      scratch_pool));
  svnmover_notify_v("A+   %s (from %s)",
                    to_path, from_path);

  return SVN_NO_ERROR;
}

/*  */
static svn_error_t *
do_delete(svn_branch__state_t *branch,
          svn_branch__eid_t eid,
          apr_pool_t *scratch_pool)
{
  const char *path = svn_branch__get_rrpath_by_eid(branch, eid, scratch_pool);

  SVN_ERR(svn_branch__state_delete_one(branch, eid, scratch_pool));
  svnmover_notify_v("D    %s", path);
  return SVN_NO_ERROR;
}

/*  */
static svn_error_t *
do_mkdir(svn_branch__txn_t *txn,
         svn_branch__state_t *to_branch,
         svn_branch__eid_t to_parent_eid,
         const char *new_name,
         apr_pool_t *scratch_pool)
{
  apr_hash_t *props = apr_hash_make(scratch_pool);
  svn_element__payload_t *payload
    = svn_element__payload_create_dir(props, scratch_pool);
  int new_eid;
  const char *path = branch_peid_name_to_path(to_branch, to_parent_eid,
                                              new_name, scratch_pool);

  SVN_ERR(svn_branch__txn_new_eid(txn, &new_eid, scratch_pool));
  SVN_ERR(svn_branch__state_alter_one(to_branch, new_eid,
                                      to_parent_eid, new_name, payload,
                                      scratch_pool));
  svnmover_notify_v("A    %s",
                    path);
  return SVN_NO_ERROR;
}

/*  */
static svn_error_t *
do_put_file(svn_branch__txn_t *txn,
            const char *local_file_path,
            svn_branch__el_rev_id_t *file_el_rev,
            svn_branch__el_rev_id_t *parent_el_rev,
            const char *file_name,
            apr_pool_t *scratch_pool)
{
  apr_hash_t *props;
  svn_stringbuf_t *text;
  int parent_eid;
  const char *name;
  svn_element__payload_t *payload;

  if (file_el_rev->eid != -1)
    {
      /* get existing props */
      svn_element__content_t *existing_element;

      SVN_ERR(svn_branch__state_get_element(file_el_rev->branch,
                                            &existing_element,
                                            file_el_rev->eid, scratch_pool));
      props = existing_element->payload->props;
    }
  else
    {
      props = apr_hash_make(scratch_pool);
    }
  /* read new text from file */
  {
    svn_stream_t *src;

    if (strcmp(local_file_path, "-") != 0)
      SVN_ERR(svn_stream_open_readonly(&src, local_file_path,
                                       scratch_pool, scratch_pool));
    else
      SVN_ERR(svn_stream_for_stdin2(&src, FALSE, scratch_pool));

    SVN_ERR(svn_stringbuf_from_stream(&text, src, 0, scratch_pool));
  }
  payload = svn_element__payload_create_file(props, text, scratch_pool);

  if (is_branch_root_element(file_el_rev->branch,
                             file_el_rev->eid))
    {
      parent_eid = -1;
      name = "";
    }
  else
    {
      parent_eid = parent_el_rev->eid;
      name = file_name;
    }

  if (file_el_rev->eid != -1)
    {
      const char *path = el_rev_id_to_path(file_el_rev, scratch_pool);

      SVN_ERR(svn_branch__state_alter_one(file_el_rev->branch, file_el_rev->eid,
                                          parent_eid, name, payload,
                                          scratch_pool));
      svnmover_notify_v("M    %s",
                        path);
    }
  else
    {
      int new_eid;
      const char *path
        = branch_peid_name_to_path(parent_el_rev->branch, parent_eid, name,
                                   scratch_pool);

      SVN_ERR(svn_branch__txn_new_eid(txn, &new_eid, scratch_pool));
      SVN_ERR(svn_branch__state_alter_one(parent_el_rev->branch, new_eid,
                                          parent_eid, name, payload,
                                          scratch_pool));
      file_el_rev->eid = new_eid;
      svnmover_notify_v("A    %s",
                        path);
    }
  return SVN_NO_ERROR;
}

/*  */
static svn_error_t *
do_cat(svn_branch__el_rev_id_t *file_el_rev,
       apr_pool_t *scratch_pool)
{
  apr_hash_t *props;
  svn_stringbuf_t *text;
  svn_element__content_t *existing_element;
  apr_hash_index_t *hi;

  /* get existing props */
  SVN_ERR(svn_branch__state_get_element(file_el_rev->branch, &existing_element,
                                        file_el_rev->eid, scratch_pool));

  props = existing_element->payload->props;
  text = existing_element->payload->text;

  for (hi = apr_hash_first(scratch_pool, props); hi; hi = apr_hash_next(hi))
    {
      const char *pname = apr_hash_this_key(hi);
      svn_string_t *pval = apr_hash_this_val(hi);

      svnmover_notify("property '%s': '%s'", pname, pval->data);
    }
  if (text)
    {
      svnmover_notify("%s", text->data);
    }
  return SVN_NO_ERROR;
}

/* Find the main parent of branch-state BRANCH. That means:
 *   - the only parent (in the case of straight history or branching), else
 *   - the parent with the same branch id (in the case of normal merging), else
 *   - none (in the case of a new unrelated branch, or a new branch formed
 *     by merging two or more other branches).
 */
static svn_error_t *
find_branch_main_parent(svn_branch__state_t *branch,
                        svn_branch__rev_bid_t **predecessor_p,
                        apr_pool_t *result_pool)
{
  svn_branch__history_t *history;
  svn_branch__rev_bid_t *our_own_history;
  svn_branch__rev_bid_t *predecessor = NULL;

  SVN_ERR(svn_branch__state_get_history(branch, &history, result_pool));
  if (apr_hash_count(history->parents) == 1)
    {
      apr_hash_index_t *hi = apr_hash_first(result_pool, history->parents);

      predecessor = apr_hash_this_val(hi);
    }
  else if ((our_own_history = svn_hash_gets(history->parents, branch->bid)))
    {
      predecessor = our_own_history;
    }

  if (predecessor_p)
    *predecessor_p = predecessor;
  return SVN_NO_ERROR;
}

/* Set *NEW_EL_REV_P to the location where OLD_EL_REV was in the previous
 * revision. Follow the "main line" of any branching in its history.
 *
 * If the same EID...
 */
static svn_error_t *
svn_branch__find_predecessor_el_rev(svn_branch__el_rev_id_t **new_el_rev_p,
                                    svn_branch__el_rev_id_t *old_el_rev,
                                    apr_pool_t *result_pool)
{
  const svn_branch__repos_t *repos = old_el_rev->branch->txn->repos;
  svn_branch__rev_bid_t *predecessor;
  svn_branch__state_t *branch;

  SVN_ERR(find_branch_main_parent(old_el_rev->branch,
                                  &predecessor, result_pool));
  if (! predecessor)
    {
      *new_el_rev_p = NULL;
      return SVN_NO_ERROR;
    }

  SVN_ERR(svn_branch__repos_get_branch_by_id(&branch,
                                             repos, predecessor->rev,
                                             predecessor->bid, result_pool));
  *new_el_rev_p = svn_branch__el_rev_id_create(branch, old_el_rev->eid,
                                               predecessor->rev, result_pool);

  return SVN_NO_ERROR;
}

/* Similar to 'svn log -v', this iterates over the revisions between
 * LEFT and RIGHT (currently excluding LEFT), printing a single-rev diff
 * for each.
 */
static svn_error_t *
do_log(svn_branch__el_rev_id_t *left,
       svn_branch__el_rev_id_t *right,
       apr_pool_t *scratch_pool)
{
  svn_revnum_t first_rev = left->rev;

  while (right->rev > first_rev)
    {
      svn_branch__el_rev_id_t *el_rev_left;

      SVN_ERR(svn_branch__find_predecessor_el_rev(&el_rev_left, right, scratch_pool));

      svnmover_notify(SVN_CL__LOG_SEP_STRING "r%ld | ...",
                      right->rev);
      svnmover_notify("History:");
      SVN_ERR(show_history_r(right->branch, "   ", scratch_pool));
      svnmover_notify("Changed elements:");
      SVN_ERR(branch_diff_r(el_rev_left, right,
                            show_subtree_diff, "   ",
                            scratch_pool));
      right = el_rev_left;
    }

  return SVN_NO_ERROR;
}

/* Make a subbranch at OUTER_BRANCH : OUTER_PARENT_EID : OUTER_NAME.
 *
 * The subbranch will consist of a single element given by PAYLOAD.
 */
static svn_error_t *
do_mkbranch(const char **new_branch_id_p,
            svn_branch__txn_t *txn,
            svn_branch__state_t *outer_branch,
            int outer_parent_eid,
            const char *outer_name,
            svn_element__payload_t *payload,
            apr_pool_t *scratch_pool)
{
  const char *outer_branch_id = svn_branch__get_id(outer_branch, scratch_pool);
  int new_outer_eid, new_inner_eid;
  const char *new_branch_id;
  svn_branch__state_t *new_branch;
  const char *path = branch_peid_name_to_path(outer_branch, outer_parent_eid,
                                              outer_name, scratch_pool);

  SVN_ERR(svn_branch__txn_new_eid(txn, &new_outer_eid, scratch_pool));
  SVN_ERR(svn_branch__state_alter_one(outer_branch, new_outer_eid,
                                      outer_parent_eid, outer_name,
                                      svn_element__payload_create_subbranch(
                                        scratch_pool), scratch_pool));

  SVN_ERR(svn_branch__txn_new_eid(txn, &new_inner_eid, scratch_pool));
  new_branch_id = svn_branch__id_nest(outer_branch_id, new_outer_eid,
                                      scratch_pool);
  SVN_ERR(svn_branch__txn_open_branch(txn, &new_branch,
                                      new_branch_id, new_inner_eid,
                                      NULL /*tree_ref*/,
                                      scratch_pool, scratch_pool));
  SVN_ERR(svn_branch__state_alter_one(new_branch, new_inner_eid,
                                      -1, "", payload, scratch_pool));

  svnmover_notify_v("A    %s (branch %s)",
                    path,
                    new_branch->bid);
  if (new_branch_id_p)
    *new_branch_id_p = new_branch->bid;
  return SVN_NO_ERROR;
}

/* Branch all or part of an existing branch, making a new branch.
 *
 * Branch the subtree of FROM_BRANCH found at FROM_EID, to create
 * a new branch at TO_OUTER_BRANCH:TO_OUTER_PARENT_EID:NEW_NAME.
 *
 * FROM_BRANCH:FROM_EID must be an existing element. It may be the
 * root of FROM_BRANCH. It must not be the root of a subbranch of
 * FROM_BRANCH.
 *
 * TO_OUTER_BRANCH:TO_OUTER_PARENT_EID must be an existing directory
 * and NEW_NAME must be nonexistent in that directory.
 */
static svn_error_t *
do_branch(svn_branch__state_t **new_branch_p,
          svn_branch__txn_t *txn,
          svn_branch__rev_bid_eid_t *from,
          svn_branch__state_t *to_outer_branch,
          svn_branch__eid_t to_outer_parent_eid,
          const char *new_name,
          apr_pool_t *result_pool,
          apr_pool_t *scratch_pool)
{
  const char *to_outer_branch_id
    = to_outer_branch ? svn_branch__get_id(to_outer_branch, scratch_pool) : NULL;
  int to_outer_eid;
  const char *new_branch_id;
  svn_branch__state_t *new_branch;
  svn_branch__history_t *history;
  const char *to_path
    = branch_peid_name_to_path(to_outer_branch,
                               to_outer_parent_eid, new_name, scratch_pool);

  /* assign new eid to root element (outer branch) */
  SVN_ERR(svn_branch__txn_new_eid(txn, &to_outer_eid, scratch_pool));

  new_branch_id = svn_branch__id_nest(to_outer_branch_id, to_outer_eid,
                                      scratch_pool);
  SVN_ERR(svn_branch__txn_open_branch(txn, &new_branch,
                                      new_branch_id, from->eid, from,
                                      result_pool, scratch_pool));
  history = svn_branch__history_create_empty(scratch_pool);
  SVN_ERR(svn_branch__history_add_parent(history, from->rev, from->bid,
                                         scratch_pool));
  SVN_ERR(svn_branch__state_set_history(new_branch, history, scratch_pool));
  SVN_ERR(svn_branch__state_alter_one(to_outer_branch, to_outer_eid,
                                      to_outer_parent_eid, new_name,
                                      svn_element__payload_create_subbranch(
                                        scratch_pool), scratch_pool));

  svnmover_notify_v("A+   %s (branch %s)",
                    to_path,
                    new_branch->bid);

  if (new_branch_p)
    *new_branch_p = new_branch;
  return SVN_NO_ERROR;
}

static svn_error_t *
do_topbranch(svn_branch__state_t **new_branch_p,
             svn_branch__txn_t *txn,
             svn_branch__rev_bid_eid_t *from,
             apr_pool_t *result_pool,
             apr_pool_t *scratch_pool)
{
  int outer_eid;
  const char *new_branch_id;
  svn_branch__state_t *new_branch;

  SVN_ERR(svn_branch__txn_new_eid(txn, &outer_eid, scratch_pool));
  new_branch_id = svn_branch__id_nest(NULL /*outer_branch*/, outer_eid,
                                      scratch_pool);
  SVN_ERR(svn_branch__txn_open_branch(txn, &new_branch,
                                      new_branch_id, from->eid, from,
                                      result_pool, scratch_pool));

  svnmover_notify_v("A+   (branch %s)",
                    new_branch->bid);

  if (new_branch_p)
    *new_branch_p = new_branch;
  return SVN_NO_ERROR;
}

/* Branch the subtree of FROM_BRANCH found at FROM_EID, to appear
 * in the existing branch TO_BRANCH at TO_PARENT_EID:NEW_NAME.
 *
 * This is like merging the creation of the source subtree into TO_BRANCH.
 *
 * Any elements of the source subtree that already exist in TO_BRANCH
 * are altered. This is like resolving any merge conflicts as 'theirs'.
 *
 * (### Sometimes the user might prefer that we throw an error if any
 * element of the source subtree already exists in TO_BRANCH.)
 */
static svn_error_t *
do_branch_into(svn_branch__state_t *from_branch,
               int from_eid,
               svn_branch__state_t *to_branch,
               svn_branch__eid_t to_parent_eid,
               const char *new_name,
               apr_pool_t *scratch_pool)
{
  svn_branch__subtree_t *from_subtree;
  svn_element__content_t *new_root_content;
  const char *to_path = branch_peid_name_to_path(to_branch, to_parent_eid,
                                                 new_name, scratch_pool);

  /* Source element must exist */
  if (! svn_branch__get_path_by_eid(from_branch, from_eid, scratch_pool))
    {
      return svn_error_createf(SVN_BRANCH__ERR, NULL,
                               _("Cannot branch from %s e%d: "
                                 "does not exist"),
                               svn_branch__get_id(
                                 from_branch, scratch_pool), from_eid);
    }

  SVN_ERR(svn_branch__get_subtree(from_branch, &from_subtree, from_eid,
                                  scratch_pool));

  /* Change this subtree's root element to TO_PARENT_EID/NEW_NAME. */
  new_root_content
    = svn_element__tree_get(from_subtree->tree, from_subtree->tree->root_eid);
  new_root_content
    = svn_element__content_create(to_parent_eid, new_name,
                                  new_root_content->payload, scratch_pool);
  svn_element__tree_set(from_subtree->tree, from_subtree->tree->root_eid,
                        new_root_content);

  /* Populate the new branch mapping */
  SVN_ERR(svn_branch__instantiate_elements_r(to_branch, *from_subtree,
                                             scratch_pool));
  svnmover_notify_v("A+   %s (subtree)",
                    to_path);

  return SVN_NO_ERROR;
}

/* Copy-and-delete.
 *
 *      copy the subtree at EL_REV to TO_BRANCH:TO_PARENT_EID:TO_NAME
 *      delete the subtree at EL_REV
 */
static svn_error_t *
do_copy_and_delete(svn_branch__el_rev_id_t *el_rev,
                   svn_branch__state_t *to_branch,
                   int to_parent_eid,
                   const char *to_name,
                   apr_pool_t *scratch_pool)
{
  const char *from_path
    = svn_branch__get_rrpath_by_eid(el_rev->branch, el_rev->eid, scratch_pool);

  SVN_ERR_ASSERT(! is_branch_root_element(el_rev->branch, el_rev->eid));

  SVN_ERR(do_copy(el_rev, to_branch, to_parent_eid, to_name,
                  scratch_pool));

  SVN_ERR(svn_branch__state_delete_one(el_rev->branch, el_rev->eid,
                                       scratch_pool));
  svnmover_notify_v("D    %s", from_path);

  return SVN_NO_ERROR;
}

/* Branch-and-delete.
 *
 *      branch the subtree at EL_REV creating a new nested branch at
 *        TO_BRANCH:TO_PARENT_EID:TO_NAME,
 *        or creating a new top-level branch if TO_BRANCH is null;
 *      delete the subtree at EL_REV
 */
static svn_error_t *
do_branch_and_delete(svn_branch__txn_t *edit_txn,
                     svn_branch__el_rev_id_t *el_rev,
                     svn_branch__state_t *to_outer_branch,
                     int to_outer_parent_eid,
                     const char *to_name,
                     apr_pool_t *scratch_pool)
{
  const char *from_branch_id = svn_branch__get_id(el_rev->branch,
                                                  scratch_pool);
  svn_branch__rev_bid_eid_t *from
    = svn_branch__rev_bid_eid_create(el_rev->rev, from_branch_id,
                                     el_rev->eid, scratch_pool);
  svn_branch__state_t *new_branch;
  const char *from_path
    = svn_branch__get_rrpath_by_eid(el_rev->branch, el_rev->eid, scratch_pool);

  SVN_ERR_ASSERT(! is_branch_root_element(el_rev->branch, el_rev->eid));

  SVN_ERR(do_branch(&new_branch, edit_txn, from,
                    to_outer_branch, to_outer_parent_eid, to_name,
                    scratch_pool, scratch_pool));

  SVN_ERR(svn_branch__state_delete_one(el_rev->branch, el_rev->eid,
                                       scratch_pool));
  svnmover_notify_v("D    %s", from_path);

  return SVN_NO_ERROR;
}

/* Branch-into-and-delete.
 *
 * (Previously, confusingly, called 'branch-and-delete'.)
 *
 * The target branch is different from the source branch.
 *
 *      delete elements from source branch
 *      instantiate (or update) same elements in target branch
 *
 * For each element being moved, if the element already exists in TO_BRANCH,
 * the effect is as if the existing element in TO_BRANCH was first deleted.
 */
static svn_error_t *
do_branch_into_and_delete(svn_branch__el_rev_id_t *el_rev,
                          svn_branch__state_t *to_branch,
                          int to_parent_eid,
                          const char *to_name,
                          apr_pool_t *scratch_pool)
{
  const char *from_path
    = svn_branch__get_rrpath_by_eid(el_rev->branch, el_rev->eid, scratch_pool);

  SVN_ERR_ASSERT(! is_branch_root_element(el_rev->branch, el_rev->eid));

  /* This is supposed to be used for moving to a *different* branch.
     In fact, this method would also work for moving within one
     branch, but we don't currently want to use it for that purpose. */
  SVN_ERR_ASSERT(! BRANCH_IS_SAME_BRANCH(el_rev->branch, to_branch,
                                         scratch_pool));

  /* Merge the "creation of the source" to the target (aka branch-into) */
  SVN_ERR(do_branch_into(el_rev->branch, el_rev->eid,
                         to_branch, to_parent_eid, to_name,
                         scratch_pool));

  SVN_ERR(svn_branch__state_delete_one(el_rev->branch, el_rev->eid,
                                       scratch_pool));
  svnmover_notify_v("D    %s", from_path);

  return SVN_NO_ERROR;
}

/* Interactive options for moving to another branch.
 */
static svn_error_t *
do_interactive_cross_branch_move(svn_branch__txn_t *txn,
                                 svn_branch__el_rev_id_t *el_rev,
                                 svn_branch__el_rev_id_t *to_parent_el_rev,
                                 const char *to_name,
                                 apr_pool_t *scratch_pool)
{
  svn_error_t *err;
  const char *input;

  if (0 /*### if non-interactive*/)
    {
      return svn_error_createf(SVN_BRANCH__ERR, NULL,
        _("mv: The source and target are in different branches. "
          "Some ways to move content to a different branch are, "
          "depending on the effect you want to achieve: "
          "copy-and-delete, branch-and-delete, branch-into-and-delete"));
    }

  svnmover_notify_v(
    _("mv: The source and target are in different branches. "
      "Some ways to move content to a different branch are, "
      "depending on the effect you want to achieve:\n"
      "  c: copy-and-delete: cp SOURCE TARGET; rm SOURCE\n"
      "  b: branch-and-delete: branch SOURCE TARGET; rm SOURCE\n"
      "  i: branch-into-and-delete: branch-into SOURCE TARGET; rm SOURCE\n"
      "We can do one of these for you now if you wish.\n"
    ));

  settext_stderr(TEXT_FG_YELLOW);
  err = svn_cmdline_prompt_user2(
          &input,
          "Your choice (c, b, i, or just <enter> to do nothing): ",
          NULL, scratch_pool);
  settext(TEXT_RESET);
  if (err && (err->apr_err == SVN_ERR_CANCELLED || err->apr_err == APR_EOF))
    {
      svn_error_clear(err);
      return SVN_NO_ERROR;
    }
  SVN_ERR(err);

  if (input[0] == 'c' || input[0] == 'C')
    {
      svnmover_notify_v("Performing 'copy-and-delete SOURCE TARGET'");

      SVN_ERR(do_copy_and_delete(el_rev,
                                 to_parent_el_rev->branch,
                                 to_parent_el_rev->eid, to_name,
                                 scratch_pool));
    }
  else if (input[0] == 'b' || input[0] == 'B')
    {
      svnmover_notify_v("Performing 'branch-and-delete SOURCE TARGET'");

      SVN_ERR(do_branch_and_delete(txn, el_rev,
                                   to_parent_el_rev->branch,
                                   to_parent_el_rev->eid, to_name,
                                   scratch_pool));
    }
  else if (input[0] == 'i' || input[0] == 'I')
    {
      svnmover_notify_v("Performing 'branch-into-and-delete SOURCE TARGET'");
      svnmover_notify_v(
        "In the current implementation of this experimental UI, each element "
        "instance from the source branch subtree will overwrite any instance "
        "of the same element that already exists in the target branch."
        );
      /* We could instead either throw an error or fall back to copy-and-delete
         if any moved element already exists in target branch. */

      SVN_ERR(do_branch_into_and_delete(el_rev,
                                        to_parent_el_rev->branch,
                                        to_parent_el_rev->eid, to_name,
                                        scratch_pool));
    }

  return SVN_NO_ERROR;
}

/* Move.
 */
static svn_error_t *
do_move(svn_branch__el_rev_id_t *el_rev,
        svn_branch__el_rev_id_t *to_parent_el_rev,
        const char *to_name,
        apr_pool_t *scratch_pool)
{
  const char *from_path = el_rev_id_to_path(el_rev, scratch_pool);
  const char *to_path
    = branch_peid_name_to_path(to_parent_el_rev->branch,
                               to_parent_el_rev->eid, to_name, scratch_pool);
  /* New payload shall be the same as before */
  svn_element__content_t *existing_element;

  SVN_ERR(svn_branch__state_get_element(el_rev->branch, &existing_element,
                                        el_rev->eid, scratch_pool));
  SVN_ERR(svn_branch__state_alter_one(el_rev->branch, el_rev->eid,
                            to_parent_el_rev->eid, to_name,
                            existing_element->payload, scratch_pool));
  svnmover_notify_v("V    %s (from %s)",
                    to_path, from_path);
  return SVN_NO_ERROR;
}

/* This commit callback prints not only a commit summary line but also
 * a log-style summary of the changes.
 */
static svn_error_t *
commit_callback(const svn_commit_info_t *commit_info,
                void *baton,
                apr_pool_t *pool)
{
  commit_callback_baton_t *b = baton;

  svnmover_notify("Committed r%ld:", commit_info->revision);

  b->revision = commit_info->revision;
  return SVN_NO_ERROR;
}

/* Display a diff of the commit */
static svn_error_t *
display_diff_of_commit(const commit_callback_baton_t *ccbb,
                       apr_pool_t *scratch_pool)
{
  svn_branch__txn_t *previous_head_txn
    = svn_branch__repos_get_base_revision_root(ccbb->edit_txn);
  svn_branch__state_t *base_branch
    = svn_branch__txn_get_branch_by_id(previous_head_txn,
                                       ccbb->wc_base_branch_id,
                                       scratch_pool);
  svn_branch__state_t *committed_branch
    = svn_branch__txn_get_branch_by_id(ccbb->edit_txn,
                                       ccbb->wc_commit_branch_id,
                                       scratch_pool);
  svn_branch__el_rev_id_t *el_rev_left
    = svn_branch__el_rev_id_create(base_branch, svn_branch__root_eid(base_branch),
                                   base_branch->txn->rev,
                                   scratch_pool);
  svn_branch__el_rev_id_t *el_rev_right
    = svn_branch__el_rev_id_create(committed_branch,
                                   svn_branch__root_eid(committed_branch),
                                   committed_branch->txn->rev,
                                   scratch_pool);

  SVN_ERR(branch_diff_r(el_rev_left, el_rev_right,
                        show_subtree_diff, "   ",
                        scratch_pool));
  return SVN_NO_ERROR;
}

static svn_error_t *
commit(svn_revnum_t *new_rev_p,
       svnmover_wc_t *wc,
       apr_hash_t *revprops,
       apr_pool_t *scratch_pool)
{
  if (svnmover_any_conflicts(wc->conflicts))
    {
      return svn_error_createf(SVN_BRANCH__ERR, NULL,
                               _("Cannot commit because there are "
                                 "unresolved conflicts"));
    }

  /* Complete the old edit drive (editing the WC working state) */
  SVN_ERR(svn_branch__txn_sequence_point(wc->edit_txn, scratch_pool));

  /* Just as in execute() the pool must be a subpool of wc->pool. */
  SVN_ERR(wc_commit(new_rev_p, wc, revprops, wc->pool));

  return SVN_NO_ERROR;
}

/* Commit.
 *
 * Set *NEW_REV_P to the committed revision number. Update the WC base of
 * each committed element to that revision.
 *
 * If there are no changes to commit, set *NEW_REV_P to SVN_INVALID_REVNUM
 * and do not make a commit.
 *
 * NEW_REV_P may be null if not wanted.
 */
static svn_error_t *
do_commit(svn_revnum_t *new_rev_p,
          svnmover_wc_t *wc,
          apr_hash_t *revprops,
          apr_pool_t *scratch_pool)
{
  svn_revnum_t new_rev;

  SVN_ERR(commit(&new_rev, wc, revprops, scratch_pool));

  if (new_rev_p)
    *new_rev_p = new_rev;
  return SVN_NO_ERROR;
}

/* Revert all uncommitted changes in WC.
 */
static svn_error_t *
do_revert(svnmover_wc_t *wc,
          apr_pool_t *scratch_pool)
{
  /* Replay the inverse of the current edit txn, into the current edit txn */
  SVN_ERR(replay(wc->edit_txn, wc->working->branch,
                 wc->working->branch,
                 wc->base->branch,
                 scratch_pool));
  wc->conflicts = NULL;

  return SVN_NO_ERROR;
}

/* Migration replay baton */
typedef struct migrate_replay_baton_t {
  svn_branch__txn_t *edit_txn;
  svn_ra_session_t *from_session;
  /* Hash (by revnum) of array of svn_repos_move_info_t. */
  apr_hash_t *moves;
} migrate_replay_baton_t;

/* Callback function for svn_ra_replay_range, invoked when starting to parse
 * a replay report.
 */
static svn_error_t *
migrate_replay_rev_started(svn_revnum_t revision,
                           void *replay_baton,
                           const svn_delta_editor_t **editor,
                           void **edit_baton,
                           apr_hash_t *rev_props,
                           apr_pool_t *pool)
{
  migrate_replay_baton_t *rb = replay_baton;
  const svn_delta_editor_t *old_editor;
  void *old_edit_baton;

  svnmover_notify("migrate: start r%ld", revision);

  SVN_ERR(svn_branch__compat_get_migration_editor(&old_editor, &old_edit_baton,
                                                  rb->edit_txn,
                                                  rb->from_session, revision,
                                                  pool));
  SVN_ERR(svn_delta__get_debug_editor(&old_editor, &old_edit_baton,
                                      old_editor, old_edit_baton,
                                      "migrate: ", pool));

  *editor = old_editor;
  *edit_baton = old_edit_baton;

  return SVN_NO_ERROR;
}

/* Callback function for svn_ra_replay_range, invoked when finishing parsing
 * a replay report.
 */
static svn_error_t *
migrate_replay_rev_finished(svn_revnum_t revision,
                            void *replay_baton,
                            const svn_delta_editor_t *editor,
                            void *edit_baton,
                            apr_hash_t *rev_props,
                            apr_pool_t *pool)
{
  migrate_replay_baton_t *rb = replay_baton;
  apr_array_header_t *moves_in_revision
    = apr_hash_get(rb->moves, &revision, sizeof(revision));

  SVN_ERR(editor->close_edit(edit_baton, pool));

  svnmover_notify("migrate: moves in revision r%ld:", revision);

  if (moves_in_revision)
    {
      int i;

      for (i = 0; i < moves_in_revision->nelts; i++)
        {
          svn_repos_move_info_t *this_move
            = APR_ARRAY_IDX(moves_in_revision, i, void *);

          if (this_move)
            {
              svnmover_notify("%s",
                     svn_client__format_move_chain_for_display(this_move,
                                                               "", pool));
            }
        }
    }

  return SVN_NO_ERROR;
}

/* Migrate changes from non-move-tracking revisions.
 */
static svn_error_t *
do_migrate(svnmover_wc_t *wc,
           svn_revnum_t start_revision,
           svn_revnum_t end_revision,
           apr_pool_t *scratch_pool)
{
  migrate_replay_baton_t *rb = apr_pcalloc(scratch_pool, sizeof(*rb));

  if (start_revision < 1 || end_revision < 1
      || start_revision > end_revision
      || end_revision > wc->head_revision)
    {
      return svn_error_createf(SVN_ERR_INCORRECT_PARAMS, NULL,
                               _("migrate: Bad revision range (%ld to %ld); "
                                 "minimum is 1 and maximum (head) is %ld"),
                               start_revision, end_revision,
                               wc->head_revision);
    }

  /* Scan the repository log for move info */
  SVN_ERR(svn_client__get_repos_moves(&rb->moves,
                                      "" /*(unused)*/,
                                      wc->ra_session,
                                      start_revision, end_revision,
                                      wc->ctx, scratch_pool, scratch_pool));

  rb->edit_txn = wc->edit_txn;
  rb->from_session = wc->ra_session;
  SVN_ERR(svn_ra_replay_range(rb->from_session,
                              start_revision, end_revision,
                              0, TRUE,
                              migrate_replay_rev_started,
                              migrate_replay_rev_finished,
                              rb, scratch_pool));
  return SVN_NO_ERROR;
}

static svn_error_t *
show_branch_history(svn_branch__state_t *branch,
                    apr_pool_t *scratch_pool)
{
  svn_branch__history_t *history;
  svn_branch__rev_bid_t *main_parent;
  apr_hash_index_t *hi;

  SVN_ERR(svn_branch__state_get_history(branch, &history, scratch_pool));

  SVN_ERR(find_branch_main_parent(branch, &main_parent, scratch_pool));
  if (main_parent)
    {
      if (strcmp(main_parent->bid, branch->bid) == 0)
        {
          svnmover_notify("  main parent: r%ld.%s",
                          main_parent->rev, main_parent->bid);
        }
      else
        {
          svnmover_notify("  main parent (branched from): r%ld.%s",
                          main_parent->rev, main_parent->bid);
        }
    }
  for (hi = apr_hash_first(scratch_pool, history->parents);
       hi; hi = apr_hash_next(hi))
    {
      svn_branch__rev_bid_t *parent = apr_hash_this_val(hi);

      if (! svn_branch__rev_bid_equal(parent, main_parent))
        {
          svnmover_notify("  other parent (complete merge): r%ld.%s",
                          parent->rev, parent->bid);
        }
    }

  return SVN_NO_ERROR;
}

/* Show info about element E.
 *
 * TODO: Show different info for a repo element versus a WC element.
 */
static svn_error_t *
do_info(svnmover_wc_t *wc,
        svn_branch__el_rev_id_t *e,
        apr_pool_t *scratch_pool)
{
  svnmover_notify("Element Id: %d%s",
                  e->eid,
                  is_branch_root_element(e->branch, e->eid)
                    ? " (branch root)" : "");

  /* Show WC info for a WC working element, or repo info for a repo element */
  if (e->rev == SVN_INVALID_REVNUM)
    {
      svn_branch__state_t *base_branch, *work_branch;
      svn_revnum_t base_rev;
      svn_element__content_t *e_base, *e_work;
      svn_boolean_t is_modified;

      base_branch = svn_branch__txn_get_branch_by_id(
                      wc->base->branch->txn, e->branch->bid, scratch_pool);
      work_branch = svn_branch__txn_get_branch_by_id(
                      wc->working->branch->txn, e->branch->bid, scratch_pool);
      base_rev = svnmover_wc_get_base_rev(wc, base_branch, e->eid, scratch_pool);
      SVN_ERR(svn_branch__state_get_element(base_branch, &e_base,
                                            e->eid, scratch_pool));
      SVN_ERR(svn_branch__state_get_element(work_branch, &e_work,
                                            e->eid, scratch_pool));
      is_modified = !svn_element__content_equal(e_base, e_work,
                                                scratch_pool);

      svnmover_notify("Base Revision: %ld", base_rev);
      svnmover_notify("Base Branch:    %s", base_branch->bid);
      svnmover_notify("Working Branch: %s", work_branch->bid);
      svnmover_notify("Modified:       %s", is_modified ? "yes" : "no");
    }
  else
    {
      svnmover_notify("Revision: %ld", e->rev);
      svnmover_notify("Branch:    %s", e->branch->bid);
    }

  return SVN_NO_ERROR;
}


typedef struct arg_t
{
  const char *path_name;
  svn_branch__el_rev_id_t *el_rev, *parent_el_rev;
} arg_t;

#define VERIFY_REV_SPECIFIED(op, i)                                     \
  if (arg[i]->el_rev->rev == SVN_INVALID_REVNUM)                        \
    return svn_error_createf(SVN_BRANCH__ERR, NULL,                   \
                             _("%s: '%s': revision number required"),   \
                             op, action->relpath[i]);

#define VERIFY_REV_UNSPECIFIED(op, i)                                   \
  if (arg[i]->el_rev->rev != SVN_INVALID_REVNUM)                        \
    return svn_error_createf(SVN_BRANCH__ERR, NULL,                   \
                             _("%s: '%s@...': revision number not allowed"), \
                             op, action->relpath[i]);

#define VERIFY_EID_NONEXISTENT(op, i)                                   \
  if (arg[i]->el_rev->eid != -1)                                        \
    return svn_error_createf(SVN_BRANCH__ERR, NULL,                   \
                             _("%s: Element already exists at path '%s'"), \
                             op, action->relpath[i]);

#define VERIFY_EID_EXISTS(op, i)                                        \
  if (arg[i]->el_rev->eid == -1)                                        \
    return svn_error_createf(SVN_BRANCH__ERR, NULL,                   \
                             _("%s: Element not found at path '%s%s'"), \
                             op, action->relpath[i],                    \
                             action->rev_spec[i].kind == svn_opt_revision_unspecified \
                               ? "" : "@...");

#define VERIFY_PARENT_EID_EXISTS(op, i)                                 \
  if (arg[i]->parent_el_rev->eid == -1)                                 \
    return svn_error_createf(SVN_BRANCH__ERR, NULL,                   \
                             _("%s: Element not found at path '%s'"),   \
                             op, svn_relpath_dirname(action->relpath[i], pool));

#define VERIFY_NOT_CHILD_OF_SELF(op, i, j, pool)                        \
  if (svn_relpath_skip_ancestor(                                        \
        svn_branch__get_rrpath_by_eid(arg[i]->el_rev->branch,           \
                                      arg[i]->el_rev->eid, pool),       \
        svn_branch__get_rrpath_by_eid(arg[j]->parent_el_rev->branch,    \
                                      arg[j]->parent_el_rev->eid, pool))) \
    return svn_error_createf(SVN_BRANCH__ERR, NULL,                   \
                             _("%s: The specified target is nested "    \
                               "inside the source"), op);

/* If EL_REV specifies the root element of a nested branch, change EL_REV
 * to specify the corresponding subbranch-root element of its outer branch.
 *
 * If EL_REV specifies the root element of a top-level branch, return an
 * error.
 */
static svn_error_t *
point_to_outer_element_instead(svn_branch__el_rev_id_t *el_rev,
                               const char *op,
                               apr_pool_t *scratch_pool)
{
  if (is_branch_root_element(el_rev->branch, el_rev->eid))
    {
      svn_branch__state_t *outer_branch;
      int outer_eid;

      svn_branch__get_outer_branch_and_eid(&outer_branch, &outer_eid,
                                           el_rev->branch, scratch_pool);

      if (! outer_branch)
        return svn_error_createf(SVN_BRANCH__ERR, NULL, "%s: %s", op,
                                 _("svnmover cannot delete or move a "
                                   "top-level branch"));

      el_rev->eid = outer_eid;
      el_rev->branch = outer_branch;
    }

  return SVN_NO_ERROR;
}

static svn_error_t *
execute(svnmover_wc_t *wc,
        const apr_array_header_t *actions,
        const char *anchor_url,
        apr_hash_t *revprops,
        svn_client_ctx_t *ctx,
        apr_pool_t *pool)
{
  const char *base_relpath;
  apr_pool_t *iterpool = svn_pool_create(pool);
  int i;

  base_relpath = svn_uri_skip_ancestor(wc->repos_root_url, anchor_url, pool);

  for (i = 0; i < actions->nelts; ++i)
    {
      action_t *action = APR_ARRAY_IDX(actions, i, action_t *);
      int j;
      arg_t *arg[3] = { NULL, NULL, NULL };

      svn_pool_clear(iterpool);

      /* Before translating paths to/from elements, need a sequence point */
      SVN_ERR(svn_branch__txn_sequence_point(wc->edit_txn, iterpool));

      /* Convert each ACTION[j].{relpath, rev_spec} to
         (EL_REV[j], PARENT_EL_REV[j], PATH_NAME[j], REVNUM[j]),
         except for the local-path argument of a 'put' command. */
      for (j = 0; j < 3; j++)
        {
          if (action->relpath[j]
              && ! (action->action == ACTION_PUT_FILE && j == 0))
            {
              const char *rrpath, *parent_rrpath;

              arg[j] = apr_palloc(iterpool, sizeof(*arg[j]));

              rrpath = svn_relpath_join(base_relpath, action->relpath[j], iterpool);
              parent_rrpath = svn_relpath_dirname(rrpath, iterpool);

              arg[j]->path_name = svn_relpath_basename(rrpath, NULL);
              SVN_ERR(find_el_rev_by_rrpath_rev(&arg[j]->el_rev, wc,
                                                &action->rev_spec[j],
                                                action->branch_id[j],
                                                rrpath,
                                                iterpool, iterpool));
              SVN_ERR(find_el_rev_by_rrpath_rev(&arg[j]->parent_el_rev, wc,
                                                &action->rev_spec[j],
                                                action->branch_id[j],
                                                parent_rrpath,
                                                iterpool, iterpool));
            }
        }

      switch (action->action)
        {
        case ACTION_INFO_WC:
          {
            svn_boolean_t is_modified;
            svn_revnum_t base_rev_min, base_rev_max;

            SVN_ERR(txn_is_changed(wc->working->branch->txn, &is_modified,
                                   iterpool));
            SVN_ERR(svnmover_wc_get_base_revs(wc, &base_rev_min, &base_rev_max,
                                              iterpool));

            svnmover_notify("Repository Root: %s", wc->repos_root_url);
            if (base_rev_min == base_rev_max)
              svnmover_notify("Base Revision: %ld", base_rev_min);
            else
              svnmover_notify("Base Revisions: %ld to %ld",
                              base_rev_min, base_rev_max);
            svnmover_notify("Base Branch:    %s", wc->base->branch->bid);
            svnmover_notify("Working Branch: %s", wc->working->branch->bid);
            SVN_ERR(show_branch_history(wc->working->branch, iterpool));
            svnmover_notify("Modified:       %s", is_modified ? "yes" : "no");
          }
          break;

        case ACTION_INFO:
          VERIFY_EID_EXISTS("info", 0);
          {
            /* If it's a nested branch root, show info for the outer element
               first, and then for the inner element. */
            if (is_branch_root_element(arg[0]->el_rev->branch,
                                       arg[0]->el_rev->eid))
              {
                svn_branch__state_t *outer_branch;
                int outer_eid;

                svn_branch__get_outer_branch_and_eid(&outer_branch, &outer_eid,
                                                     arg[0]->el_rev->branch,
                                                     iterpool);
                if (outer_branch)
                  {
                    svn_branch__el_rev_id_t *outer_e
                      = svn_branch__el_rev_id_create(outer_branch, outer_eid,
                                                     arg[0]->el_rev->rev,
                                                     iterpool);
                    SVN_ERR(do_info(wc, outer_e, iterpool));
                  }
              }
            SVN_ERR(do_info(wc, arg[0]->el_rev, iterpool));
          }
          break;

        case ACTION_LIST_CONFLICTS:
          {
            if (svnmover_any_conflicts(wc->conflicts))
              {
                SVN_ERR(svnmover_display_conflicts(wc->conflicts, iterpool));
              }
          }
          break;

        case ACTION_RESOLVED_CONFLICT:
          {
            if (svnmover_any_conflicts(wc->conflicts))
              {
                SVN_ERR(svnmover_conflict_resolved(wc->conflicts,
                                                   action->relpath[0],
                                                   iterpool));
              }
            else
              {
                return svn_error_create(SVN_BRANCH__ERR, NULL,
                                        _("No conflicts are currently flagged"));
              }
          }
          break;

        case ACTION_DIFF:
          VERIFY_EID_EXISTS("diff", 0);
          VERIFY_EID_EXISTS("diff", 1);
          {
            SVN_ERR(branch_diff_r(arg[0]->el_rev /*from*/,
                                  arg[1]->el_rev /*to*/,
                                  show_subtree_diff, "",
                                  iterpool));
          }
          break;

        case ACTION_STATUS:
          {
            svn_branch__el_rev_id_t *from, *to;

            from = svn_branch__el_rev_id_create(wc->base->branch,
                                                svn_branch__root_eid(wc->base->branch),
                                                SVN_INVALID_REVNUM, iterpool);
            to = svn_branch__el_rev_id_create(wc->working->branch,
                                              svn_branch__root_eid(wc->working->branch),
                                              SVN_INVALID_REVNUM, iterpool);
            SVN_ERR(branch_diff_r(from, to,
                                  show_subtree_diff, "",
                                  iterpool));
          }
          break;

        case ACTION_LOG:
          VERIFY_EID_EXISTS("log", 0);
          VERIFY_EID_EXISTS("log", 1);
          {
            SVN_ERR(do_log(arg[0]->el_rev /*from*/,
                           arg[1]->el_rev /*to*/,
                           iterpool));
            }
          break;

        case ACTION_LIST_BRANCHES:
          {
            VERIFY_EID_EXISTS("branches", 0);
            if (the_ui_mode == UI_MODE_PATHS)
              {
                svnmover_notify_v("branches rooted at same element as '%s':",
                                  action->relpath[0]);
              }
            else
              {
                svnmover_notify_v("branches rooted at e%d:",
                                  arg[0]->el_rev->eid);
              }
            SVN_ERR(list_branches(
                      arg[0]->el_rev->branch->txn,
                      arg[0]->el_rev->eid,
                      FALSE, iterpool));
          }
          break;

        case ACTION_LIST_BRANCHES_R:
          {
            if (the_ui_mode == UI_MODE_SERIAL)
              {
                svn_stream_t *stream;
                SVN_ERR(svn_stream_for_stdout(&stream, iterpool));
                SVN_ERR(svn_branch__txn_serialize(wc->working->branch->txn,
                          stream,
                          iterpool));
              }
            else
              {
                /* Note: BASE_REVISION is always a real revision number, here */
                SVN_ERR(list_all_branches(wc->working->branch->txn, TRUE,
                                          iterpool));
              }
          }
          break;

        case ACTION_LS:
          {
            VERIFY_EID_EXISTS("ls", 0);
            if (the_ui_mode == UI_MODE_PATHS)
              {
                SVN_ERR(list_branch_elements(arg[0]->el_rev->branch, iterpool));
              }
            else if (the_ui_mode == UI_MODE_EIDS)
              {
                SVN_ERR(list_branch_elements_by_eid(arg[0]->el_rev->branch,
                                                    iterpool));
              }
            else
              {
                svn_stream_t *stream;
                SVN_ERR(svn_stream_for_stdout(&stream, iterpool));
                SVN_ERR(svn_branch__state_serialize(stream,
                                                    arg[0]->el_rev->branch,
                                                    iterpool));
              }
          }
          break;

        case ACTION_TBRANCH:
          VERIFY_EID_EXISTS("tbranch", 0);
          {
            const char *from_branch_id = svn_branch__get_id(arg[0]->el_rev->branch,
                                                            iterpool);
            svn_branch__rev_bid_eid_t *from
              = svn_branch__rev_bid_eid_create(arg[0]->el_rev->rev, from_branch_id,
                                               arg[0]->el_rev->eid, iterpool);
            svn_branch__state_t *new_branch;

            SVN_ERR(do_topbranch(&new_branch, wc->edit_txn,
                                 from,
                                 iterpool, iterpool));
            /* Switch the WC working state to this new branch */
            wc->working->branch = new_branch;
          }
          break;

        case ACTION_BRANCH:
          VERIFY_EID_EXISTS("branch", 0);
          VERIFY_REV_UNSPECIFIED("branch", 1);
          VERIFY_EID_NONEXISTENT("branch", 1);
          VERIFY_PARENT_EID_EXISTS("branch", 1);
          {
            const char *from_branch_id = svn_branch__get_id(arg[0]->el_rev->branch,
                                                            iterpool);
            svn_branch__rev_bid_eid_t *from
              = svn_branch__rev_bid_eid_create(arg[0]->el_rev->rev, from_branch_id,
                                               arg[0]->el_rev->eid, iterpool);
            svn_branch__state_t *new_branch;

            SVN_ERR(do_branch(&new_branch, wc->edit_txn,
                              from,
                              arg[1]->el_rev->branch, arg[1]->parent_el_rev->eid,
                              arg[1]->path_name,
                              iterpool, iterpool));
          }
          break;

        case ACTION_BRANCH_INTO:
          VERIFY_EID_EXISTS("branch-into", 0);
          VERIFY_REV_UNSPECIFIED("branch-into", 1);
          VERIFY_EID_NONEXISTENT("branch-into", 1);
          VERIFY_PARENT_EID_EXISTS("branch-into", 1);
          {
            SVN_ERR(do_branch_into(arg[0]->el_rev->branch, arg[0]->el_rev->eid,
                                   arg[1]->el_rev->branch,
                                   arg[1]->parent_el_rev->eid, arg[1]->path_name,
                                   iterpool));
          }
          break;

        case ACTION_MKBRANCH:
          VERIFY_REV_UNSPECIFIED("mkbranch", 0);
          VERIFY_EID_NONEXISTENT("mkbranch", 0);
          VERIFY_PARENT_EID_EXISTS("mkbranch", 0);
          {
            apr_hash_t *props = apr_hash_make(iterpool);
            svn_element__payload_t *payload
              = svn_element__payload_create_dir(props, iterpool);

            SVN_ERR(do_mkbranch(NULL, wc->edit_txn,
                                arg[0]->parent_el_rev->branch,
                                arg[0]->parent_el_rev->eid, arg[0]->path_name,
                                payload, iterpool));
          }
          break;

        case ACTION_MERGE3:
          {
            VERIFY_EID_EXISTS("merge", 0);
            VERIFY_EID_EXISTS("merge", 1);
            VERIFY_REV_UNSPECIFIED("merge", 1);
            VERIFY_EID_EXISTS("merge", 2);

            SVN_ERR(do_merge(wc,
                             arg[0]->el_rev /*from*/,
                             arg[1]->el_rev /*to*/,
                             arg[2]->el_rev /*yca*/,
                             iterpool));
          }
          break;

        case ACTION_AUTO_MERGE:
          {
            VERIFY_EID_EXISTS("merge", 0);
            VERIFY_EID_EXISTS("merge", 1);
            VERIFY_REV_UNSPECIFIED("merge", 1);

            SVN_ERR(do_auto_merge(wc,
                                  arg[0]->el_rev /*from*/,
                                  arg[1]->el_rev /*to*/,
                                  iterpool));
          }
          break;

        case ACTION_MV:
          SVN_ERR(point_to_outer_element_instead(arg[0]->el_rev, "mv",
                                                 iterpool));

          VERIFY_REV_UNSPECIFIED("mv", 0);
          VERIFY_EID_EXISTS("mv", 0);
          VERIFY_REV_UNSPECIFIED("mv", 1);
          VERIFY_EID_NONEXISTENT("mv", 1);
          VERIFY_PARENT_EID_EXISTS("mv", 1);
          VERIFY_NOT_CHILD_OF_SELF("mv", 0, 1, iterpool);

          /* Simple move/rename within same branch, if possible */
          if (BRANCH_IS_SAME_BRANCH(arg[1]->parent_el_rev->branch,
                                    arg[0]->el_rev->branch,
                                    iterpool))
            {
              SVN_ERR(do_move(arg[0]->el_rev,
                              arg[1]->parent_el_rev, arg[1]->path_name,
                              iterpool));
            }
          else
            {
              SVN_ERR(do_interactive_cross_branch_move(wc->edit_txn,
                                                       arg[0]->el_rev,
                                                       arg[1]->parent_el_rev,
                                                       arg[1]->path_name,
                                                       iterpool));
            }
          break;

        case ACTION_CP:
          VERIFY_REV_SPECIFIED("cp", 0);
            /* (Or do we want to support copying from "this txn" too?) */
          VERIFY_EID_EXISTS("cp", 0);
          VERIFY_REV_UNSPECIFIED("cp", 1);
          VERIFY_EID_NONEXISTENT("cp", 1);
          VERIFY_PARENT_EID_EXISTS("cp", 1);
          SVN_ERR(do_copy(arg[0]->el_rev,
                          arg[1]->parent_el_rev->branch,
                          arg[1]->parent_el_rev->eid, arg[1]->path_name,
                          iterpool));
          break;

        case ACTION_RM:
          SVN_ERR(point_to_outer_element_instead(arg[0]->el_rev, "rm",
                                                 iterpool));

          VERIFY_REV_UNSPECIFIED("rm", 0);
          VERIFY_EID_EXISTS("rm", 0);
          SVN_ERR(do_delete(arg[0]->el_rev->branch, arg[0]->el_rev->eid,
                            iterpool));
          break;

        case ACTION_CP_RM:
          SVN_ERR(point_to_outer_element_instead(arg[0]->el_rev,
                                                 "copy-and-delete", iterpool));

          VERIFY_REV_UNSPECIFIED("copy-and-delete", 0);
          VERIFY_EID_EXISTS("copy-and-delete", 0);
          VERIFY_REV_UNSPECIFIED("copy-and-delete", 1);
          VERIFY_EID_NONEXISTENT("copy-and-delete", 1);
          VERIFY_PARENT_EID_EXISTS("copy-and-delete", 1);
          VERIFY_NOT_CHILD_OF_SELF("copy-and-delete", 0, 1, iterpool);

          SVN_ERR(do_copy_and_delete(arg[0]->el_rev,
                                     arg[1]->parent_el_rev->branch,
                                     arg[1]->parent_el_rev->eid,
                                     arg[1]->path_name,
                                     iterpool));
          break;

        case ACTION_BR_RM:
          SVN_ERR(point_to_outer_element_instead(arg[0]->el_rev,
                                                 "branch-and-delete",
                                                 iterpool));

          VERIFY_REV_UNSPECIFIED("branch-and-delete", 0);
          VERIFY_EID_EXISTS("branch-and-delete", 0);
          VERIFY_REV_UNSPECIFIED("branch-and-delete", 1);
          VERIFY_EID_NONEXISTENT("branch-and-delete", 1);
          VERIFY_PARENT_EID_EXISTS("branch-and-delete", 1);
          VERIFY_NOT_CHILD_OF_SELF("branch-and-delete", 0, 1, iterpool);

          SVN_ERR(do_branch_and_delete(wc->edit_txn,
                                       arg[0]->el_rev,
                                       arg[1]->parent_el_rev->branch,
                                       arg[1]->parent_el_rev->eid,
                                       arg[1]->path_name,
                                       iterpool));
          break;

        case ACTION_BR_INTO_RM:
          SVN_ERR(point_to_outer_element_instead(arg[0]->el_rev,
                                                 "branch-into-and-delete",
                                                 iterpool));

          VERIFY_REV_UNSPECIFIED("branch-into-and-delete", 0);
          VERIFY_EID_EXISTS("branch-into-and-delete", 0);
          VERIFY_REV_UNSPECIFIED("branch-into-and-delete", 1);
          VERIFY_EID_NONEXISTENT("branch-into-and-delete", 1);
          VERIFY_PARENT_EID_EXISTS("branch-into-and-delete", 1);
          VERIFY_NOT_CHILD_OF_SELF("branch-into-and-delete", 0, 1, iterpool);

          SVN_ERR(do_branch_into_and_delete(arg[0]->el_rev,
                                            arg[1]->parent_el_rev->branch,
                                            arg[1]->parent_el_rev->eid,
                                            arg[1]->path_name,
                                            iterpool));
          break;

        case ACTION_MKDIR:
          VERIFY_REV_UNSPECIFIED("mkdir", 0);
          VERIFY_EID_NONEXISTENT("mkdir", 0);
          VERIFY_PARENT_EID_EXISTS("mkdir", 0);
          SVN_ERR(do_mkdir(wc->edit_txn,
                           arg[0]->parent_el_rev->branch,
                           arg[0]->parent_el_rev->eid, arg[0]->path_name,
                           iterpool));
          break;

        case ACTION_PUT_FILE:
          VERIFY_REV_UNSPECIFIED("put", 1);
          VERIFY_PARENT_EID_EXISTS("put", 1);
          SVN_ERR(do_put_file(wc->edit_txn,
                              action->relpath[0],
                              arg[1]->el_rev,
                              arg[1]->parent_el_rev,
                              arg[1]->path_name,
                              iterpool));
          break;

        case ACTION_CAT:
          VERIFY_EID_EXISTS("rm", 0);
          SVN_ERR(do_cat(arg[0]->el_rev,
                         iterpool));
          break;

        case ACTION_COMMIT:
          {
            svn_revnum_t new_rev;

            SVN_ERR(do_commit(&new_rev, wc, revprops, iterpool));
            if (! SVN_IS_VALID_REVNUM(new_rev))
              {
                svnmover_notify_v("There are no changes to commit.");
              }
          }
          break;

        case ACTION_UPDATE:
          /* ### If current WC branch doesn't exist in target rev, should
             'update' follow to a different branch? By following merge graph?
             Presently it would try to update to a state of nonexistence. */
          /* path (or eid) is currently required for syntax, but ignored */
          VERIFY_EID_EXISTS("update", 0);
          /* We require a rev to be specified because an unspecified rev
             currently always means 'working version', whereas we would
             want it to mean 'head' for this subcommand. */
          VERIFY_REV_SPECIFIED("update", 0);
          {
            SVN_ERR(do_switch(wc, arg[0]->el_rev->rev, wc->base->branch,
                              iterpool));
          }
          break;

        case ACTION_SWITCH:
          VERIFY_EID_EXISTS("switch", 0);
          {
            SVN_ERR(do_switch(wc, arg[0]->el_rev->rev, arg[0]->el_rev->branch,
                              iterpool));
          }
          break;

        case ACTION_REVERT:
          {
            SVN_ERR(do_revert(wc, iterpool));
          }
          break;

        case ACTION_MIGRATE:
          /* path (or eid) is currently required for syntax, but ignored */
          VERIFY_EID_EXISTS("migrate", 0);
          VERIFY_REV_SPECIFIED("migrate", 0);
          {
            SVN_ERR(do_migrate(wc,
                               arg[0]->el_rev->rev, arg[0]->el_rev->rev,
                               iterpool));
          }
          break;

        default:
          SVN_ERR_MALFUNCTION();
        }

      if (action->action != ACTION_COMMIT)
        {
          wc->list_of_commands
            = apr_psprintf(pool, "%s%s\n",
                           wc->list_of_commands ? wc->list_of_commands : "",
                           svn_cstring_join2(action->action_args, " ",
                                             TRUE, pool));
        }
    }
  svn_pool_destroy(iterpool);
  return SVN_NO_ERROR;
}

/* Perform the typical suite of manipulations for user-provided URLs
   on URL, returning the result (allocated from POOL): IRI-to-URI
   conversion, auto-escaping, and canonicalization. */
static const char *
sanitize_url(const char *url,
             apr_pool_t *pool)
{
  url = svn_path_uri_from_iri(url, pool);
  url = svn_path_uri_autoescape(url, pool);
  return svn_uri_canonicalize(url, pool);
}

static const char *
help_for_subcommand(const action_defn_t *action, apr_pool_t *pool)
{
  const char *cmd = apr_psprintf(pool, "%s %s",
                                 action->name, action->args_help);

  return apr_psprintf(pool, "  %-22s : %s\n", cmd, action->help);
}

/* Print a usage message on STREAM, listing only the actions. */
static void
usage_actions_only(FILE *stream, apr_pool_t *pool)
{
  int i;

  for (i = 0; i < sizeof (action_defn) / sizeof (action_defn[0]); i++)
    svn_error_clear(svn_cmdline_fputs(
                      help_for_subcommand(&action_defn[i], pool),
                      stream, pool));
}

/* Print a usage message on STREAM. */
static void
usage(FILE *stream, apr_pool_t *pool)
{
  svn_error_clear(svn_cmdline_fputs(
    _("usage: svnmover -U REPO_URL [ACTION...]\n"
      "A client for experimenting with move tracking.\n"
      "\n"
      "  Commit a batch of ACTIONs to a Subversion repository, as a single\n"
      "  new revision.  With no ACTIONs specified, read actions interactively\n"
      "  from standard input, until EOF or ^C, and then commit the result.\n"
      "\n"
      "  Action arguments are of the form\n"
      "    [^B<branch-id>/]<path>[@<revnum>]\n"
      "  where\n"
      "    <branch-id> defaults to the working branch or, when <revnum> is\n"
      "                given, to the base branch\n"
      "    <path>      is a path relative to the branch\n"
      "    <revnum>    is the revision number, when making a historic reference\n"
      "\n"
      "  Move tracking metadata is stored in the repository, in on-disk files\n"
      "  for RA-local or in revprops otherwise.\n"
      "\n"
      "Actions:\n"),
                  stream, pool));
  usage_actions_only(stream, pool);
  svn_error_clear(svn_cmdline_fputs(
    _("\n"
      "Valid options:\n"
      "  --ui={eids|e|paths|p}  : display information as elements or as paths\n"
      "  --colo[u]r={always|never|auto}\n"
      "                         : use coloured output; 'auto' means when standard\n"
      "                           output goes to a terminal; default: never\n"
      "  -h, -? [--help]        : display this text\n"
      "  -v [--verbose]         : display debugging messages\n"
      "  -q [--quiet]           : suppress notifications\n"
      "  -m [--message] ARG     : use ARG as a log message\n"
      "  -F [--file] ARG        : read log message from file ARG\n"
      "  -u [--username] ARG    : commit the changes as username ARG\n"
      "  -p [--password] ARG    : use ARG as the password\n"
      "  -U [--root-url] ARG    : interpret all action URLs relative to ARG\n"
      "  -r [--revision] ARG    : use revision ARG as baseline for changes\n"
      "  -B [--branch-id] ARG   : work on the branch identified by ARG\n"
      "  --with-revprop ARG     : set revision property in the following format:\n"
      "                               NAME[=VALUE]\n"
      "  --non-interactive      : do no interactive prompting (default is to\n"
      "                           prompt only if standard input is a terminal)\n"
      "  --force-interactive    : do interactive prompting even if standard\n"
      "                           input is not a terminal\n"
      "  --trust-server-cert    : accept SSL server certificates from unknown\n"
      "                           certificate authorities without prompting (but\n"
      "                           only with '--non-interactive')\n"
      "  -X [--extra-args] ARG  : append arguments from file ARG (one per line;\n"
      "                           use \"-\" to read from standard input)\n"
      "  --config-dir ARG       : use ARG to override the config directory\n"
      "  --config-option ARG    : use ARG to override a configuration option\n"
      "  --no-auth-cache        : do not cache authentication tokens\n"
      "  --version              : print version information\n"),
                  stream, pool));
}

static svn_error_t *
insufficient(int i, apr_pool_t *pool)
{
  return svn_error_createf(SVN_ERR_INCORRECT_PARAMS, NULL,
                           "insufficient arguments:\n"
                           "%s",
                           help_for_subcommand(&action_defn[i], pool));
}

static svn_error_t *
display_version(apr_getopt_t *os, svn_boolean_t _quiet, apr_pool_t *pool)
{
  const char *ra_desc_start
    = "The following repository access (RA) modules are available:\n\n";
  svn_stringbuf_t *version_footer;

  version_footer = svn_stringbuf_create(ra_desc_start, pool);
  SVN_ERR(svn_ra_print_modules(version_footer, pool));

  SVN_ERR(svn_opt_print_help5(NULL, "svnmover", TRUE, _quiet, FALSE,
                              version_footer->data,
                              NULL, NULL, NULL, NULL, NULL, pool));

  return SVN_NO_ERROR;
}

/* Return an error about the mutual exclusivity of the -m, -F, and
   --with-revprop=svn:log command-line options. */
static svn_error_t *
mutually_exclusive_logs_error(void)
{
  return svn_error_create(SVN_ERR_CL_ARG_PARSING_ERROR, NULL,
                          _("--message (-m), --file (-F), and "
                            "--with-revprop=svn:log are mutually "
                            "exclusive"));
}

/* Obtain the log message from multiple sources, producing an error
   if there are multiple sources. Store the result in *FINAL_MESSAGE.  */
static svn_error_t *
get_log_message(const char **final_message,
                const char *message,
                apr_hash_t *revprops,
                svn_stringbuf_t *filedata,
                apr_pool_t *result_pool,
                apr_pool_t *scratch_pool)
{
  svn_string_t *msg;

  *final_message = NULL;
  /* If we already have a log message in the revprop hash, then just
     make sure the user didn't try to also use -m or -F.  Otherwise,
     we need to consult -m or -F to find a log message, if any. */
  msg = svn_hash_gets(revprops, SVN_PROP_REVISION_LOG);
  if (msg)
    {
      if (filedata || message)
        return mutually_exclusive_logs_error();

      /* Remove it from the revprops; it will be re-added later */
      svn_hash_sets(revprops, SVN_PROP_REVISION_LOG, NULL);
    }
  else if (filedata)
    {
      if (message)
        return mutually_exclusive_logs_error();

      msg = svn_string_create(filedata->data, scratch_pool);
    }
  else if (message)
    {
      msg = svn_string_create(message, scratch_pool);
    }

  if (msg)
    {
      SVN_ERR_W(svn_subst_translate_string2(&msg, NULL, NULL,
                                            msg, NULL, FALSE,
                                            result_pool, scratch_pool),
                _("Error normalizing log message to internal format"));

      *final_message = msg->data;
    }

  return SVN_NO_ERROR;
}

static const char *const special_commands[] =
{
  "help",
  "--verbose",
  "--ui=paths", "--ui=eids", "--ui=serial",
};

/* Parse the action arguments into action structures. */
static svn_error_t *
parse_actions(apr_array_header_t **actions,
              apr_array_header_t *action_args,
              apr_pool_t *pool)
{
  int i;

  *actions = apr_array_make(pool, 1, sizeof(action_t *));

  for (i = 0; i < action_args->nelts; ++i)
    {
      int j, k, num_url_args;
      const char *action_string = APR_ARRAY_IDX(action_args, i, const char *);
      action_t *action = apr_pcalloc(pool, sizeof(*action));
      const char *cp_from_rev = NULL;

      /* First, parse the action. Handle some special actions immediately;
         handle normal subcommands by looking them up in the table. */
      if (! strcmp(action_string, "?") || ! strcmp(action_string, "h")
          || ! strcmp(action_string, "help"))
        {
          usage_actions_only(stdout, pool);
          return SVN_NO_ERROR;
        }
      if (! strncmp(action_string, "--ui=", 5))
        {
          SVN_ERR(svn_token__from_word_err(&the_ui_mode, ui_mode_map,
                                           action_string + 5));
          continue;
        }
      if (! strcmp(action_string, "--verbose")
          || ! strcmp(action_string, "-v"))
        {
          quiet = !quiet;
          svnmover_notify("verbose mode %s", quiet ? "off" : "on");
          continue;
        }
      for (j = 0; j < sizeof(action_defn) / sizeof(action_defn[0]); j++)
        {
          if (strcmp(action_string, action_defn[j].name) == 0)
            {
              action->action = action_defn[j].code;
              num_url_args = action_defn[j].num_args;
              break;
            }
        }
      if (j == sizeof(action_defn) / sizeof(action_defn[0]))
        return svn_error_createf(SVN_ERR_INCORRECT_PARAMS, NULL,
                                 "'%s' is not an action; try 'help'.",
                                 action_string);

      action->action_args = apr_array_make(pool, 0, sizeof(const char *));
      APR_ARRAY_PUSH(action->action_args, const char *) = action_string;

      if (action->action == ACTION_CP)
        {
          /* next argument is the copy source revision */
          if (++i == action_args->nelts)
            return svn_error_trace(insufficient(j, pool));
          cp_from_rev = APR_ARRAY_IDX(action_args, i, const char *);
          APR_ARRAY_PUSH(action->action_args, const char *) = cp_from_rev;
        }

      /* Parse the required number of URLs. */
      for (k = 0; k < num_url_args; ++k)
        {
          const char *path;

          if (++i == action_args->nelts)
            return svn_error_trace(insufficient(j, pool));
          path = APR_ARRAY_IDX(action_args, i, const char *);
          APR_ARRAY_PUSH(action->action_args, const char *) = path;

          if (cp_from_rev && k == 0)
            {
              path = apr_psprintf(pool, "%s@%s", path, cp_from_rev);
            }

          SVN_ERR(svn_opt_parse_path(&action->rev_spec[k], &path, path, pool));

          /* If there's an ANCHOR_URL, we expect URL to be a path
             relative to ANCHOR_URL (and we build a full url from the
             combination of the two).  Otherwise, it should be a full
             url. */
          if (svn_path_is_url(path))
            {
              return svn_error_createf(SVN_ERR_INCORRECT_PARAMS, NULL,
                                       "Argument '%s' is a URL; use "
                                       "--root-url (-U) instead", path);
            }
          /* Parse "^B<branch-id>/path" syntax. */
          if (strncmp("^B", path, 2) == 0)
            {
              const char *slash = strchr(path, '/');

              action->branch_id[k]
                = slash ? apr_pstrndup(pool, path + 1, slash - (path + 1))
                        : path + 1;
              path = slash ? slash + 1 : "";
            }
          /* These args must be relpaths, except for the 'local file' arg
             of a 'put' command. */
          if (! svn_relpath_is_canonical(path)
              && ! (action->action == ACTION_PUT_FILE && k == 0))
            {
              return svn_error_createf(SVN_ERR_INCORRECT_PARAMS, NULL,
                                       "Argument '%s' is not a relative path "
                                       "or a URL", path);
            }
          action->relpath[k] = path;
        }

      APR_ARRAY_PUSH(*actions, action_t *) = action;
    }

  return SVN_NO_ERROR;
}

#ifdef HAVE_LINENOISE
/* A command-line completion callback for the 'Line Noise' interactive
 * prompting.
 *
 * This is called when the user presses the Tab key. It calculates the
 * possible completions for the partial line BUF.
 *
 * ### So far, this only works on a single command keyword at the start
 *     of the line.
 */
static void
linenoise_completion(const char *buf, linenoiseCompletions *lc)
{
  int i;

  for (i = 0; i < sizeof(special_commands) / sizeof(special_commands[0]); i++)
    {
      /* Suggest each command that matches (and is longer than) what the
         user has already typed. Add a space. */
      if (strncmp(buf, special_commands[i], strlen(buf)) == 0
          && strlen(special_commands[i]) > strlen(buf))
        {
          static char completion[100];

          apr_cpystrn(completion, special_commands[i], 99);
          strcat(completion, " ");
          linenoiseAddCompletion(lc, completion);
        }
    }

  for (i = 0; i < sizeof(action_defn) / sizeof(action_defn[0]); i++)
    {
      /* Suggest each command that matches (and is longer than) what the
         user has already typed. Add a space. */
      if (strncmp(buf, action_defn[i].name, strlen(buf)) == 0
          && strlen(action_defn[i].name) > strlen(buf))
        {
          static char completion[100];

          apr_cpystrn(completion, action_defn[i].name, 99);
          strcat(completion, " ");
          linenoiseAddCompletion(lc, completion);
        }
    }
}
#endif

/* Display a prompt, read a line of input and split it into words.
 *
 * Set *WORDS to null if input is cancelled (by ctrl-C for example).
 */
static svn_error_t *
read_words(apr_array_header_t **words,
           const char *prompt,
           apr_pool_t *result_pool)
{
  svn_error_t *err;
  const char *input;

  settext(TEXT_FG_YELLOW);
  err = svnmover_prompt_user(&input, prompt, result_pool);
  settext(TEXT_RESET);
  if (err && (err->apr_err == SVN_ERR_CANCELLED || err->apr_err == APR_EOF))
    {
      *words = NULL;
      svn_error_clear(err);
      return SVN_NO_ERROR;
    }
  SVN_ERR(err);
  *words = svn_cstring_split(input, " ", TRUE /*chop_whitespace*/, result_pool);

  return SVN_NO_ERROR;
}

/*
 * On success, leave *EXIT_CODE untouched and return SVN_NO_ERROR. On error,
 * either return an error to be displayed, or set *EXIT_CODE to non-zero and
 * return SVN_NO_ERROR.
 */
static svn_error_t *
sub_main(int *exit_code, int argc, const char *argv[], apr_pool_t *pool)
{
  apr_array_header_t *actions;
  svn_error_t *err = SVN_NO_ERROR;
  apr_getopt_t *opts;
  enum {
    config_dir_opt = SVN_OPT_FIRST_LONGOPT_ID,
    config_inline_opt,
    no_auth_cache_opt,
    version_opt,
    with_revprop_opt,
    non_interactive_opt,
    force_interactive_opt,
    trust_server_cert_opt,
    trust_server_cert_failures_opt,
    ui_opt,
    colour_opt,
    auth_password_from_stdin_opt
  };
  static const apr_getopt_option_t options[] = {
    {"verbose", 'v', 0, ""},
    {"quiet", 'q', 0, ""},
    {"message", 'm', 1, ""},
    {"file", 'F', 1, ""},
    {"username", 'u', 1, ""},
    {"password", 'p', 1, ""},
    {"password-from-stdin", auth_password_from_stdin_opt, 1, ""},
    {"root-url", 'U', 1, ""},
    {"revision", 'r', 1, ""},
    {"branch-id", 'B', 1, ""},
    {"with-revprop",  with_revprop_opt, 1, ""},
    {"extra-args", 'X', 1, ""},
    {"help", 'h', 0, ""},
    {NULL, '?', 0, ""},
    {"non-interactive", non_interactive_opt, 0, ""},
    {"force-interactive", force_interactive_opt, 0, ""},
    {"trust-server-cert", trust_server_cert_opt, 0, ""},
    {"trust-server-cert-failures", trust_server_cert_failures_opt, 1, ""},
    {"config-dir", config_dir_opt, 1, ""},
    {"config-option",  config_inline_opt, 1, ""},
    {"no-auth-cache",  no_auth_cache_opt, 0, ""},
    {"version", version_opt, 0, ""},
    {"ui", ui_opt, 1, ""},
    {"colour", colour_opt, 1, ""},
    {"color", colour_opt, 1, ""},
    {NULL, 0, 0, NULL}
  };
  const char *message = NULL;
  svn_stringbuf_t *filedata = NULL;
  const char *username = NULL, *password = NULL;
  const char *anchor_url = NULL, *extra_args_file = NULL;
  const char *config_dir = NULL;
  apr_array_header_t *config_options;
  svn_boolean_t show_version = FALSE;
  svn_boolean_t non_interactive = FALSE;
  svn_boolean_t force_interactive = FALSE;
  svn_boolean_t interactive_actions;
  svn_boolean_t trust_unknown_ca = FALSE;
  svn_boolean_t trust_cn_mismatch = FALSE;
  svn_boolean_t trust_expired = FALSE;
  svn_boolean_t trust_not_yet_valid = FALSE;
  svn_boolean_t trust_other_failure = FALSE;
  svn_boolean_t no_auth_cache = FALSE;
  svn_revnum_t base_revision = SVN_INVALID_REVNUM;
  const char *branch_id = "B0";  /* default branch */
  apr_array_header_t *action_args;
  apr_hash_t *revprops = apr_hash_make(pool);
  apr_hash_t *cfg_hash;
  svn_config_t *cfg_config;
  svn_client_ctx_t *ctx;
  const char *log_msg;
  svn_tristate_t coloured_output = svn_tristate_false;
  svnmover_wc_t *wc;
  svn_boolean_t read_pass_from_stdin = FALSE;

  /* Check library versions */
  SVN_ERR(check_lib_versions());

  config_options = apr_array_make(pool, 0,
                                  sizeof(svn_cmdline__config_argument_t*));

  apr_getopt_init(&opts, pool, argc, argv);
  opts->interleave = 1;
  while (1)
    {
      int opt;
      const char *arg;
      const char *opt_arg;

      apr_status_t status = apr_getopt_long(opts, options, &opt, &arg);
      if (APR_STATUS_IS_EOF(status))
        break;
      if (status != APR_SUCCESS)
        return svn_error_wrap_apr(status, "getopt failure");
      switch(opt)
        {
        case 'v':
          quiet = FALSE;
          break;
        case 'q':
          quiet = TRUE;
          break;
        case 'm':
          SVN_ERR(svn_utf_cstring_to_utf8(&message, arg, pool));
          break;
        case 'F':
          {
            const char *filename;
            SVN_ERR(svn_utf_cstring_to_utf8(&filename, arg, pool));
            SVN_ERR(svn_stringbuf_from_file2(&filedata, filename, pool));
          }
          break;
        case 'u':
          username = apr_pstrdup(pool, arg);
          break;
        case 'p':
          password = apr_pstrdup(pool, arg);
          break;
        case auth_password_from_stdin_opt:
          read_pass_from_stdin = TRUE;
          break;
        case 'U':
          SVN_ERR(svn_utf_cstring_to_utf8(&anchor_url, arg, pool));
          if (! svn_path_is_url(anchor_url))
            return svn_error_createf(SVN_ERR_INCORRECT_PARAMS, NULL,
                                     "'%s' is not a URL", anchor_url);
          anchor_url = sanitize_url(anchor_url, pool);
          break;
        case 'r':
          {
            const char *saved_arg = arg;
            char *digits_end = NULL;
            while (*arg == 'r')
              arg++;
            base_revision = strtol(arg, &digits_end, 10);
            if ((! SVN_IS_VALID_REVNUM(base_revision))
                || (! digits_end)
                || *digits_end)
              return svn_error_createf(SVN_ERR_CL_ARG_PARSING_ERROR, NULL,
                                       _("Invalid revision number '%s'"),
                                       saved_arg);
          }
          break;
        case 'B':
          branch_id = (arg[0] == 'B') ? apr_pstrdup(pool, arg)
                                      : apr_psprintf(pool, "B%s", arg);
          break;
        case with_revprop_opt:
          SVN_ERR(svn_opt_parse_revprop(&revprops, arg, pool));
          break;
        case 'X':
          SVN_ERR(svn_utf_cstring_to_utf8(&extra_args_file, arg, pool));
          break;
        case non_interactive_opt:
          non_interactive = TRUE;
          break;
        case force_interactive_opt:
          force_interactive = TRUE;
          break;
        case trust_server_cert_opt:
          trust_unknown_ca = TRUE;
          break;
        case trust_server_cert_failures_opt:
          SVN_ERR(svn_utf_cstring_to_utf8(&opt_arg, arg, pool));
          SVN_ERR(svn_cmdline__parse_trust_options(
                      &trust_unknown_ca,
                      &trust_cn_mismatch,
                      &trust_expired,
                      &trust_not_yet_valid,
                      &trust_other_failure,
                      opt_arg, pool));
          break;
        case config_dir_opt:
          SVN_ERR(svn_utf_cstring_to_utf8(&config_dir, arg, pool));
          break;
        case config_inline_opt:
          SVN_ERR(svn_utf_cstring_to_utf8(&opt_arg, arg, pool));
          SVN_ERR(svn_cmdline__parse_config_option(config_options, opt_arg,
                                                   "svnmover: ", pool));
          break;
        case no_auth_cache_opt:
          no_auth_cache = TRUE;
          break;
        case version_opt:
          show_version = TRUE;
          break;
        case ui_opt:
          SVN_ERR(svn_utf_cstring_to_utf8(&opt_arg, arg, pool));
          SVN_ERR(svn_token__from_word_err(&the_ui_mode, ui_mode_map, opt_arg));
          break;
        case colour_opt:
          if (strcmp(arg, "always") == 0)
            coloured_output = svn_tristate_true;
          else if (strcmp(arg, "never") == 0)
            coloured_output = svn_tristate_false;
          else if (strcmp(arg, "auto") == 0)
            coloured_output = svn_tristate_unknown;
          else
            return svn_error_createf(SVN_ERR_CL_ARG_PARSING_ERROR, NULL,
                                     _("Bad argument in '--colour=%s': "
                                       "use one of 'always', 'never', 'auto'"),
                                     arg);
          break;
        case 'h':
        case '?':
          usage(stdout, pool);
          return SVN_NO_ERROR;
        }
    }

  if (show_version)
    {
      SVN_ERR(display_version(opts, quiet, pool));
      return SVN_NO_ERROR;
    }

  if (coloured_output == svn_tristate_true)
    use_coloured_output = TRUE;
  else if (coloured_output == svn_tristate_false)
    use_coloured_output = FALSE;
  else
    use_coloured_output = (svn_cmdline__stdout_is_a_terminal()
                           && svn_cmdline__stderr_is_a_terminal());

  if (non_interactive && force_interactive)
    {
      return svn_error_create(SVN_ERR_CL_ARG_PARSING_ERROR, NULL,
                              _("--non-interactive and --force-interactive "
                                "are mutually exclusive"));
    }
  else
    non_interactive = !svn_cmdline__be_interactive(non_interactive,
                                                   force_interactive);

  if (!non_interactive)
    {
      if (trust_unknown_ca || trust_cn_mismatch || trust_expired
          || trust_not_yet_valid || trust_other_failure)
        return svn_error_create(SVN_ERR_CL_ARG_PARSING_ERROR, NULL,
                                _("--trust-server-cert-failures requires "
                                  "--non-interactive"));
    }

  /* --password-from-stdin can only be used with --non-interactive */
  if (read_pass_from_stdin && !non_interactive)
    {
      return svn_error_create(SVN_ERR_CL_ARG_PARSING_ERROR, NULL,
                              _("--password-from-stdin requires "
                                "--non-interactive"));
    }

  /* Now initialize the client context */

  err = svn_config_get_config(&cfg_hash, config_dir, pool);
  if (err)
    {
      /* Fallback to default config if the config directory isn't readable
         or is not a directory. */
      if (APR_STATUS_IS_EACCES(err->apr_err)
          || SVN__APR_STATUS_IS_ENOTDIR(err->apr_err))
        {
          svn_handle_warning2(stderr, err, "svnmover: ");
          svn_error_clear(err);

          SVN_ERR(svn_config__get_default_config(&cfg_hash, pool));
        }
      else
        return err;
    }

  if (config_options)
    {
      svn_error_clear(
          svn_cmdline__apply_config_options(cfg_hash, config_options,
                                            "svnmover: ", "--config-option"));
    }

  /* Get password from stdin if necessary */
  if (read_pass_from_stdin)
    {
      SVN_ERR(svn_cmdline__stdin_readline(&password, pool, pool));
    }

  SVN_ERR(svn_client_create_context2(&ctx, cfg_hash, pool));

  cfg_config = svn_hash_gets(cfg_hash, SVN_CONFIG_CATEGORY_CONFIG);
  SVN_ERR(svn_cmdline_create_auth_baton2(&ctx->auth_baton,
                                         non_interactive,
                                         username,
                                         password,
                                         config_dir,
                                         no_auth_cache,
                                         trust_unknown_ca,
                                         trust_cn_mismatch,
                                         trust_expired,
                                         trust_not_yet_valid,
                                         trust_other_failure,
                                         cfg_config,
                                         ctx->cancel_func,
                                         ctx->cancel_baton,
                                         pool));

  /* Get the commit log message */
  SVN_ERR(get_log_message(&log_msg, message, revprops, filedata,
                          pool, pool));

  /* Put the log message in the list of revprops, and check that the user
     did not try to supply any other "svn:*" revprops. */
  if (svn_prop_has_svn_prop(revprops, pool))
    return svn_error_create(SVN_ERR_CLIENT_PROPERTY_NAME, NULL,
                            _("Standard properties can't be set "
                              "explicitly as revision properties"));
  if (log_msg)
    {
      svn_hash_sets(revprops, SVN_PROP_REVISION_LOG,
                    svn_string_create(log_msg, pool));
    }

  /* Help command: if given before any actions, then display full help
     (and ANCHOR_URL need not have been provided). */
  if (opts->ind < opts->argc && strcmp(opts->argv[opts->ind], "help") == 0)
    {
      usage(stdout, pool);
      return SVN_NO_ERROR;
    }

  if (!anchor_url)
    return svn_error_createf(SVN_ERR_INCORRECT_PARAMS, NULL,
                             "--root-url (-U) not provided");

  /* Copy the rest of our command-line arguments to an array,
     UTF-8-ing them along the way. */
  /* If there are extra arguments in a supplementary file, tack those
     on, too (again, in UTF8 form). */
  action_args = apr_array_make(pool, opts->argc, sizeof(const char *));
  if (extra_args_file)
    {
      svn_stringbuf_t *contents, *contents_utf8;

      SVN_ERR(svn_stringbuf_from_file2(&contents, extra_args_file, pool));
      SVN_ERR(svn_utf_stringbuf_to_utf8(&contents_utf8, contents, pool));
      svn_cstring_split_append(action_args, contents_utf8->data, "\n\r",
                               FALSE, pool);
    }

  interactive_actions = !(opts->ind < opts->argc
                          || extra_args_file
                          || non_interactive);

  if (interactive_actions)
    {
#ifdef HAVE_LINENOISE
      linenoiseSetCompletionCallback(linenoise_completion);
#endif
    }

  SVN_ERR(wc_create(&wc,
                    anchor_url, base_revision,
                    branch_id,
                    ctx, pool, pool));

  do
    {
      /* Parse arguments -- converting local style to internal style,
       * repos-relative URLs to regular URLs, etc. */
      err = svn_client_args_to_target_array2(&action_args, opts, action_args,
                                             ctx, FALSE, pool);
      if (! err)
        err = parse_actions(&actions, action_args, pool);
      if (! err)
        err = execute(wc, actions, anchor_url, revprops, ctx, pool);
      if (err)
        {
          if (err->apr_err == SVN_ERR_AUTHN_FAILED && non_interactive)
            err = svn_error_quick_wrap(err,
                                       _("Authentication failed and interactive"
                                         " prompting is disabled; see the"
                                         " --force-interactive option"));
          if (interactive_actions)
            {
              /* Display the error, but don't quit */
              settext_stderr(TEXT_FG_RED);
              svn_handle_error2(err, stderr, FALSE, "svnmover: ");
              settext_stderr(TEXT_RESET);
              svn_error_clear(err);
            }
          else
            SVN_ERR(err);
        }

      /* Possibly read more actions from the command line */
      if (interactive_actions)
        {
          SVN_ERR(read_words(&action_args, "svnmover> ", pool));
        }
    }
  while (interactive_actions && action_args);

  /* Final commit */
  err = commit(NULL, wc, revprops, pool);
  svn_pool_destroy(wc->pool);
  SVN_ERR(err);

  return SVN_NO_ERROR;
}

int
main(int argc, const char *argv[])
{
  apr_pool_t *pool;
  int exit_code = EXIT_SUCCESS;
  svn_error_t *err;

  /* Initialize the app. */
  if (svn_cmdline_init("svnmover", stderr) != EXIT_SUCCESS)
    return EXIT_FAILURE;

  /* Create our top-level pool.  Use a separate mutexless allocator,
   * given this application is single threaded.
   */
  pool = apr_allocator_owner_get(svn_pool_create_allocator(FALSE));

  svn_error_set_malfunction_handler(svn_error_raise_on_malfunction);

  err = sub_main(&exit_code, argc, argv, pool);

  /* Flush stdout and report if it fails. It would be flushed on exit anyway
     but this makes sure that output is not silently lost if it fails. */
  err = svn_error_compose_create(err, svn_cmdline_fflush(stdout));

  if (err)
    {
      exit_code = EXIT_FAILURE;
      settext_stderr(TEXT_FG_RED);
      svn_cmdline_handle_exit_error(err, NULL, "svnmover: ");
      settext_stderr(TEXT_RESET);
    }

  svn_pool_destroy(pool);
  return exit_code;
}