Import trimmed svn-1.8.0-rc3

1 files changed, 1304 insertions, 0 deletions

diff --git a/subversion/libsvn_subr/deprecated.c b/subversion/libsvn_subr/deprecated.c
new file mode 100644
index 0000000..378b3f8
--- /dev/null
+++ b/subversion/libsvn_subr/deprecated.c
@@ -0,0 +1,1304 @@
+/*
+ * deprecated.c:  holding file for all deprecated APIs.
+ *                "we can't lose 'em, but we can shun 'em!"
+ *
+ * ====================================================================
+ *    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 <assert.h>
+
+/* We define this here to remove any further warnings about the usage of
+   deprecated functions in this file. */
+#define SVN_DEPRECATED
+
+#include "svn_hash.h"
+#include "svn_subst.h"
+#include "svn_path.h"
+#include "svn_opt.h"
+#include "svn_cmdline.h"
+#include "svn_version.h"
+#include "svn_pools.h"
+#include "svn_dso.h"
+#include "svn_mergeinfo.h"
+#include "svn_utf.h"
+#include "svn_xml.h"
+
+#include "opt.h"
+#include "private/svn_opt_private.h"
+#include "private/svn_mergeinfo_private.h"
+
+#include "svn_private_config.h"
+
+
+
+
+/*** Code. ***/
+
+/*** From subst.c ***/
+/* Convert an old-style svn_subst_keywords_t struct * into a new-style
+ * keywords hash.  Keyword values are shallow copies, so the produced
+ * hash must not be assumed to have lifetime longer than the struct it
+ * is based on.  A NULL input causes a NULL output. */
+static apr_hash_t *
+kwstruct_to_kwhash(const svn_subst_keywords_t *kwstruct,
+                   apr_pool_t *pool)
+{
+  apr_hash_t *kwhash;
+
+  if (kwstruct == NULL)
+    return NULL;
+
+  kwhash = apr_hash_make(pool);
+
+  if (kwstruct->revision)
+    {
+      svn_hash_sets(kwhash, SVN_KEYWORD_REVISION_LONG, kwstruct->revision);
+      svn_hash_sets(kwhash, SVN_KEYWORD_REVISION_MEDIUM, kwstruct->revision);
+      svn_hash_sets(kwhash, SVN_KEYWORD_REVISION_SHORT, kwstruct->revision);
+    }
+  if (kwstruct->date)
+    {
+      svn_hash_sets(kwhash, SVN_KEYWORD_DATE_LONG, kwstruct->date);
+      svn_hash_sets(kwhash, SVN_KEYWORD_DATE_SHORT, kwstruct->date);
+    }
+  if (kwstruct->author)
+    {
+      svn_hash_sets(kwhash, SVN_KEYWORD_AUTHOR_LONG, kwstruct->author);
+      svn_hash_sets(kwhash, SVN_KEYWORD_AUTHOR_SHORT, kwstruct->author);
+    }
+  if (kwstruct->url)
+    {
+      svn_hash_sets(kwhash, SVN_KEYWORD_URL_LONG, kwstruct->url);
+      svn_hash_sets(kwhash, SVN_KEYWORD_URL_SHORT, kwstruct->url);
+    }
+  if (kwstruct->id)
+    {
+      svn_hash_sets(kwhash, SVN_KEYWORD_ID, kwstruct->id);
+    }
+
+  return kwhash;
+}
+
+
+svn_error_t *
+svn_subst_translate_stream3(svn_stream_t *src_stream,
+                            svn_stream_t *dst_stream,
+                            const char *eol_str,
+                            svn_boolean_t repair,
+                            apr_hash_t *keywords,
+                            svn_boolean_t expand,
+                            apr_pool_t *pool)
+{
+  /* The docstring requires that *some* translation be requested. */
+  SVN_ERR_ASSERT(eol_str || keywords);
+
+  /* We don't want the copy3 to close the provided streams. */
+  src_stream = svn_stream_disown(src_stream, pool);
+  dst_stream = svn_stream_disown(dst_stream, pool);
+
+  /* Wrap the destination stream with our translation stream. It is more
+     efficient than wrapping the source stream. */
+  dst_stream = svn_subst_stream_translated(dst_stream, eol_str, repair,
+                                           keywords, expand, pool);
+
+  return svn_error_trace(svn_stream_copy3(src_stream, dst_stream,
+                                          NULL, NULL, pool));
+}
+
+svn_error_t *
+svn_subst_translate_stream2(svn_stream_t *s, /* src stream */
+                            svn_stream_t *d, /* dst stream */
+                            const char *eol_str,
+                            svn_boolean_t repair,
+                            const svn_subst_keywords_t *keywords,
+                            svn_boolean_t expand,
+                            apr_pool_t *pool)
+{
+  apr_hash_t *kh = kwstruct_to_kwhash(keywords, pool);
+
+  return svn_error_trace(svn_subst_translate_stream3(s, d, eol_str, repair,
+                                                     kh, expand, pool));
+}
+
+svn_error_t *
+svn_subst_translate_stream(svn_stream_t *s, /* src stream */
+                           svn_stream_t *d, /* dst stream */
+                           const char *eol_str,
+                           svn_boolean_t repair,
+                           const svn_subst_keywords_t *keywords,
+                           svn_boolean_t expand)
+{
+  apr_pool_t *pool = svn_pool_create(NULL);
+  svn_error_t *err = svn_subst_translate_stream2(s, d, eol_str, repair,
+                                                 keywords, expand, pool);
+  svn_pool_destroy(pool);
+  return svn_error_trace(err);
+}
+
+svn_error_t *
+svn_subst_translate_cstring(const char *src,
+                            const char **dst,
+                            const char *eol_str,
+                            svn_boolean_t repair,
+                            const svn_subst_keywords_t *keywords,
+                            svn_boolean_t expand,
+                            apr_pool_t *pool)
+{
+  apr_hash_t *kh = kwstruct_to_kwhash(keywords, pool);
+
+  return svn_error_trace(svn_subst_translate_cstring2(src, dst, eol_str,
+                                                      repair, kh, expand,
+                                                      pool));
+}
+
+svn_error_t *
+svn_subst_copy_and_translate(const char *src,
+                             const char *dst,
+                             const char *eol_str,
+                             svn_boolean_t repair,
+                             const svn_subst_keywords_t *keywords,
+                             svn_boolean_t expand,
+                             apr_pool_t *pool)
+{
+  return svn_error_trace(svn_subst_copy_and_translate2(src, dst, eol_str,
+                                                       repair, keywords,
+                                                       expand, FALSE, pool));
+}
+
+svn_error_t *
+svn_subst_copy_and_translate2(const char *src,
+                              const char *dst,
+                              const char *eol_str,
+                              svn_boolean_t repair,
+                              const svn_subst_keywords_t *keywords,
+                              svn_boolean_t expand,
+                              svn_boolean_t special,
+                              apr_pool_t *pool)
+{
+  apr_hash_t *kh = kwstruct_to_kwhash(keywords, pool);
+
+  return svn_error_trace(svn_subst_copy_and_translate3(src, dst, eol_str,
+                                                       repair, kh, expand,
+                                                       special, pool));
+}
+
+svn_error_t *
+svn_subst_copy_and_translate3(const char *src,
+                              const char *dst,
+                              const char *eol_str,
+                              svn_boolean_t repair,
+                              apr_hash_t *keywords,
+                              svn_boolean_t expand,
+                              svn_boolean_t special,
+                              apr_pool_t *pool)
+{
+  return svn_error_trace(svn_subst_copy_and_translate4(src, dst, eol_str,
+                                                       repair, keywords,
+                                                       expand, special,
+                                                       NULL, NULL,
+                                                       pool));
+}
+
+
+svn_error_t *
+svn_subst_stream_translated_to_normal_form(svn_stream_t **stream,
+                                           svn_stream_t *source,
+                                           svn_subst_eol_style_t eol_style,
+                                           const char *eol_str,
+                                           svn_boolean_t always_repair_eols,
+                                           apr_hash_t *keywords,
+                                           apr_pool_t *pool)
+{
+  if (eol_style == svn_subst_eol_style_native)
+    eol_str = SVN_SUBST_NATIVE_EOL_STR;
+  else if (! (eol_style == svn_subst_eol_style_fixed
+              || eol_style == svn_subst_eol_style_none))
+    return svn_error_create(SVN_ERR_IO_UNKNOWN_EOL, NULL, NULL);
+
+ *stream = svn_subst_stream_translated(source, eol_str,
+                                       eol_style == svn_subst_eol_style_fixed
+                                       || always_repair_eols,
+                                       keywords, FALSE, pool);
+
+ return SVN_NO_ERROR;
+}
+
+svn_error_t *
+svn_subst_translate_string(svn_string_t **new_value,
+                           const svn_string_t *value,
+                           const char *encoding,
+                           apr_pool_t *pool)
+{
+  return svn_subst_translate_string2(new_value, NULL, NULL, value,
+                                     encoding, FALSE, pool, pool);
+}
+
+svn_error_t *
+svn_subst_stream_detranslated(svn_stream_t **stream_p,
+                              const char *src,
+                              svn_subst_eol_style_t eol_style,
+                              const char *eol_str,
+                              svn_boolean_t always_repair_eols,
+                              apr_hash_t *keywords,
+                              svn_boolean_t special,
+                              apr_pool_t *pool)
+{
+  svn_stream_t *src_stream;
+
+  if (special)
+    return svn_subst_read_specialfile(stream_p, src, pool, pool);
+
+  /* This will be closed by svn_subst_stream_translated_to_normal_form
+     when the returned stream is closed. */
+  SVN_ERR(svn_stream_open_readonly(&src_stream, src, pool, pool));
+
+  return svn_error_trace(svn_subst_stream_translated_to_normal_form(
+                           stream_p, src_stream,
+                           eol_style, eol_str,
+                           always_repair_eols,
+                           keywords, pool));
+}
+
+svn_error_t *
+svn_subst_translate_to_normal_form(const char *src,
+                                   const char *dst,
+                                   svn_subst_eol_style_t eol_style,
+                                   const char *eol_str,
+                                   svn_boolean_t always_repair_eols,
+                                   apr_hash_t *keywords,
+                                   svn_boolean_t special,
+                                   apr_pool_t *pool)
+{
+
+  if (eol_style == svn_subst_eol_style_native)
+    eol_str = SVN_SUBST_NATIVE_EOL_STR;
+  else if (! (eol_style == svn_subst_eol_style_fixed
+              || eol_style == svn_subst_eol_style_none))
+    return svn_error_create(SVN_ERR_IO_UNKNOWN_EOL, NULL, NULL);
+
+  return svn_error_trace(svn_subst_copy_and_translate3(
+                           src, dst, eol_str,
+                           eol_style == svn_subst_eol_style_fixed
+                             || always_repair_eols,
+                           keywords,
+                           FALSE /* contract keywords */,
+                           special,
+                           pool));
+}
+
+
+/*** From opt.c ***/
+/* Same as print_command_info2(), but with deprecated struct revision. */
+static svn_error_t *
+print_command_info(const svn_opt_subcommand_desc_t *cmd,
+                   const apr_getopt_option_t *options_table,
+                   svn_boolean_t help,
+                   apr_pool_t *pool,
+                   FILE *stream)
+{
+  svn_boolean_t first_time;
+  apr_size_t i;
+
+  /* Print the canonical command name. */
+  SVN_ERR(svn_cmdline_fputs(cmd->name, stream, pool));
+
+  /* Print the list of aliases. */
+  first_time = TRUE;
+  for (i = 0; i < SVN_OPT_MAX_ALIASES; i++)
+    {
+      if (cmd->aliases[i] == NULL)
+        break;
+
+      if (first_time) {
+        SVN_ERR(svn_cmdline_fputs(" (", stream, pool));
+        first_time = FALSE;
+      }
+      else
+        SVN_ERR(svn_cmdline_fputs(", ", stream, pool));
+
+      SVN_ERR(svn_cmdline_fputs(cmd->aliases[i], stream, pool));
+    }
+
+  if (! first_time)
+    SVN_ERR(svn_cmdline_fputs(")", stream, pool));
+
+  if (help)
+    {
+      const apr_getopt_option_t *option;
+      svn_boolean_t have_options = FALSE;
+
+      SVN_ERR(svn_cmdline_fprintf(stream, pool, ": %s", _(cmd->help)));
+
+      /* Loop over all valid option codes attached to the subcommand */
+      for (i = 0; i < SVN_OPT_MAX_OPTIONS; i++)
+        {
+          if (cmd->valid_options[i])
+            {
+              if (!have_options)
+                {
+                  SVN_ERR(svn_cmdline_fputs(_("\nValid options:\n"),
+                                            stream, pool));
+                  have_options = TRUE;
+                }
+
+              /* convert each option code into an option */
+              option =
+                svn_opt_get_option_from_code2(cmd->valid_options[i],
+                                              options_table, NULL, pool);
+
+              /* print the option's docstring */
+              if (option && option->description)
+                {
+                  const char *optstr;
+                  svn_opt_format_option(&optstr, option, TRUE, pool);
+                  SVN_ERR(svn_cmdline_fprintf(stream, pool, "  %s\n",
+                                              optstr));
+                }
+            }
+        }
+
+      if (have_options)
+        SVN_ERR(svn_cmdline_fprintf(stream, pool, "\n"));
+    }
+
+  return SVN_NO_ERROR;
+}
+
+const svn_opt_subcommand_desc_t *
+svn_opt_get_canonical_subcommand(const svn_opt_subcommand_desc_t *table,
+                                 const char *cmd_name)
+{
+  int i = 0;
+
+  if (cmd_name == NULL)
+    return NULL;
+
+  while (table[i].name) {
+    int j;
+    if (strcmp(cmd_name, table[i].name) == 0)
+      return table + i;
+    for (j = 0; (j < SVN_OPT_MAX_ALIASES) && table[i].aliases[j]; j++)
+      if (strcmp(cmd_name, table[i].aliases[j]) == 0)
+        return table + i;
+
+    i++;
+  }
+
+  /* If we get here, there was no matching subcommand name or alias. */
+  return NULL;
+}
+
+void
+svn_opt_subcommand_help2(const char *subcommand,
+                         const svn_opt_subcommand_desc2_t *table,
+                         const apr_getopt_option_t *options_table,
+                         apr_pool_t *pool)
+{
+  svn_opt_subcommand_help3(subcommand, table, options_table,
+                           NULL, pool);
+}
+
+void
+svn_opt_subcommand_help(const char *subcommand,
+                        const svn_opt_subcommand_desc_t *table,
+                        const apr_getopt_option_t *options_table,
+                        apr_pool_t *pool)
+{
+  const svn_opt_subcommand_desc_t *cmd =
+    svn_opt_get_canonical_subcommand(table, subcommand);
+  svn_error_t *err;
+
+  if (cmd)
+    err = print_command_info(cmd, options_table, TRUE, pool, stdout);
+  else
+    err = svn_cmdline_fprintf(stderr, pool,
+                              _("\"%s\": unknown command.\n\n"), subcommand);
+
+  if (err) {
+    svn_handle_error2(err, stderr, FALSE, "svn: ");
+    svn_error_clear(err);
+  }
+}
+
+svn_error_t *
+svn_opt_args_to_target_array3(apr_array_header_t **targets_p,
+                              apr_getopt_t *os,
+                              const apr_array_header_t *known_targets,
+                              apr_pool_t *pool)
+{
+  return svn_error_trace(svn_opt__args_to_target_array(targets_p, os,
+                                                       known_targets, pool));
+}
+
+svn_error_t *
+svn_opt_args_to_target_array2(apr_array_header_t **targets_p,
+                              apr_getopt_t *os,
+                              const apr_array_header_t *known_targets,
+                              apr_pool_t *pool)
+{
+  svn_error_t *err = svn_opt_args_to_target_array3(targets_p, os,
+                                                   known_targets, pool);
+
+  if (err && err->apr_err == SVN_ERR_RESERVED_FILENAME_SPECIFIED)
+    {
+      svn_error_clear(err);
+      return SVN_NO_ERROR;
+    }
+
+  return err;
+}
+
+svn_error_t *
+svn_opt_args_to_target_array(apr_array_header_t **targets_p,
+                             apr_getopt_t *os,
+                             const apr_array_header_t *known_targets,
+                             svn_opt_revision_t *start_revision,
+                             svn_opt_revision_t *end_revision,
+                             svn_boolean_t extract_revisions,
+                             apr_pool_t *pool)
+{
+  apr_array_header_t *output_targets;
+
+  SVN_ERR(svn_opt_args_to_target_array2(&output_targets, os,
+                                        known_targets, pool));
+
+  if (extract_revisions)
+    {
+      svn_opt_revision_t temprev;
+      const char *path;
+
+      if (output_targets->nelts > 0)
+        {
+          path = APR_ARRAY_IDX(output_targets, 0, const char *);
+          SVN_ERR(svn_opt_parse_path(&temprev, &path, path, pool));
+          if (temprev.kind != svn_opt_revision_unspecified)
+            {
+              APR_ARRAY_IDX(output_targets, 0, const char *) = path;
+              start_revision->kind = temprev.kind;
+              start_revision->value = temprev.value;
+            }
+        }
+      if (output_targets->nelts > 1)
+        {
+          path = APR_ARRAY_IDX(output_targets, 1, const char *);
+          SVN_ERR(svn_opt_parse_path(&temprev, &path, path, pool));
+          if (temprev.kind != svn_opt_revision_unspecified)
+            {
+              APR_ARRAY_IDX(output_targets, 1, const char *) = path;
+              end_revision->kind = temprev.kind;
+              end_revision->value = temprev.value;
+            }
+        }
+    }
+
+  *targets_p = output_targets;
+  return SVN_NO_ERROR;
+}
+
+svn_error_t *
+svn_opt_print_help3(apr_getopt_t *os,
+                    const char *pgm_name,
+                    svn_boolean_t print_version,
+                    svn_boolean_t quiet,
+                    const char *version_footer,
+                    const char *header,
+                    const svn_opt_subcommand_desc2_t *cmd_table,
+                    const apr_getopt_option_t *option_table,
+                    const int *global_options,
+                    const char *footer,
+                    apr_pool_t *pool)
+{
+  return svn_error_trace(svn_opt_print_help4(os,
+                                             pgm_name,
+                                             print_version,
+                                             quiet,
+                                             FALSE,
+                                             version_footer,
+                                             header,
+                                             cmd_table,
+                                             option_table,
+                                             global_options,
+                                             footer,
+                                             pool));
+}
+
+svn_error_t *
+svn_opt_print_help2(apr_getopt_t *os,
+                    const char *pgm_name,
+                    svn_boolean_t print_version,
+                    svn_boolean_t quiet,
+                    const char *version_footer,
+                    const char *header,
+                    const svn_opt_subcommand_desc2_t *cmd_table,
+                    const apr_getopt_option_t *option_table,
+                    const char *footer,
+                    apr_pool_t *pool)
+{
+  return svn_error_trace(svn_opt_print_help4(os,
+                                             pgm_name,
+                                             print_version,
+                                             quiet,
+                                             FALSE,
+                                             version_footer,
+                                             header,
+                                             cmd_table,
+                                             option_table,
+                                             NULL,
+                                             footer,
+                                             pool));
+}
+
+svn_error_t *
+svn_opt_print_help(apr_getopt_t *os,
+                   const char *pgm_name,
+                   svn_boolean_t print_version,
+                   svn_boolean_t quiet,
+                   const char *version_footer,
+                   const char *header,
+                   const svn_opt_subcommand_desc_t *cmd_table,
+                   const apr_getopt_option_t *option_table,
+                   const char *footer,
+                   apr_pool_t *pool)
+{
+  apr_array_header_t *targets = NULL;
+
+  if (os)
+    SVN_ERR(svn_opt_parse_all_args(&targets, os, pool));
+
+  if (os && targets->nelts)  /* help on subcommand(s) requested */
+    {
+      int i;
+
+      for (i = 0; i < targets->nelts; i++)
+        {
+          svn_opt_subcommand_help(APR_ARRAY_IDX(targets, i, const char *),
+                                  cmd_table, option_table, pool);
+        }
+    }
+  else if (print_version)   /* just --version */
+    {
+      SVN_ERR(svn_opt__print_version_info(pgm_name, version_footer,
+                                          svn_version_extended(FALSE, pool),
+                                          quiet, FALSE, pool));
+    }
+  else if (os && !targets->nelts)            /* `-h', `--help', or `help' */
+    svn_opt_print_generic_help(header,
+                               cmd_table,
+                               option_table,
+                               footer,
+                               pool,
+                               stdout);
+  else                                       /* unknown option or cmd */
+    SVN_ERR(svn_cmdline_fprintf(stderr, pool,
+                                _("Type '%s help' for usage.\n"), pgm_name));
+
+  return SVN_NO_ERROR;
+}
+
+void
+svn_opt_print_generic_help(const char *header,
+                           const svn_opt_subcommand_desc_t *cmd_table,
+                           const apr_getopt_option_t *opt_table,
+                           const char *footer,
+                           apr_pool_t *pool, FILE *stream)
+{
+  int i = 0;
+  svn_error_t *err;
+
+  if (header)
+    if ((err = svn_cmdline_fputs(header, stream, pool)))
+      goto print_error;
+
+  while (cmd_table[i].name)
+    {
+      if ((err = svn_cmdline_fputs("   ", stream, pool))
+          || (err = print_command_info(cmd_table + i, opt_table, FALSE,
+                                       pool, stream))
+          || (err = svn_cmdline_fputs("\n", stream, pool)))
+        goto print_error;
+      i++;
+    }
+
+  if ((err = svn_cmdline_fputs("\n", stream, pool)))
+    goto print_error;
+
+  if (footer)
+    if ((err = svn_cmdline_fputs(footer, stream, pool)))
+      goto print_error;
+
+  return;
+
+ print_error:
+  svn_handle_error2(err, stderr, FALSE, "svn: ");
+  svn_error_clear(err);
+}
+
+/*** From io.c ***/
+svn_error_t *
+svn_io_open_unique_file2(apr_file_t **file,
+                         const char **temp_path,
+                         const char *path,
+                         const char *suffix,
+                         svn_io_file_del_t delete_when,
+                         apr_pool_t *pool)
+{
+  const char *dirpath;
+  const char *filename;
+
+  svn_path_split(path, &dirpath, &filename, pool);
+  return svn_error_trace(svn_io_open_uniquely_named(file, temp_path,
+                                                    dirpath, filename, suffix,
+                                                    delete_when,
+                                                    pool, pool));
+}
+
+svn_error_t *
+svn_io_open_unique_file(apr_file_t **file,
+                        const char **temp_path,
+                        const char *path,
+                        const char *suffix,
+                        svn_boolean_t delete_on_close,
+                        apr_pool_t *pool)
+{
+  return svn_error_trace(svn_io_open_unique_file2(file, temp_path,
+                                                  path, suffix,
+                                                  delete_on_close
+                                                    ? svn_io_file_del_on_close
+                                                    : svn_io_file_del_none,
+                                                  pool));
+}
+
+svn_error_t *
+svn_io_run_diff(const char *dir,
+                const char *const *user_args,
+                int num_user_args,
+                const char *label1,
+                const char *label2,
+                const char *from,
+                const char *to,
+                int *pexitcode,
+                apr_file_t *outfile,
+                apr_file_t *errfile,
+                const char *diff_cmd,
+                apr_pool_t *pool)
+{
+  SVN_ERR(svn_path_cstring_to_utf8(&diff_cmd, diff_cmd, pool));
+
+  return svn_error_trace(svn_io_run_diff2(dir, user_args, num_user_args,
+                                          label1, label2,
+                                          from, to, pexitcode,
+                                          outfile, errfile, diff_cmd,
+                                          pool));
+}
+
+svn_error_t *
+svn_io_run_diff3_2(int *exitcode,
+                   const char *dir,
+                   const char *mine,
+                   const char *older,
+                   const char *yours,
+                   const char *mine_label,
+                   const char *older_label,
+                   const char *yours_label,
+                   apr_file_t *merged,
+                   const char *diff3_cmd,
+                   const apr_array_header_t *user_args,
+                   apr_pool_t *pool)
+{
+  SVN_ERR(svn_path_cstring_to_utf8(&diff3_cmd, diff3_cmd, pool));
+
+  return svn_error_trace(svn_io_run_diff3_3(exitcode, dir,
+                                            mine, older, yours,
+                                            mine_label, older_label,
+                                            yours_label, merged,
+                                            diff3_cmd, user_args, pool));
+}
+
+svn_error_t *
+svn_io_run_diff3(const char *dir,
+                 const char *mine,
+                 const char *older,
+                 const char *yours,
+                 const char *mine_label,
+                 const char *older_label,
+                 const char *yours_label,
+                 apr_file_t *merged,
+                 int *exitcode,
+                 const char *diff3_cmd,
+                 apr_pool_t *pool)
+{
+  return svn_error_trace(svn_io_run_diff3_2(exitcode, dir, mine, older, yours,
+                                            mine_label, older_label,
+                                            yours_label,
+                                            merged, diff3_cmd, NULL, pool));
+}
+
+svn_error_t *
+svn_io_remove_file(const char *path,
+                   apr_pool_t *scratch_pool)
+{
+  return svn_error_trace(svn_io_remove_file2(path, FALSE, scratch_pool));
+}
+
+svn_error_t *svn_io_file_lock(const char *lock_file,
+                              svn_boolean_t exclusive,
+                              apr_pool_t *pool)
+{
+  return svn_io_file_lock2(lock_file, exclusive, FALSE, pool);
+}
+
+svn_error_t *
+svn_io_get_dirents2(apr_hash_t **dirents,
+                    const char *path,
+                    apr_pool_t *pool)
+{
+  /* Note that the first part of svn_io_dirent2_t is identical
+     to svn_io_dirent_t to allow this construct */
+  return svn_error_trace(
+            svn_io_get_dirents3(dirents, path, FALSE, pool, pool));
+}
+
+svn_error_t *
+svn_io_get_dirents(apr_hash_t **dirents,
+                   const char *path,
+                   apr_pool_t *pool)
+{
+  /* Note that in C, padding is not allowed at the beginning of structs,
+     so this is actually portable, since the kind field of svn_io_dirent_t
+     is first in that struct. */
+  return svn_io_get_dirents2(dirents, path, pool);
+}
+
+svn_error_t *
+svn_io_start_cmd2(apr_proc_t *cmd_proc,
+                  const char *path,
+                  const char *cmd,
+                  const char *const *args,
+                  svn_boolean_t inherit,
+                  svn_boolean_t infile_pipe,
+                  apr_file_t *infile,
+                  svn_boolean_t outfile_pipe,
+                  apr_file_t *outfile,
+                  svn_boolean_t errfile_pipe,
+                  apr_file_t *errfile,
+                  apr_pool_t *pool)
+{
+  return svn_io_start_cmd3(cmd_proc, path, cmd, args, NULL, inherit,
+                           infile_pipe, infile, outfile_pipe, outfile,
+                           errfile_pipe, errfile, pool);
+}
+
+svn_error_t *
+svn_io_start_cmd(apr_proc_t *cmd_proc,
+                 const char *path,
+                 const char *cmd,
+                 const char *const *args,
+                 svn_boolean_t inherit,
+                 apr_file_t *infile,
+                 apr_file_t *outfile,
+                 apr_file_t *errfile,
+                 apr_pool_t *pool)
+{
+  return svn_io_start_cmd2(cmd_proc, path, cmd, args, inherit, FALSE,
+                           infile, FALSE, outfile, FALSE, errfile, pool);
+}
+
+svn_error_t *
+svn_io_file_read_full(apr_file_t *file, void *buf,
+                      apr_size_t nbytes, apr_size_t *bytes_read,
+                      apr_pool_t *pool)
+{
+  return svn_io_file_read_full2(file, buf, nbytes, bytes_read, NULL, pool);
+}
+
+struct walk_func_filter_baton_t
+{
+  svn_io_walk_func_t walk_func;
+  void *walk_baton;
+};
+
+/* Implements svn_io_walk_func_t, but only allows APR_DIR and APR_REG
+   finfo types through to the wrapped function/baton.  */
+static svn_error_t *
+walk_func_filter_func(void *baton,
+                      const char *path,
+                      const apr_finfo_t *finfo,
+                      apr_pool_t *pool)
+{
+  struct walk_func_filter_baton_t *b = baton;
+
+  if (finfo->filetype == APR_DIR || finfo->filetype == APR_REG)
+    SVN_ERR(b->walk_func(b->walk_baton, path, finfo, pool));
+
+  return SVN_NO_ERROR;
+}
+
+svn_error_t *
+svn_io_dir_walk(const char *dirname,
+                apr_int32_t wanted,
+                svn_io_walk_func_t walk_func,
+                void *walk_baton,
+                apr_pool_t *pool)
+{
+  struct walk_func_filter_baton_t baton;
+  baton.walk_func = walk_func;
+  baton.walk_baton = walk_baton;
+  return svn_error_trace(svn_io_dir_walk2(dirname, wanted,
+                                          walk_func_filter_func,
+                                          &baton, pool));
+}
+
+svn_error_t *
+svn_io_stat_dirent(const svn_io_dirent2_t **dirent_p,
+                   const char *path,
+                   svn_boolean_t ignore_enoent,
+                   apr_pool_t *result_pool,
+                   apr_pool_t *scratch_pool)
+{
+  return svn_error_trace(
+            svn_io_stat_dirent2(dirent_p,
+                                path,
+                                FALSE,
+                                ignore_enoent,
+                                result_pool,
+                                scratch_pool));
+}
+
+/*** From constructors.c ***/
+svn_log_changed_path_t *
+svn_log_changed_path_dup(const svn_log_changed_path_t *changed_path,
+                         apr_pool_t *pool)
+{
+  svn_log_changed_path_t *new_changed_path
+    = apr_palloc(pool, sizeof(*new_changed_path));
+
+  *new_changed_path = *changed_path;
+
+  if (new_changed_path->copyfrom_path)
+    new_changed_path->copyfrom_path =
+      apr_pstrdup(pool, new_changed_path->copyfrom_path);
+
+  return new_changed_path;
+}
+
+/*** From cmdline.c ***/
+svn_error_t *
+svn_cmdline_prompt_user(const char **result,
+                        const char *prompt_str,
+                        apr_pool_t *pool)
+{
+  return svn_error_trace(svn_cmdline_prompt_user2(result, prompt_str, NULL,
+                                                  pool));
+}
+
+svn_error_t *
+svn_cmdline_setup_auth_baton(svn_auth_baton_t **ab,
+                             svn_boolean_t non_interactive,
+                             const char *auth_username,
+                             const char *auth_password,
+                             const char *config_dir,
+                             svn_boolean_t no_auth_cache,
+                             svn_config_t *cfg,
+                             svn_cancel_func_t cancel_func,
+                             void *cancel_baton,
+                             apr_pool_t *pool)
+{
+  return svn_error_trace(svn_cmdline_create_auth_baton(
+                           ab, non_interactive,
+                           auth_username, auth_password,
+                           config_dir, no_auth_cache, FALSE,
+                           cfg, cancel_func, cancel_baton, pool));
+}
+
+/*** From dso.c ***/
+void
+svn_dso_initialize(void)
+{
+  svn_error_t *err = svn_dso_initialize2();
+  if (err)
+    {
+      svn_error_clear(err);
+      abort();
+    }
+}
+
+/*** From simple_providers.c ***/
+void
+svn_auth_get_simple_provider(svn_auth_provider_object_t **provider,
+                             apr_pool_t *pool)
+{
+  svn_auth_get_simple_provider2(provider, NULL, NULL, pool);
+}
+
+/*** From ssl_client_cert_pw_providers.c ***/
+void
+svn_auth_get_ssl_client_cert_pw_file_provider
+  (svn_auth_provider_object_t **provider,
+   apr_pool_t *pool)
+{
+  svn_auth_get_ssl_client_cert_pw_file_provider2(provider, NULL, NULL, pool);
+}
+
+/*** From path.c ***/
+
+#define SVN_EMPTY_PATH ""
+
+const char *
+svn_path_url_add_component(const char *url,
+                           const char *component,
+                           apr_pool_t *pool)
+{
+  /* URL can have trailing '/' */
+  url = svn_path_canonicalize(url, pool);
+
+  return svn_path_url_add_component2(url, component, pool);
+}
+
+void
+svn_path_split(const char *path,
+               const char **dirpath,
+               const char **base_name,
+               apr_pool_t *pool)
+{
+  assert(dirpath != base_name);
+
+  if (dirpath)
+    *dirpath = svn_path_dirname(path, pool);
+
+  if (base_name)
+    *base_name = svn_path_basename(path, pool);
+}
+
+
+svn_error_t *
+svn_path_split_if_file(const char *path,
+                       const char **pdirectory,
+                       const char **pfile,
+                       apr_pool_t *pool)
+{
+  apr_finfo_t finfo;
+  svn_error_t *err;
+
+  SVN_ERR_ASSERT(svn_path_is_canonical(path, pool));
+
+  err = svn_io_stat(&finfo, path, APR_FINFO_TYPE, pool);
+  if (err && ! APR_STATUS_IS_ENOENT(err->apr_err))
+    return err;
+
+  if (err || finfo.filetype == APR_REG)
+    {
+      svn_error_clear(err);
+      svn_path_split(path, pdirectory, pfile, pool);
+    }
+  else if (finfo.filetype == APR_DIR)
+    {
+      *pdirectory = path;
+      *pfile = SVN_EMPTY_PATH;
+    }
+  else
+    {
+      return svn_error_createf(SVN_ERR_BAD_FILENAME, NULL,
+                               _("'%s' is neither a file nor a directory name"),
+                               svn_path_local_style(path, pool));
+    }
+
+  return SVN_NO_ERROR;
+}
+
+/*** From stream.c ***/
+svn_error_t *svn_stream_copy2(svn_stream_t *from, svn_stream_t *to,
+                              svn_cancel_func_t cancel_func,
+                              void *cancel_baton,
+                              apr_pool_t *scratch_pool)
+{
+  return svn_error_trace(svn_stream_copy3(
+                           svn_stream_disown(from, scratch_pool),
+                           svn_stream_disown(to, scratch_pool),
+                           cancel_func, cancel_baton, scratch_pool));
+}
+
+svn_error_t *svn_stream_copy(svn_stream_t *from, svn_stream_t *to,
+                             apr_pool_t *scratch_pool)
+{
+  return svn_error_trace(svn_stream_copy3(
+                           svn_stream_disown(from, scratch_pool),
+                           svn_stream_disown(to, scratch_pool),
+                           NULL, NULL, scratch_pool));
+}
+
+svn_stream_t *
+svn_stream_from_aprfile(apr_file_t *file, apr_pool_t *pool)
+{
+  return svn_stream_from_aprfile2(file, TRUE, pool);
+}
+
+svn_error_t *
+svn_stream_contents_same(svn_boolean_t *same,
+                         svn_stream_t *stream1,
+                         svn_stream_t *stream2,
+                         apr_pool_t *pool)
+{
+  return svn_error_trace(svn_stream_contents_same2(
+                           same,
+                           svn_stream_disown(stream1, pool),
+                           svn_stream_disown(stream2, pool),
+                           pool));
+}
+
+/*** From path.c ***/
+
+const char *
+svn_path_internal_style(const char *path, apr_pool_t *pool)
+{
+  if (svn_path_is_url(path))
+    return svn_uri_canonicalize(path, pool);
+  else
+    return svn_dirent_internal_style(path, pool);
+}
+
+
+const char *
+svn_path_local_style(const char *path, apr_pool_t *pool)
+{
+  if (svn_path_is_url(path))
+    return apr_pstrdup(pool, path);
+  else
+    return svn_dirent_local_style(path, pool);
+}
+
+const char *
+svn_path_canonicalize(const char *path, apr_pool_t *pool)
+{
+  if (svn_path_is_url(path))
+    return svn_uri_canonicalize(path, pool);
+  else
+    return svn_dirent_canonicalize(path, pool);
+}
+
+
+/*** From mergeinfo.c ***/
+
+svn_error_t *
+svn_mergeinfo_inheritable(svn_mergeinfo_t *output,
+                          svn_mergeinfo_t mergeinfo,
+                          const char *path,
+                          svn_revnum_t start,
+                          svn_revnum_t end,
+                          apr_pool_t *pool)
+{
+  return svn_error_trace(svn_mergeinfo_inheritable2(output, mergeinfo, path,
+                                                    start, end,
+                                                    TRUE, pool, pool));
+}
+
+svn_error_t *
+svn_rangelist_inheritable(svn_rangelist_t **inheritable_rangelist,
+                          const svn_rangelist_t *rangelist,
+                          svn_revnum_t start,
+                          svn_revnum_t end,
+                          apr_pool_t *pool)
+{
+  return svn_error_trace(svn_rangelist_inheritable2(inheritable_rangelist,
+                                                    rangelist,
+                                                    start, end, TRUE,
+                                                    pool, pool));
+}
+
+svn_error_t *
+svn_rangelist_merge(svn_rangelist_t **rangelist,
+                    const svn_rangelist_t *changes,
+                    apr_pool_t *pool)
+{
+  SVN_ERR(svn_rangelist_merge2(*rangelist, changes,
+                               pool, pool));
+
+  return svn_error_trace(
+            svn_rangelist__combine_adjacent_ranges(*rangelist, pool));
+}
+
+svn_error_t *
+svn_mergeinfo_diff(svn_mergeinfo_t *deleted, svn_mergeinfo_t *added,
+                   svn_mergeinfo_t from, svn_mergeinfo_t to,
+                   svn_boolean_t consider_inheritance,
+                   apr_pool_t *pool)
+{
+  return svn_error_trace(svn_mergeinfo_diff2(deleted, added, from, to,
+                                             consider_inheritance, pool,
+                                             pool));
+}
+
+svn_error_t *
+svn_mergeinfo_merge(svn_mergeinfo_t mergeinfo,
+                    svn_mergeinfo_t changes,
+                    apr_pool_t *pool)
+{
+  return svn_error_trace(svn_mergeinfo_merge2(mergeinfo, changes, pool,
+                         pool));
+}
+
+svn_error_t *
+svn_mergeinfo_remove(svn_mergeinfo_t *mergeinfo, svn_mergeinfo_t eraser,
+                     svn_mergeinfo_t whiteboard, apr_pool_t *pool)
+{
+  return svn_mergeinfo_remove2(mergeinfo, eraser, whiteboard, TRUE, pool,
+                               pool);
+}
+
+svn_error_t *
+svn_mergeinfo_intersect(svn_mergeinfo_t *mergeinfo,
+                        svn_mergeinfo_t mergeinfo1,
+                        svn_mergeinfo_t mergeinfo2,
+                        apr_pool_t *pool)
+{
+  return svn_mergeinfo_intersect2(mergeinfo, mergeinfo1, mergeinfo2,
+                                  TRUE, pool, pool);
+}
+
+/*** From config.c ***/
+svn_error_t *
+svn_config_create(svn_config_t **cfgp,
+                  svn_boolean_t section_names_case_sensitive,
+                  apr_pool_t *result_pool)
+{
+  return svn_error_trace(svn_config_create2(cfgp,
+                                            section_names_case_sensitive,
+                                            FALSE,
+                                            result_pool));
+}
+
+svn_error_t *
+svn_config_read2(svn_config_t **cfgp, const char *file,
+                 svn_boolean_t must_exist,
+                 svn_boolean_t section_names_case_sensitive,
+                 apr_pool_t *result_pool)
+{
+  return svn_error_trace(svn_config_read3(cfgp, file,
+                                          must_exist,
+                                          section_names_case_sensitive,
+                                          FALSE,
+                                          result_pool));
+}
+
+svn_error_t *
+svn_config_read(svn_config_t **cfgp, const char *file,
+                svn_boolean_t must_exist,
+                apr_pool_t *result_pool)
+{
+  return svn_error_trace(svn_config_read3(cfgp, file,
+                                          must_exist,
+                                          FALSE, FALSE,
+                                          result_pool));
+}
+
+#ifdef SVN_DISABLE_FULL_VERSION_MATCH
+/* This double underscore name is used by the 1.6 command line client.
+   Keeping this name is sufficient for the 1.6 client to use the 1.7
+   libraries at runtime. */
+svn_error_t *
+svn_opt__eat_peg_revisions(apr_array_header_t **true_targets_p,
+                           apr_array_header_t *targets,
+                           apr_pool_t *pool);
+svn_error_t *
+svn_opt__eat_peg_revisions(apr_array_header_t **true_targets_p,
+                           apr_array_header_t *targets,
+                           apr_pool_t *pool)
+{
+  unsigned int i;
+  apr_array_header_t *true_targets;
+
+  true_targets = apr_array_make(pool, 5, sizeof(const char *));
+
+  for (i = 0; i < targets->nelts; i++)
+    {
+      const char *target = APR_ARRAY_IDX(targets, i, const char *);
+      const char *true_target;
+
+      SVN_ERR(svn_opt__split_arg_at_peg_revision(&true_target, NULL,
+                                                 target, pool));
+      APR_ARRAY_PUSH(true_targets, const char *) = true_target;
+    }
+
+  SVN_ERR_ASSERT(true_targets_p);
+  *true_targets_p = true_targets;
+
+  return SVN_NO_ERROR;
+}
+#endif
+
+void
+svn_xml_make_header(svn_stringbuf_t **str, apr_pool_t *pool)
+{
+  svn_xml_make_header2(str, NULL, pool);
+}
+
+void
+svn_utf_initialize(apr_pool_t *pool)
+{
+  svn_utf_initialize2(FALSE, pool);
+}
+
+svn_error_t *
+svn_subst_build_keywords(svn_subst_keywords_t *kw,
+                         const char *keywords_val,
+                         const char *rev,
+                         const char *url,
+                         apr_time_t date,
+                         const char *author,
+                         apr_pool_t *pool)
+{
+  apr_hash_t *kwhash;
+  const svn_string_t *val;
+
+  SVN_ERR(svn_subst_build_keywords2(&kwhash, keywords_val, rev,
+                                    url, date, author, pool));
+
+  /* The behaviour of pre-1.3 svn_subst_build_keywords, which we are
+   * replicating here, is to write to a slot in the svn_subst_keywords_t
+   * only if the relevant keyword was present in keywords_val, otherwise
+   * leaving that slot untouched. */
+
+  val = svn_hash_gets(kwhash, SVN_KEYWORD_REVISION_LONG);
+  if (val)
+    kw->revision = val;
+
+  val = svn_hash_gets(kwhash, SVN_KEYWORD_DATE_LONG);
+  if (val)
+    kw->date = val;
+
+  val = svn_hash_gets(kwhash, SVN_KEYWORD_AUTHOR_LONG);
+  if (val)
+    kw->author = val;
+
+  val = svn_hash_gets(kwhash, SVN_KEYWORD_URL_LONG);
+  if (val)
+    kw->url = val;
+
+  val = svn_hash_gets(kwhash, SVN_KEYWORD_ID);
+  if (val)
+    kw->id = val;
+
+  return SVN_NO_ERROR;
+}
+
+