#include "svn_string.h"
#include "svn_cmdline.h"
#include "svn_wc.h"
#include "svn_pools.h"
#include "svn_error_codes.h"
#include "svn_error.h"
#include "svn_dirent_uri.h"
#include "svn_path.h"
#include "svn_time.h"
#include "svn_xml.h"
#include "cl.h"
#include "svn_private_config.h"
#include "cl-conflicts.h"
static svn_error_t *
svn_cl__info_print_time(apr_time_t atime,
const char *desc,
apr_pool_t *pool)
{
const char *time_utf8;
time_utf8 = svn_time_to_human_cstring(atime, pool);
return svn_cmdline_printf(pool, "%s: %s\n", desc, time_utf8);
}
static const char *
schedule_str(svn_wc_schedule_t schedule)
{
switch (schedule)
{
case svn_wc_schedule_normal:
return "normal";
case svn_wc_schedule_add:
return "add";
case svn_wc_schedule_delete:
return "delete";
case svn_wc_schedule_replace:
return "replace";
default:
return "none";
}
}
static const char*
relative_url(const svn_client_info2_t *info, apr_pool_t *pool)
{
return apr_pstrcat(pool, "^/",
svn_path_uri_encode(
svn_uri_skip_ancestor(info->repos_root_URL,
info->URL, pool),
pool), SVN_VA_NULL);
}
typedef enum
{
info_item_kind,
info_item_url,
info_item_relative_url,
info_item_repos_root_url,
info_item_repos_uuid,
info_item_revision,
info_item_last_changed_rev,
info_item_last_changed_date,
info_item_last_changed_author,
info_item_wc_root
} info_item_t;
typedef struct info_item_map_t
{
const svn_string_t keyword;
const info_item_t print_what;
} info_item_map_t;
#define MAKE_STRING(x) { x, sizeof(x) - 1 }
static const info_item_map_t info_item_map[] =
{
{ MAKE_STRING("kind"), info_item_kind },
{ MAKE_STRING("url"), info_item_url },
{ MAKE_STRING("relative-url"), info_item_relative_url },
{ MAKE_STRING("repos-root-url"), info_item_repos_root_url },
{ MAKE_STRING("repos-uuid"), info_item_repos_uuid },
{ MAKE_STRING("revision"), info_item_revision },
{ MAKE_STRING("last-changed-revision"),
info_item_last_changed_rev },
{ MAKE_STRING("last-changed-date"), info_item_last_changed_date },
{ MAKE_STRING("last-changed-author"), info_item_last_changed_author },
{ MAKE_STRING("wc-root"), info_item_wc_root }
};
#undef MAKE_STRING
static const apr_size_t info_item_map_len =
(sizeof(info_item_map) / sizeof(info_item_map[0]));
typedef struct print_info_baton_t
{
const char *path_prefix;
info_item_t print_what;
svn_boolean_t multiple_targets;
svn_boolean_t target_is_path;
svn_boolean_t start_new_line;
} print_info_baton_t;
static svn_error_t *
find_print_what(const char *keyword,
print_info_baton_t *receiver_baton,
apr_pool_t *scratch_pool)
{
svn_cl__simcheck_t **keywords = apr_palloc(
scratch_pool, info_item_map_len * sizeof(svn_cl__simcheck_t*));
svn_cl__simcheck_t *kwbuf = apr_palloc(
scratch_pool, info_item_map_len * sizeof(svn_cl__simcheck_t));
apr_size_t i;
for (i = 0; i < info_item_map_len; ++i)
{
keywords[i] = &kwbuf[i];
kwbuf[i].token.data = info_item_map[i].keyword.data;
kwbuf[i].token.len = info_item_map[i].keyword.len;
kwbuf[i].data = &info_item_map[i];
}
switch (svn_cl__similarity_check(keyword, keywords,
info_item_map_len, scratch_pool))
{
const info_item_map_t *kw0;
const info_item_map_t *kw1;
const info_item_map_t *kw2;
case 0:
kw0 = keywords[0]->data;
receiver_baton->print_what = kw0->print_what;
return SVN_NO_ERROR;
case 1:
return svn_error_createf(
SVN_ERR_CL_ARG_PARSING_ERROR, NULL,
_("'%s' is not a valid value for --show-item"),
keyword);
case 2:
kw0 = keywords[0]->data;
return svn_error_createf(
SVN_ERR_CL_ARG_PARSING_ERROR, NULL,
_("'%s' is not a valid value for --show-item;"
" did you mean '%s'?"),
keyword, kw0->keyword.data);
case 3:
kw0 = keywords[0]->data;
kw1 = keywords[1]->data;
return svn_error_createf(
SVN_ERR_CL_ARG_PARSING_ERROR, NULL,
_("'%s' is not a valid value for --show-item;"
" did you mean '%s' or '%s'?"),
keyword, kw0->keyword.data, kw1->keyword.data);
default:
kw0 = keywords[0]->data;
kw1 = keywords[1]->data;
kw2 = keywords[2]->data;
return svn_error_createf(
SVN_ERR_CL_ARG_PARSING_ERROR, NULL,
_("'%s' is not a valid value for --show-item;"
" did you mean '%s', '%s' or '%s'?"),
keyword, kw0->keyword.data, kw1->keyword.data, kw2->keyword.data);
}
}
static svn_error_t *
print_info_xml(void *baton,
const char *target,
const svn_client_info2_t *info,
apr_pool_t *pool)
{
svn_stringbuf_t *sb = svn_stringbuf_create_empty(pool);
const char *rev_str;
print_info_baton_t *const receiver_baton = baton;
if (SVN_IS_VALID_REVNUM(info->rev))
rev_str = apr_psprintf(pool, "%ld", info->rev);
else
rev_str = apr_pstrdup(pool, _("Resource is not under version control."));
svn_xml_make_open_tag(&sb, pool, svn_xml_normal, "entry",
"path", svn_cl__local_style_skip_ancestor(
receiver_baton->path_prefix, target, pool),
"kind", svn_cl__node_kind_str_xml(info->kind),
"revision", rev_str,
SVN_VA_NULL);
svn_cl__xml_tagged_cdata(&sb, pool, "url", info->URL);
if (info->repos_root_URL && info->URL)
{
svn_cl__xml_tagged_cdata(&sb, pool, "relative-url",
relative_url(info, pool));
}
if (info->repos_root_URL || info->repos_UUID)
{
svn_xml_make_open_tag(&sb, pool, svn_xml_normal, "repository",
SVN_VA_NULL);
svn_cl__xml_tagged_cdata(&sb, pool, "root", info->repos_root_URL);
svn_cl__xml_tagged_cdata(&sb, pool, "uuid", info->repos_UUID);
svn_xml_make_close_tag(&sb, pool, "repository");
}
if (info->wc_info)
{
svn_xml_make_open_tag(&sb, pool, svn_xml_normal, "wc-info",
SVN_VA_NULL);
if (info->wc_info->wcroot_abspath)
svn_cl__xml_tagged_cdata(&sb, pool, "wcroot-abspath",
info->wc_info->wcroot_abspath);
svn_cl__xml_tagged_cdata(&sb, pool, "schedule",
schedule_str(info->wc_info->schedule));
{
svn_depth_t depth = info->wc_info->depth;
if (depth == svn_depth_unknown && info->kind == svn_node_file)
depth = svn_depth_infinity;
svn_cl__xml_tagged_cdata(&sb, pool, "depth", svn_depth_to_word(depth));
}
svn_cl__xml_tagged_cdata(&sb, pool, "copy-from-url",
info->wc_info->copyfrom_url);
if (SVN_IS_VALID_REVNUM(info->wc_info->copyfrom_rev))
svn_cl__xml_tagged_cdata(&sb, pool, "copy-from-rev",
apr_psprintf(pool, "%ld",
info->wc_info->copyfrom_rev));
if (info->wc_info->recorded_time)
svn_cl__xml_tagged_cdata(&sb, pool, "text-updated",
svn_time_to_cstring(
info->wc_info->recorded_time,
pool));
svn_cl__xml_tagged_cdata(&sb, pool, "checksum",
svn_checksum_to_cstring(info->wc_info->checksum,
pool));
if (info->wc_info->changelist)
svn_cl__xml_tagged_cdata(&sb, pool, "changelist",
info->wc_info->changelist);
if (info->wc_info->moved_from_abspath)
{
const char *relpath;
relpath = svn_dirent_skip_ancestor(info->wc_info->wcroot_abspath,
info->wc_info->moved_from_abspath);
if (relpath && relpath[0] != '\0')
svn_cl__xml_tagged_cdata(&sb, pool, "moved-from", relpath);
else
svn_cl__xml_tagged_cdata(&sb, pool, "moved-from",
info->wc_info->moved_from_abspath);
}
if (info->wc_info->moved_to_abspath)
{
const char *relpath;
relpath = svn_dirent_skip_ancestor(info->wc_info->wcroot_abspath,
info->wc_info->moved_to_abspath);
if (relpath && relpath[0] != '\0')
svn_cl__xml_tagged_cdata(&sb, pool, "moved-to", relpath);
else
svn_cl__xml_tagged_cdata(&sb, pool, "moved-to",
info->wc_info->moved_to_abspath);
}
svn_xml_make_close_tag(&sb, pool, "wc-info");
}
if (info->last_changed_author
|| SVN_IS_VALID_REVNUM(info->last_changed_rev)
|| info->last_changed_date)
{
svn_cl__print_xml_commit(&sb, info->last_changed_rev,
info->last_changed_author,
svn_time_to_cstring(info->last_changed_date,
pool),
pool);
}
if (info->wc_info && info->wc_info->conflicts)
{
int i;
for (i = 0; i < info->wc_info->conflicts->nelts; i++)
{
const svn_wc_conflict_description2_t *conflict =
APR_ARRAY_IDX(info->wc_info->conflicts, i,
const svn_wc_conflict_description2_t *);
SVN_ERR(svn_cl__append_conflict_info_xml(sb, conflict, pool));
}
}
if (info->lock)
svn_cl__print_xml_lock(&sb, info->lock, pool);
svn_xml_make_close_tag(&sb, pool, "entry");
return svn_cl__error_checked_fputs(sb->data, stdout);
}
static svn_error_t *
print_info(void *baton,
const char *target,
const svn_client_info2_t *info,
apr_pool_t *pool)
{
print_info_baton_t *const receiver_baton = baton;
SVN_ERR(svn_cmdline_printf(pool, _("Path: %s\n"),
svn_cl__local_style_skip_ancestor(
receiver_baton->path_prefix, target, pool)));
if (info->kind != svn_node_dir)
SVN_ERR(svn_cmdline_printf(pool, _("Name: %s\n"),
svn_dirent_basename(target, pool)));
if (info->wc_info && info->wc_info->wcroot_abspath)
SVN_ERR(svn_cmdline_printf(pool, _("Working Copy Root Path: %s\n"),
svn_dirent_local_style(
info->wc_info->wcroot_abspath,
pool)));
if (info->URL)
SVN_ERR(svn_cmdline_printf(pool, _("URL: %s\n"), info->URL));
if (info->URL && info->repos_root_URL)
SVN_ERR(svn_cmdline_printf(pool, _("Relative URL: %s\n"),
relative_url(info, pool)));
if (info->repos_root_URL)
SVN_ERR(svn_cmdline_printf(pool, _("Repository Root: %s\n"),
info->repos_root_URL));
if (info->repos_UUID)
SVN_ERR(svn_cmdline_printf(pool, _("Repository UUID: %s\n"),
info->repos_UUID));
if (SVN_IS_VALID_REVNUM(info->rev))
SVN_ERR(svn_cmdline_printf(pool, _("Revision: %ld\n"), info->rev));
switch (info->kind)
{
case svn_node_file:
SVN_ERR(svn_cmdline_printf(pool, _("Node Kind: file\n")));
break;
case svn_node_dir:
SVN_ERR(svn_cmdline_printf(pool, _("Node Kind: directory\n")));
break;
case svn_node_none:
SVN_ERR(svn_cmdline_printf(pool, _("Node Kind: none\n")));
break;
case svn_node_unknown:
default:
SVN_ERR(svn_cmdline_printf(pool, _("Node Kind: unknown\n")));
break;
}
if (info->wc_info)
{
switch (info->wc_info->schedule)
{
case svn_wc_schedule_normal:
SVN_ERR(svn_cmdline_printf(pool, _("Schedule: normal\n")));
break;
case svn_wc_schedule_add:
SVN_ERR(svn_cmdline_printf(pool, _("Schedule: add\n")));
break;
case svn_wc_schedule_delete:
SVN_ERR(svn_cmdline_printf(pool, _("Schedule: delete\n")));
break;
case svn_wc_schedule_replace:
SVN_ERR(svn_cmdline_printf(pool, _("Schedule: replace\n")));
break;
default:
break;
}
switch (info->wc_info->depth)
{
case svn_depth_unknown:
break;
case svn_depth_empty:
SVN_ERR(svn_cmdline_printf(pool, _("Depth: empty\n")));
break;
case svn_depth_files:
SVN_ERR(svn_cmdline_printf(pool, _("Depth: files\n")));
break;
case svn_depth_immediates:
SVN_ERR(svn_cmdline_printf(pool, _("Depth: immediates\n")));
break;
case svn_depth_exclude:
SVN_ERR(svn_cmdline_printf(pool, _("Depth: exclude\n")));
break;
case svn_depth_infinity:
break;
default:
SVN_ERR(svn_cmdline_printf(pool, _("Depth: INVALID\n")));
}
if (info->wc_info->copyfrom_url)
SVN_ERR(svn_cmdline_printf(pool, _("Copied From URL: %s\n"),
info->wc_info->copyfrom_url));
if (SVN_IS_VALID_REVNUM(info->wc_info->copyfrom_rev))
SVN_ERR(svn_cmdline_printf(pool, _("Copied From Rev: %ld\n"),
info->wc_info->copyfrom_rev));
if (info->wc_info->moved_from_abspath)
SVN_ERR(svn_cmdline_printf(pool, _("Moved From: %s\n"),
svn_cl__local_style_skip_ancestor(
receiver_baton->path_prefix,
info->wc_info->moved_from_abspath,
pool)));
if (info->wc_info->moved_to_abspath)
SVN_ERR(svn_cmdline_printf(pool, _("Moved To: %s\n"),
svn_cl__local_style_skip_ancestor(
receiver_baton->path_prefix,
info->wc_info->moved_to_abspath,
pool)));
}
if (info->last_changed_author)
SVN_ERR(svn_cmdline_printf(pool, _("Last Changed Author: %s\n"),
info->last_changed_author));
if (SVN_IS_VALID_REVNUM(info->last_changed_rev))
SVN_ERR(svn_cmdline_printf(pool, _("Last Changed Rev: %ld\n"),
info->last_changed_rev));
if (info->last_changed_date)
SVN_ERR(svn_cl__info_print_time(info->last_changed_date,
_("Last Changed Date"), pool));
if (info->wc_info)
{
if (info->wc_info->recorded_time)
SVN_ERR(svn_cl__info_print_time(info->wc_info->recorded_time,
_("Text Last Updated"), pool));
if (info->wc_info->checksum)
SVN_ERR(svn_cmdline_printf(pool, _("Checksum: %s\n"),
svn_checksum_to_cstring(
info->wc_info->checksum, pool)));
if (info->wc_info->conflicts)
{
svn_boolean_t printed_prop_conflict_file = FALSE;
svn_boolean_t printed_tc = FALSE;
int i;
for (i = 0; i < info->wc_info->conflicts->nelts; i++)
{
const svn_wc_conflict_description2_t *conflict =
APR_ARRAY_IDX(info->wc_info->conflicts, i,
const svn_wc_conflict_description2_t *);
const char *desc;
switch (conflict->kind)
{
case svn_wc_conflict_kind_text:
if (conflict->base_abspath)
SVN_ERR(svn_cmdline_printf(pool,
_("Conflict Previous Base File: %s\n"),
svn_cl__local_style_skip_ancestor(
receiver_baton->path_prefix,
conflict->base_abspath,
pool)));
if (conflict->my_abspath)
SVN_ERR(svn_cmdline_printf(pool,
_("Conflict Previous Working File: %s\n"),
svn_cl__local_style_skip_ancestor(
receiver_baton->path_prefix,
conflict->my_abspath,
pool)));
if (conflict->their_abspath)
SVN_ERR(svn_cmdline_printf(pool,
_("Conflict Current Base File: %s\n"),
svn_cl__local_style_skip_ancestor(
receiver_baton->path_prefix,
conflict->their_abspath,
pool)));
break;
case svn_wc_conflict_kind_property:
if (! printed_prop_conflict_file)
SVN_ERR(svn_cmdline_printf(pool,
_("Conflict Properties File: %s\n"),
svn_cl__local_style_skip_ancestor(
receiver_baton->path_prefix,
conflict->prop_reject_abspath,
pool)));
printed_prop_conflict_file = TRUE;
break;
case svn_wc_conflict_kind_tree:
printed_tc = TRUE;
SVN_ERR(
svn_cl__get_human_readable_tree_conflict_description(
&desc, conflict, pool));
SVN_ERR(svn_cmdline_printf(pool, "%s: %s\n",
_("Tree conflict"), desc));
break;
}
}
{
const char *src_left_version;
const char *src_right_version;
const svn_wc_conflict_description2_t *conflict =
APR_ARRAY_IDX(info->wc_info->conflicts, 0,
const svn_wc_conflict_description2_t *);
if (!printed_tc)
{
const char *desc;
SVN_ERR(svn_cl__get_human_readable_action_description(&desc,
svn_wc_conflict_action_edit,
conflict->operation,
conflict->node_kind, pool));
SVN_ERR(svn_cmdline_printf(pool, "%s: %s\n",
_("Conflict Details"), desc));
}
src_left_version =
svn_cl__node_description(conflict->src_left_version,
info->repos_root_URL, pool);
src_right_version =
svn_cl__node_description(conflict->src_right_version,
info->repos_root_URL, pool);
if (src_left_version)
SVN_ERR(svn_cmdline_printf(pool, " %s: %s\n",
_("Source left"),
src_left_version));
if (src_right_version)
SVN_ERR(svn_cmdline_printf(pool, " %s: %s\n",
_("Source right"),
src_right_version));
}
}
}
if (info->lock)
{
if (info->lock->token)
SVN_ERR(svn_cmdline_printf(pool, _("Lock Token: %s\n"),
info->lock->token));
if (info->lock->owner)
SVN_ERR(svn_cmdline_printf(pool, _("Lock Owner: %s\n"),
info->lock->owner));
if (info->lock->creation_date)
SVN_ERR(svn_cl__info_print_time(info->lock->creation_date,
_("Lock Created"), pool));
if (info->lock->expiration_date)
SVN_ERR(svn_cl__info_print_time(info->lock->expiration_date,
_("Lock Expires"), pool));
if (info->lock->comment)
{
int comment_lines;
comment_lines = svn_cstring_count_newlines(info->lock->comment) + 1;
SVN_ERR(svn_cmdline_printf(pool,
Q_("Lock Comment (%i line):\n%s\n",
"Lock Comment (%i lines):\n%s\n",
comment_lines),
comment_lines,
info->lock->comment));
}
}
if (info->wc_info && info->wc_info->changelist)
SVN_ERR(svn_cmdline_printf(pool, _("Changelist: %s\n"),
info->wc_info->changelist));
return svn_cmdline_printf(pool, "\n");
}
static svn_error_t *
print_info_item_string(const char *text, const char *target_path,
apr_pool_t *pool)
{
if (text)
{
if (target_path)
SVN_ERR(svn_cmdline_printf(pool, "%-10s %s", text, target_path));
else
SVN_ERR(svn_cmdline_fputs(text, stdout, pool));
}
else if (target_path)
SVN_ERR(svn_cmdline_printf(pool, "%-10s %s", "", target_path));
return SVN_NO_ERROR;
}
static svn_error_t *
print_info_item_revision(svn_revnum_t rev, const char *target_path,
apr_pool_t *pool)
{
if (SVN_IS_VALID_REVNUM(rev))
{
if (target_path)
SVN_ERR(svn_cmdline_printf(pool, "%-10ld %s", rev, target_path));
else
SVN_ERR(svn_cmdline_printf(pool, "%ld", rev));
}
else if (target_path)
SVN_ERR(svn_cmdline_printf(pool, "%-10s %s", "", target_path));
return SVN_NO_ERROR;
}
static svn_error_t *
print_info_item(void *baton,
const char *target,
const svn_client_info2_t *info,
apr_pool_t *pool)
{
print_info_baton_t *const receiver_baton = baton;
const char *const target_path =
(!receiver_baton->multiple_targets ? NULL
: (!receiver_baton->target_is_path ? info->URL
: svn_cl__local_style_skip_ancestor(
receiver_baton->path_prefix, target, pool)));
if (receiver_baton->start_new_line)
SVN_ERR(svn_cmdline_fputs("\n", stdout, pool));
switch (receiver_baton->print_what)
{
case info_item_kind:
SVN_ERR(print_info_item_string(svn_node_kind_to_word(info->kind),
target_path, pool));
break;
case info_item_url:
SVN_ERR(print_info_item_string(info->URL, target_path, pool));
break;
case info_item_relative_url:
SVN_ERR(print_info_item_string(relative_url(info, pool),
target_path, pool));
break;
case info_item_repos_root_url:
SVN_ERR(print_info_item_string(info->repos_root_URL, target_path, pool));
break;
case info_item_repos_uuid:
SVN_ERR(print_info_item_string(info->repos_UUID, target_path, pool));
break;
case info_item_revision:
SVN_ERR(print_info_item_revision(info->rev, target_path, pool));
break;
case info_item_last_changed_rev:
SVN_ERR(print_info_item_revision(info->last_changed_rev,
target_path, pool));
break;
case info_item_last_changed_date:
SVN_ERR(print_info_item_string(
(!info->last_changed_date ? NULL
: svn_time_to_cstring(info->last_changed_date, pool)),
target_path, pool));
break;
case info_item_last_changed_author:
SVN_ERR(print_info_item_string(info->last_changed_author,
target_path, pool));
break;
case info_item_wc_root:
SVN_ERR(print_info_item_string(
(info->wc_info && info->wc_info->wcroot_abspath
? info->wc_info->wcroot_abspath : NULL),
target_path, pool));
break;
default:
SVN_ERR_MALFUNCTION();
}
receiver_baton->start_new_line = TRUE;
return SVN_NO_ERROR;
}
svn_error_t *
svn_cl__info(apr_getopt_t *os,
void *baton,
apr_pool_t *pool)
{
svn_cl__opt_state_t *opt_state = ((svn_cl__cmd_baton_t *) baton)->opt_state;
svn_client_ctx_t *ctx = ((svn_cl__cmd_baton_t *) baton)->ctx;
apr_array_header_t *targets = NULL;
apr_pool_t *subpool = svn_pool_create(pool);
int i;
svn_error_t *err;
svn_boolean_t seen_nonexistent_target = FALSE;
svn_opt_revision_t peg_revision;
svn_client_info_receiver2_t receiver;
print_info_baton_t receiver_baton = { 0 };
SVN_ERR(svn_cl__args_to_target_array_print_reserved(&targets, os,
opt_state->targets,
ctx, FALSE, pool));
svn_opt_push_implicit_dot_target(targets, pool);
if (opt_state->xml)
{
receiver = print_info_xml;
if (opt_state->show_item)
return svn_error_create(
SVN_ERR_CL_ARG_PARSING_ERROR, NULL,
_("--show-item is not valid in --xml mode"));
if (opt_state->no_newline)
return svn_error_create(
SVN_ERR_CL_ARG_PARSING_ERROR, NULL,
_("--no-newline is not valid in --xml mode"));
if (! opt_state->incremental)
SVN_ERR(svn_cl__xml_print_header("info", pool));
}
else if (opt_state->show_item)
{
receiver = print_info_item;
if (opt_state->incremental)
return svn_error_create(
SVN_ERR_CL_ARG_PARSING_ERROR, NULL,
_("--incremental is only valid in --xml mode"));
receiver_baton.multiple_targets = (opt_state->depth > svn_depth_empty
|| targets->nelts > 1);
if (receiver_baton.multiple_targets && opt_state->no_newline)
return svn_error_create(
SVN_ERR_CL_ARG_PARSING_ERROR, NULL,
_("--no-newline is only available for single-target,"
" non-recursive info operations"));
SVN_ERR(find_print_what(opt_state->show_item, &receiver_baton, pool));
receiver_baton.start_new_line = FALSE;
}
else
{
receiver = print_info;
if (opt_state->incremental)
return svn_error_create(
SVN_ERR_CL_ARG_PARSING_ERROR, NULL,
_("--incremental is only valid in --xml mode"));
if (opt_state->no_newline)
return svn_error_create(
SVN_ERR_CL_ARG_PARSING_ERROR, NULL,
_("--no-newline' is only valid with --show-item"));
}
if (opt_state->depth == svn_depth_unknown)
opt_state->depth = svn_depth_empty;
SVN_ERR(svn_dirent_get_absolute(&receiver_baton.path_prefix, "", pool));
for (i = 0; i < targets->nelts; i++)
{
const char *truepath;
const char *target = APR_ARRAY_IDX(targets, i, const char *);
svn_pool_clear(subpool);
SVN_ERR(svn_cl__check_cancel(ctx->cancel_baton));
SVN_ERR(svn_opt_parse_path(&peg_revision, &truepath, target, subpool));
if (svn_path_is_url(truepath))
{
if (peg_revision.kind == svn_opt_revision_unspecified)
peg_revision.kind = svn_opt_revision_head;
receiver_baton.target_is_path = FALSE;
}
else
{
SVN_ERR(svn_dirent_get_absolute(&truepath, truepath, subpool));
receiver_baton.target_is_path = TRUE;
}
err = svn_client_info4(truepath,
&peg_revision, &(opt_state->start_revision),
opt_state->depth,
TRUE ,
TRUE ,
opt_state->include_externals,
opt_state->changelists,
receiver, &receiver_baton,
ctx, subpool);
if (err)
{
if (err->apr_err == SVN_ERR_WC_PATH_NOT_FOUND ||
err->apr_err == SVN_ERR_RA_ILLEGAL_URL)
{
svn_handle_warning2(stderr, err, "svn: ");
svn_error_clear(svn_cmdline_fprintf(stderr, subpool, "\n"));
}
else
{
return svn_error_trace(err);
}
svn_error_clear(err);
err = NULL;
seen_nonexistent_target = TRUE;
}
}
svn_pool_destroy(subpool);
if (opt_state->xml && (! opt_state->incremental))
SVN_ERR(svn_cl__xml_print_footer("info", pool));
else if (opt_state->show_item && !opt_state->no_newline
&& receiver_baton.start_new_line)
SVN_ERR(svn_cmdline_fputs("\n", stdout, pool));
if (seen_nonexistent_target)
return svn_error_create(
SVN_ERR_ILLEGAL_TARGET, NULL,
_("Could not display info for all targets because some "
"targets don't exist"));
else
return SVN_NO_ERROR;
}