diff options
Diffstat (limited to 'subversion/libsvn_subr/deprecated.c')
| -rw-r--r-- | subversion/libsvn_subr/deprecated.c | 1304 |
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; +} + + |
