/*
* 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 "private/svn_subr_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;
}
/*** From version.c ***/
svn_error_t *
svn_ver_check_list(const svn_version_t *my_version,
const svn_version_checklist_t *checklist)
{
return svn_ver_check_list2(my_version, checklist, svn_ver_compatible);
}