/* Insert a chunk of blame associated with REV starting
at token START and continuing for LENGTH tokens */
static svn_error_t *
blame_insert_range(struct blame_chain *chain,
struct rev *rev,
apr_off_t start,
apr_off_t length)
{
struct blame *head = chain->blame;
struct blame *point = blame_find(head, start);
struct blame *insert;
if (point->start == start)
{
insert = blame_create(chain, point->rev, point->start + length);
point->rev = rev;
insert->next = point->next;
point->next = insert;
}
else
{
struct blame *middle;
middle = blame_create(chain, rev, start);
insert = blame_create(chain, point->rev, start + length);
middle->next = insert;
insert->next = point->next;
point->next = middle;
}
blame_adjust(insert->next, length);
return SVN_NO_ERROR;
}
/* Insert a chunk of blame associated with DB->REV starting
at token START and continuing for LENGTH tokens */
static svn_error_t *
blame_insert_range (struct file_rev_baton *db, apr_off_t start,
apr_off_t length)
{
struct blame *head = db->blame;
struct blame *point = blame_find (head, start);
struct blame *insert;
if (point->start == start)
{
insert = blame_create (db, point->rev, point->start + length);
point->rev = db->rev;
insert->next = point->next;
point->next = insert;
}
else if (!point->next || point->next->start > start + length)
{
struct blame *middle;
middle = blame_create (db, db->rev, start);
insert = blame_create (db, point->rev, start + length);
middle->next = insert;
insert->next = point->next;
point->next = middle;
}
else
{
insert = blame_create (db, db->rev, start);
insert->next = point->next;
point->next = insert;
}
blame_adjust (insert->next, length);
return SVN_NO_ERROR;
}
/* Ensure that CHAIN_ORIG and CHAIN_MERGED have the same number of chunks,
and that for every chunk C, CHAIN_ORIG[C] and CHAIN_MERGED[C] have the
same starting value. Both CHAIN_ORIG and CHAIN_MERGED should not be
NULL. */
static void
normalize_blames(struct blame_chain *chain,
struct blame_chain *chain_merged,
apr_pool_t *pool)
{
struct blame *walk, *walk_merged;
/* Walk over the CHAIN's blame chunks and CHAIN_MERGED's blame chunks,
creating new chunks as needed. */
for (walk = chain->blame, walk_merged = chain_merged->blame;
walk->next && walk_merged->next;
walk = walk->next, walk_merged = walk_merged->next)
{
/* The current chunks should always be starting at the same offset. */
assert(walk->start == walk_merged->start);
if (walk->next->start < walk_merged->next->start)
{
/* insert a new chunk in CHAIN_MERGED. */
struct blame *tmp = blame_create(chain_merged, walk_merged->rev,
walk->next->start);
tmp->next = walk_merged->next;
walk_merged->next = tmp;
}
if (walk->next->start > walk_merged->next->start)
{
/* insert a new chunk in CHAIN. */
struct blame *tmp = blame_create(chain, walk->rev,
walk_merged->next->start);
tmp->next = walk->next;
walk->next = tmp;
}
}
/* If both NEXT pointers are null, the lists are equally long, otherwise
we need to extend one of them. If CHAIN is longer, append new chunks
to CHAIN_MERGED until its length matches that of CHAIN. */
while (walk->next != NULL)
{
struct blame *tmp = blame_create(chain_merged, walk_merged->rev,
walk->next->start);
walk_merged->next = tmp;
walk_merged = walk_merged->next;
walk = walk->next;
}
/* Same as above, only extend CHAIN to match CHAIN_MERGED. */
while (walk_merged->next != NULL)
{
struct blame *tmp = blame_create(chain, walk->rev,
walk_merged->next->start);
walk->next = tmp;
walk = walk->next;
walk_merged = walk_merged->next;
}
}
/* Add the blame for the diffs between LAST_FILE and CUR_FILE with the rev
specified in FRB. LAST_FILE may be NULL in which
case blame is added for every line of CUR_FILE. */
static svn_error_t *
add_file_blame(const char *last_file,
const char *cur_file,
struct blame_chain *chain,
struct rev *rev,
const svn_diff_file_options_t *diff_options,
apr_pool_t *pool)
{
if (!last_file)
{
SVN_ERR_ASSERT(chain->blame == NULL);
chain->blame = blame_create(chain, rev, 0);
}
else
{
svn_diff_t *diff;
struct diff_baton diff_baton;
diff_baton.chain = chain;
diff_baton.rev = rev;
/* We have a previous file. Get the diff and adjust blame info. */
SVN_ERR(svn_diff_file_diff_2(&diff, last_file, cur_file,
diff_options, pool));
SVN_ERR(svn_diff_output(diff, &diff_baton, &output_fns));
}
return SVN_NO_ERROR;
}
/* Add the blame for the diffs between LAST_FILE and CUR_FILE with the rev
specified in FRB. LAST_FILE may be NULL in which
case blame is added for every line of CUR_FILE. */
static svn_error_t *
add_file_blame (const char *last_file, const char *cur_file,
struct file_rev_baton *frb)
{
if (!last_file)
{
assert (frb->blame == NULL);
frb->blame = blame_create (frb, frb->rev, 0);
}
else
{
svn_diff_t *diff;
/* We have a previous file. Get the diff and adjust blame info. */
SVN_ERR (svn_diff_file_diff (&diff, last_file, cur_file,
frb->currpool));
SVN_ERR (svn_diff_output (diff, frb, &output_fns));
}
return SVN_NO_ERROR;
}
svn_error_t *
svn_client_blame5(const char *target,
const svn_opt_revision_t *peg_revision,
const svn_opt_revision_t *start,
const svn_opt_revision_t *end,
const svn_diff_file_options_t *diff_options,
svn_boolean_t ignore_mime_type,
svn_boolean_t include_merged_revisions,
svn_client_blame_receiver3_t receiver,
void *receiver_baton,
svn_client_ctx_t *ctx,
apr_pool_t *pool)
{
struct file_rev_baton frb;
svn_ra_session_t *ra_session;
svn_revnum_t start_revnum, end_revnum;
struct blame *walk, *walk_merged = NULL;
apr_pool_t *iterpool;
svn_stream_t *last_stream;
svn_stream_t *stream;
const char *target_abspath_or_url;
if (start->kind == svn_opt_revision_unspecified
|| end->kind == svn_opt_revision_unspecified)
return svn_error_create
(SVN_ERR_CLIENT_BAD_REVISION, NULL, NULL);
if (svn_path_is_url(target))
target_abspath_or_url = target;
else
SVN_ERR(svn_dirent_get_absolute(&target_abspath_or_url, target, pool));
/* Get an RA plugin for this filesystem object. */
SVN_ERR(svn_client__ra_session_from_path(&ra_session, &end_revnum, NULL,
target, NULL, peg_revision, end,
ctx, pool));
SVN_ERR(svn_client__get_revision_number(&start_revnum, NULL, ctx->wc_ctx,
target_abspath_or_url, ra_session,
start, pool));
if (end_revnum < start_revnum)
return svn_error_create
(SVN_ERR_CLIENT_BAD_REVISION, NULL,
_("Start revision must precede end revision"));
frb.start_rev = start_revnum;
frb.end_rev = end_revnum;
frb.target = target;
frb.ctx = ctx;
frb.diff_options = diff_options;
frb.ignore_mime_type = ignore_mime_type;
frb.include_merged_revisions = include_merged_revisions;
frb.last_filename = NULL;
frb.last_original_filename = NULL;
frb.chain = apr_palloc(pool, sizeof(*frb.chain));
frb.chain->blame = NULL;
frb.chain->avail = NULL;
frb.chain->pool = pool;
if (include_merged_revisions)
{
frb.merged_chain = apr_palloc(pool, sizeof(*frb.merged_chain));
frb.merged_chain->blame = NULL;
frb.merged_chain->avail = NULL;
frb.merged_chain->pool = pool;
}
SVN_ERR(svn_ra_get_repos_root2(ra_session, &frb.repos_root_url, pool));
frb.mainpool = pool;
/* The callback will flip the following two pools, because it needs
information from the previous call. Obviously, it can't rely on
the lifetime of the pool provided by get_file_revs. */
frb.lastpool = svn_pool_create(pool);
frb.currpool = svn_pool_create(pool);
if (include_merged_revisions)
{
frb.filepool = svn_pool_create(pool);
frb.prevfilepool = svn_pool_create(pool);
}
/* Collect all blame information.
We need to ensure that we get one revision before the start_rev,
if available so that we can know what was actually changed in the start
revision. */
SVN_ERR(svn_ra_get_file_revs2(ra_session, "",
start_revnum - (start_revnum > 0 ? 1 : 0),
end_revnum, include_merged_revisions,
file_rev_handler, &frb, pool));
if (end->kind == svn_opt_revision_working)
{
/* If the local file is modified we have to call the handler on the
working copy file with keywords unexpanded */
svn_wc_status3_t *status;
SVN_ERR(svn_wc_status3(&status, ctx->wc_ctx, target_abspath_or_url, pool,
pool));
if (status->text_status != svn_wc_status_normal)
{
apr_hash_t *props;
svn_stream_t *wcfile;
svn_string_t *keywords;
svn_stream_t *tempfile;
const char *temppath;
apr_hash_t *kw = NULL;
SVN_ERR(svn_wc_prop_list2(&props, ctx->wc_ctx, target_abspath_or_url,
pool, pool));
SVN_ERR(svn_stream_open_readonly(&wcfile, target, pool, pool));
keywords = apr_hash_get(props, SVN_PROP_KEYWORDS,
APR_HASH_KEY_STRING);
if (keywords)
SVN_ERR(svn_subst_build_keywords2(&kw, keywords->data, NULL, NULL,
0, NULL, pool));
wcfile = svn_subst_stream_translated(wcfile, "\n", TRUE, kw, FALSE,
pool);
SVN_ERR(svn_stream_open_unique(&tempfile, &temppath, NULL,
svn_io_file_del_on_pool_cleanup,
pool, pool));
SVN_ERR(svn_stream_copy3(wcfile, tempfile, ctx->cancel_func,
ctx->cancel_baton, pool));
SVN_ERR(add_file_blame(frb.last_filename, temppath, frb.chain, NULL,
frb.diff_options, pool));
frb.last_filename = temppath;
}
}
/* Report the blame to the caller. */
/* The callback has to have been called at least once. */
SVN_ERR_ASSERT(frb.last_filename != NULL);
/* Create a pool for the iteration below. */
iterpool = svn_pool_create(pool);
/* Open the last file and get a stream. */
SVN_ERR(svn_stream_open_readonly(&last_stream, frb.last_filename,
pool, pool));
stream = svn_subst_stream_translated(last_stream,
"\n", TRUE, NULL, FALSE, pool);
/* Perform optional merged chain normalization. */
if (include_merged_revisions)
{
/* If we never created any blame for the original chain, create it now,
with the most recent changed revision. This could occur if a file
was created on a branch and them merged to another branch. This is
semanticly a copy, and we want to use the revision on the branch as
the most recently changed revision. ### Is this really what we want
to do here? Do the sematics of copy change? */
if (!frb.chain->blame)
frb.chain->blame = blame_create(frb.chain, frb.rev, 0);
normalize_blames(frb.chain, frb.merged_chain, pool);
walk_merged = frb.merged_chain->blame;
}
/* Process each blame item. */
for (walk = frb.chain->blame; walk; walk = walk->next)
{
apr_off_t line_no;
svn_revnum_t merged_rev;
const char *merged_path;
apr_hash_t *merged_rev_props;
if (walk_merged)
{
merged_rev = walk_merged->rev->revision;
merged_rev_props = walk_merged->rev->rev_props;
merged_path = walk_merged->rev->path;
}
else
{
merged_rev = SVN_INVALID_REVNUM;
merged_rev_props = NULL;
merged_path = NULL;
}
for (line_no = walk->start;
!walk->next || line_no < walk->next->start;
++line_no)
{
svn_boolean_t eof;
svn_stringbuf_t *sb;
svn_pool_clear(iterpool);
SVN_ERR(svn_stream_readline(stream, &sb, "\n", &eof, iterpool));
if (ctx->cancel_func)
SVN_ERR(ctx->cancel_func(ctx->cancel_baton));
if (!eof || sb->len)
{
if (walk->rev)
SVN_ERR(receiver(receiver_baton, start_revnum, end_revnum,
line_no, walk->rev->revision,
walk->rev->rev_props, merged_rev,
merged_rev_props, merged_path,
sb->data, FALSE, iterpool));
else
SVN_ERR(receiver(receiver_baton, start_revnum, end_revnum,
line_no, SVN_INVALID_REVNUM,
NULL, SVN_INVALID_REVNUM,
NULL, NULL,
sb->data, TRUE, iterpool));
}
if (eof) break;
}
if (walk_merged)
walk_merged = walk_merged->next;
}
SVN_ERR(svn_stream_close(stream));
svn_pool_destroy(frb.lastpool);
svn_pool_destroy(frb.currpool);
if (include_merged_revisions)
{
svn_pool_destroy(frb.filepool);
svn_pool_destroy(frb.prevfilepool);
}
svn_pool_destroy(iterpool);
return SVN_NO_ERROR;
}
svn_error_t *
svn_client_blame4(const char *target,
const svn_opt_revision_t *peg_revision,
const svn_opt_revision_t *start,
const svn_opt_revision_t *end,
const svn_diff_file_options_t *diff_options,
svn_boolean_t ignore_mime_type,
svn_boolean_t include_merged_revisions,
svn_client_blame_receiver2_t receiver,
void *receiver_baton,
svn_client_ctx_t *ctx,
apr_pool_t *pool)
{
struct file_rev_baton frb;
svn_ra_session_t *ra_session;
const char *url;
svn_revnum_t start_revnum, end_revnum;
struct blame *walk, *walk_merged = NULL;
apr_file_t *file;
apr_pool_t *iterpool;
svn_stream_t *stream;
if (start->kind == svn_opt_revision_unspecified
|| end->kind == svn_opt_revision_unspecified)
return svn_error_create
(SVN_ERR_CLIENT_BAD_REVISION, NULL, NULL);
else if (start->kind == svn_opt_revision_working
|| end->kind == svn_opt_revision_working)
return svn_error_create
(SVN_ERR_UNSUPPORTED_FEATURE, NULL,
_("blame of the WORKING revision is not supported"));
/* Get an RA plugin for this filesystem object. */
SVN_ERR(svn_client__ra_session_from_path(&ra_session, &end_revnum,
&url, target, NULL,
peg_revision, end,
ctx, pool));
SVN_ERR(svn_client__get_revision_number(&start_revnum, NULL, ra_session,
start, target, pool));
if (end_revnum < start_revnum)
return svn_error_create
(SVN_ERR_CLIENT_BAD_REVISION, NULL,
_("Start revision must precede end revision"));
frb.start_rev = start_revnum;
frb.end_rev = end_revnum;
frb.target = target;
frb.ctx = ctx;
frb.diff_options = diff_options;
frb.ignore_mime_type = ignore_mime_type;
frb.include_merged_revisions = include_merged_revisions;
frb.last_filename = NULL;
frb.last_original_filename = NULL;
frb.chain = apr_palloc(pool, sizeof(*frb.chain));
frb.chain->blame = NULL;
frb.chain->avail = NULL;
frb.chain->pool = pool;
if (include_merged_revisions)
{
frb.merged_chain = apr_palloc(pool, sizeof(*frb.merged_chain));
frb.merged_chain->blame = NULL;
frb.merged_chain->avail = NULL;
frb.merged_chain->pool = pool;
}
SVN_ERR(svn_io_temp_dir(&frb.tmp_path, pool));
frb.tmp_path = svn_path_join(frb.tmp_path, "tmp", pool),
frb.mainpool = pool;
/* The callback will flip the following two pools, because it needs
information from the previous call. Obviously, it can't rely on
the lifetime of the pool provided by get_file_revs. */
frb.lastpool = svn_pool_create(pool);
frb.currpool = svn_pool_create(pool);
if (include_merged_revisions)
{
frb.filepool = svn_pool_create(pool);
frb.prevfilepool = svn_pool_create(pool);
}
/* Collect all blame information.
We need to ensure that we get one revision before the start_rev,
if available so that we can know what was actually changed in the start
revision. */
SVN_ERR(svn_ra_get_file_revs2(ra_session, "",
start_revnum - (start_revnum > 0 ? 1 : 0),
end_revnum, include_merged_revisions,
file_rev_handler, &frb, pool));
/* Report the blame to the caller. */
/* The callback has to have been called at least once. */
assert(frb.last_filename != NULL);
/* Create a pool for the iteration below. */
iterpool = svn_pool_create(pool);
/* Open the last file and get a stream. */
SVN_ERR(svn_io_file_open(&file, frb.last_filename, APR_READ | APR_BUFFERED,
APR_OS_DEFAULT, pool));
stream = svn_subst_stream_translated(svn_stream_from_aprfile(file, pool),
"\n", TRUE, NULL, FALSE, pool);
/* Perform optional merged chain normalization. */
if (include_merged_revisions)
{
/* If we never created any blame for the original chain, create it now,
with the most recent changed revision. This could occur if a file
was created on a branch and them merged to another branch. This is
semanticly a copy, and we want to use the revision on the branch as
the most recently changed revision. ### Is this really what we want
to do here? Do the sematics of copy change? */
if (!frb.chain->blame)
frb.chain->blame = blame_create(frb.chain, frb.rev, 0);
normalize_blames(frb.chain, frb.merged_chain, pool);
walk_merged = frb.merged_chain->blame;
}
/* Process each blame item. */
for (walk = frb.chain->blame; walk; walk = walk->next)
{
apr_off_t line_no;
svn_revnum_t merged_rev;
const char *merged_author, *merged_date, *merged_path;
if (walk_merged)
{
merged_rev = walk_merged->rev->revision;
merged_author = walk_merged->rev->author;
merged_date = walk_merged->rev->date;
merged_path = walk_merged->rev->path;
}
else
{
merged_rev = SVN_INVALID_REVNUM;
merged_author = NULL;
merged_date = NULL;
merged_path = NULL;
}
for (line_no = walk->start;
!walk->next || line_no < walk->next->start;
++line_no)
{
svn_boolean_t eof;
svn_stringbuf_t *sb;
svn_pool_clear(iterpool);
SVN_ERR(svn_stream_readline(stream, &sb, "\n", &eof, iterpool));
if (ctx->cancel_func)
SVN_ERR(ctx->cancel_func(ctx->cancel_baton));
if (!eof || sb->len)
SVN_ERR(receiver(receiver_baton, line_no, walk->rev->revision,
walk->rev->author, walk->rev->date,
merged_rev, merged_author, merged_date,
merged_path, sb->data, iterpool));
if (eof) break;
}
if (walk_merged)
walk_merged = walk_merged->next;
}
SVN_ERR(svn_stream_close(stream));
/* We don't need the temp file any more. */
SVN_ERR(svn_io_file_close(file, pool));
svn_pool_destroy(frb.lastpool);
svn_pool_destroy(frb.currpool);
if (include_merged_revisions)
{
svn_pool_destroy(frb.filepool);
svn_pool_destroy(frb.prevfilepool);
}
svn_pool_destroy(iterpool);
return SVN_NO_ERROR;
}
/* Ensure that CHAIN_ORIG and CHAIN_MERGED have the same number of chunks,
and that for every chunk C, CHAIN_ORIG[C] and CHAIN_MERGED[C] have the
same starting value. Both CHAIN_ORIG and CHAIN_MERGED should not be
NULL. */
static void
normalize_blames(struct blame_chain *chain,
struct blame_chain *chain_merged,
apr_pool_t *pool)
{
struct blame *walk, *walk_merged;
/* Walk over the CHAIN's blame chunks and CHAIN_MERGED's blame chunks,
creating new chunks as needed. */
for (walk = chain->blame, walk_merged = chain_merged->blame;
walk->next && walk_merged->next;
walk = walk->next, walk_merged = walk_merged->next)
{
/* The current chunks should always be starting at the same offset. */
assert(walk->start == walk_merged->start);
if (walk->next->start < walk_merged->next->start)
{
struct blame *tmp = blame_create(chain_merged, walk_merged->next->rev,
walk->next->start);
tmp->next = walk_merged->next->next;
walk_merged->next = tmp;
}
if (walk->next->start > walk_merged->next->start)
{
struct blame *tmp = blame_create(chain, walk->next->rev,
walk_merged->next->start);
tmp->next = walk->next->next;
walk->next = tmp;
}
}
/* If both next pointers are null, we have an equally long list. */
if (walk->next == NULL && walk_merged->next == NULL)
return;
if (walk_merged->next == NULL)
{
/* Make new walk_merged chunks as needed at the end of the list so that
the length matches that of walk. */
while (walk->next != NULL)
{
struct blame *tmp = blame_create(chain_merged, walk_merged->rev,
walk->next->start);
walk_merged->next = tmp;
walk_merged = walk_merged->next;
walk = walk->next;
}
}
if (walk->next == NULL)
{
/* Same as above, only create walk chunks as needed. */
while (walk_merged->next != NULL)
{
struct blame *tmp = blame_create(chain, walk->rev,
walk_merged->next->start);
walk->next = tmp;
walk = walk->next;
walk_merged = walk_merged->next;
}
}
}
static svn_error_t *
do_blame (const char *target,
svn_ra_plugin_t *ra_lib,
void *ra_session,
struct file_rev_baton *frb)
{
struct log_message_baton lmb;
apr_array_header_t *condensed_targets;
apr_file_t *file;
svn_stream_t *stream;
struct rev *rev;
svn_node_kind_t kind;
apr_pool_t *pool = frb->mainpool;
SVN_ERR (ra_lib->check_path (ra_session, target, frb->end_rev, &kind, pool));
if (kind == svn_node_dir)
return svn_error_createf (SVN_ERR_CLIENT_IS_DIRECTORY, NULL,
("URL '%s' refers to a directory"), target);
condensed_targets = apr_array_make (pool, 1, sizeof (const char *));
(*((const char **)apr_array_push (condensed_targets))) = "";
lmb.path = apr_pstrcat(pool, "/", target, NULL);
lmb.eldest = NULL;
lmb.pool = pool;
/* Accumulate revision metadata by walking the revisions
backwards; this allows us to follow moves/copies
correctly. */
SVN_ERR (ra_lib->get_log (ra_session,
condensed_targets,
frb->end_rev,
frb->start_rev,
TRUE,
FALSE,
log_message_receiver,
&lmb,
pool));
/* Inspect the first revision's change metadata; if there are any
prior revisions, compute a new starting revision/path. If no
revisions were selected, no blame is assigned. A modified
item certainly has a prior revision. It is reasonable for an
added item to have none, but anything else is unexpected. */
if (!lmb.eldest)
{
lmb.eldest = apr_palloc (pool, sizeof (*rev));
lmb.eldest->revision = frb->end_rev;
lmb.eldest->path = lmb.path;
lmb.eldest->next = NULL;
rev = apr_palloc (pool, sizeof (*rev));
rev->revision = SVN_INVALID_REVNUM;
rev->author = NULL;
rev->date = NULL;
frb->blame = blame_create (frb, rev, 0);
}
else if (lmb.action == 'M' || SVN_IS_VALID_REVNUM (lmb.copyrev))
{
rev = apr_palloc (pool, sizeof (*rev));
if (SVN_IS_VALID_REVNUM (lmb.copyrev))
rev->revision = lmb.copyrev;
else
rev->revision = lmb.eldest->revision - 1;
rev->path = lmb.path;
rev->next = lmb.eldest;
lmb.eldest = rev;
rev = apr_palloc (pool, sizeof (*rev));
rev->revision = SVN_INVALID_REVNUM;
rev->author = NULL;
rev->date = NULL;
frb->blame = blame_create (frb, rev, 0);
}
else if (lmb.action == 'A')
{
frb->blame = blame_create (frb, lmb.eldest, 0);
}
else
return svn_error_createf (APR_EGENERAL, NULL,
("Revision action '%c' for "
"revision %ld of '%s' "
"lacks a prior revision"),
lmb.action, lmb.eldest->revision,
lmb.eldest->path);
/* Walk the revision list in chronological order, downloading
each fulltext, diffing it with its predecessor, and accumulating
the blame information into db.blame. Use two iteration pools
rather than one, because the diff routines need to look at a
sliding window of revisions. Two pools gives us a ring buffer
of sorts. */
for (rev = lmb.eldest; rev; rev = rev->next)
{
const char *tmp;
const char *temp_dir;
apr_hash_t *props;
svn_string_t *mimetype;
apr_pool_clear (frb->currpool);
SVN_ERR (svn_io_temp_dir (&temp_dir, frb->currpool));
SVN_ERR (svn_io_open_unique_file (&file, &tmp,
svn_path_join (temp_dir, "tmp", frb->currpool), ".tmp",
FALSE, frb->currpool));
apr_pool_cleanup_register (frb->currpool, file, cleanup_tempfile,
apr_pool_cleanup_null);
stream = svn_stream_from_aprfile (file, frb->currpool);
SVN_ERR (ra_lib->get_file(ra_session, rev->path + 1, rev->revision,
stream, NULL, &props, frb->currpool));
SVN_ERR (svn_stream_close (stream));
SVN_ERR (svn_io_file_close (file, frb->currpool));
/* If this file has a non-textual mime-type, bail out. */
if (props &&
((mimetype = apr_hash_get (props, SVN_PROP_MIME_TYPE,
sizeof (SVN_PROP_MIME_TYPE) - 1))))
{
if (svn_mime_type_is_binary (mimetype->data))
return svn_error_createf (SVN_ERR_CLIENT_IS_BINARY_FILE, 0,
("Cannot calculate blame information for binary file '%s'"),target);
}
if (frb->last_filename)
{
frb->rev = rev;
SVN_ERR (add_file_blame (frb->last_filename, tmp, frb));
}
frb->last_filename = tmp;
{
apr_pool_t *tmppool = frb->currpool;
frb->currpool = frb->lastpool;
frb->lastpool = tmppool;
}
}
return SVN_NO_ERROR;
}
