svn_diff_file_options_t * CDiffData::CreateDiffFileOptions(DWORD dwIgnoreWS, bool bIgnoreEOL, apr_pool_t * pool)
{
svn_diff_file_options_t * options = svn_diff_file_options_create(pool);
options->ignore_eol_style = bIgnoreEOL;
options->ignore_space = GetIgnoreSpaceMode(dwIgnoreWS);
return options;
}
svn_error_t *
svn_diff_file_diff(svn_diff_t **diff,
const char *original,
const char *modified,
apr_pool_t *pool)
{
return svn_diff_file_diff_2(diff, original, modified,
svn_diff_file_options_create(pool), pool);
}
svn_error_t *
svn_diff_file_diff4(svn_diff_t **diff,
const char *original,
const char *modified,
const char *latest,
const char *ancestor,
apr_pool_t *pool)
{
return svn_diff_file_diff4_2(diff, original, modified, latest, ancestor,
svn_diff_file_options_create(pool), pool);
}
apr_array_header_t *svn_support_blame_call(char *file_path,
int revision,
apr_pool_t *subpool)
{
svn_error_t *err;
svn_opt_revision_t peg_rev,start,end;
svn_diff_file_options_t *diff_options;
// -- Initialisation des révisions --
if (revision != -1) {
peg_rev.kind = end.kind = svn_opt_revision_number;
peg_rev.value.number = end.value.number = revision;
}
else {
peg_rev.kind = svn_opt_revision_unspecified;
end.kind = svn_opt_revision_head;
}
start.kind = svn_opt_revision_number;
start.value.number = 1;
// -- Initialisation des diff_options --
diff_options = svn_diff_file_options_create(pool);
// -- Initialisation du tableau et du buffer de résultats --
apr_array_header_t *list_result = apr_array_make(pool, 1, sizeof (const char *));
svn_stringbuf_t *res = svn_stringbuf_create("",pool);
err = svn_client_blame4(file_path,
&peg_rev,
&start,
&end,
diff_options,
FALSE, // ignore_mime_type
FALSE, // include_merged_revisions
blame_callback,
res,
ctx,
pool);
if (err) {
svn_handle_error2(err, stderr, FALSE, "svn_support_blame: ");
svn_pool_destroy(subpool);
return NULL;
}
svn_cstring_split_append(list_result,res->data,"\n",FALSE,pool);
svn_pool_destroy(subpool);
return list_result;
}
svn_error_t *
svn_client_blame2(const char *target,
const svn_opt_revision_t *peg_revision,
const svn_opt_revision_t *start,
const svn_opt_revision_t *end,
svn_client_blame_receiver_t receiver,
void *receiver_baton,
svn_client_ctx_t *ctx,
apr_pool_t *pool)
{
wrap_pre_blame3_receiver(&receiver, &receiver_baton, pool);
return svn_client_blame3(target, peg_revision, start, end,
svn_diff_file_options_create(pool), FALSE,
receiver, receiver_baton, ctx, pool);
}
bool CAppUtils::CreateUnifiedDiff(const CString& orig, const CString& modified, const CString& output, bool bShowError)
{
apr_file_t * outfile = NULL;
apr_pool_t * pool = svn_pool_create(NULL);
svn_error_t * err = svn_io_file_open (&outfile, svn_path_internal_style(CUnicodeUtils::GetUTF8(output), pool),
APR_WRITE | APR_CREATE | APR_BINARY | APR_TRUNCATE,
APR_OS_DEFAULT, pool);
if (err == NULL)
{
svn_stream_t * stream = svn_stream_from_aprfile2(outfile, false, pool);
if (stream)
{
svn_diff_t * diff = NULL;
svn_diff_file_options_t * opts = svn_diff_file_options_create(pool);
opts->ignore_eol_style = false;
opts->ignore_space = svn_diff_file_ignore_space_none;
err = svn_diff_file_diff_2(&diff, svn_path_internal_style(CUnicodeUtils::GetUTF8(orig), pool),
svn_path_internal_style(CUnicodeUtils::GetUTF8(modified), pool), opts, pool);
if (err == NULL)
{
err = svn_diff_file_output_unified(stream, diff, svn_path_internal_style(CUnicodeUtils::GetUTF8(orig), pool),
svn_path_internal_style(CUnicodeUtils::GetUTF8(modified), pool),
NULL, NULL, pool);
svn_stream_close(stream);
}
}
apr_file_close(outfile);
}
if (err)
{
if (bShowError)
AfxMessageBox(CAppUtils::GetErrorString(err), MB_ICONERROR);
svn_error_clear(err);
svn_pool_destroy(pool);
return false;
}
svn_pool_destroy(pool);
return true;
}
int main(int argc, const char *argv[])
{
apr_pool_t *pool;
svn_stream_t *ostream;
svn_error_t *svn_err;
svn_boolean_t has_changes;
svn_diff_file_options_t *diff_options;
apr_array_header_t *options_array;
int i;
const char *from = NULL;
const char *to = NULL;
svn_boolean_t show_c_function = FALSE;
svn_boolean_t no_more_options = FALSE;
apr_initialize();
atexit(apr_terminate);
pool = svn_pool_create(NULL);
svn_err = svn_stream_for_stdout(&ostream, pool);
if (svn_err)
{
svn_handle_error2(svn_err, stdout, FALSE, "diff: ");
return 2;
}
options_array = apr_array_make(pool, 0, sizeof(const char *));
diff_options = svn_diff_file_options_create(pool);
for (i = 1 ; i < argc ; i++)
{
if (!no_more_options && (argv[i][0] == '-'))
{
/* Special case: '--' means "no more options follow" */
if (argv[i][1] == '-' && !argv[i][2])
{
no_more_options = TRUE;
continue;
}
/* Special case: we need to detect '-p' and handle it specially */
if (argv[i][1] == 'p' && !argv[i][2])
{
show_c_function = TRUE;
continue;
}
if (argv[i][1] == 'w' && !argv[i][2])
{
diff_options->ignore_space = svn_diff_file_ignore_space_all;
continue;
}
APR_ARRAY_PUSH(options_array, const char *) = argv[i];
/* Special case: '-U' takes an argument, so capture the
* next argument in the array. */
if (argv[i][1] == 'U' && !argv[i][2])
{
i++;
APR_ARRAY_PUSH(options_array, const char *) = argv[i];
}
}
else
{
if (from == NULL)
from = argv[i];
else if (to == NULL)
to = argv[i];
else
{
print_usage(ostream, argv[0], pool);
return 2;
}
}
}
if (!from || !to)
{
print_usage(ostream, argv[0], pool);
return 2;
}
svn_err = svn_diff_file_options_parse(diff_options, options_array, pool);
if (svn_err)
{
svn_handle_error2(svn_err, stdout, FALSE, "diff: ");
return 2;
}
svn_err = do_diff(ostream, from, to, &has_changes,
diff_options, show_c_function, pool);
if (svn_err)
{
svn_handle_error2(svn_err, stdout, FALSE, "diff: ");
return 2;
}
return has_changes ? 1 : 0;
}
JNIEXPORT void JNICALL
Java_org_apache_subversion_javahl_util_DiffLib_nativeFileDiff(
JNIEnv* env, jobject jthis,
jstring joriginal_file,
jstring jmodified_file,
jint jignore_space_ordinal,
jboolean jignore_eol_style,
jboolean jshow_c_function,
jstring joriginal_header,
jstring jmodified_header,
jstring jheader_encoding,
jstring jrelative_to_dir,
jobject jresult_stream)
{
JNIEntry(DiffLib, nativeFileDiff);
// Using a "global" request pool since we don't keep a context with
// its own pool around for these functions.
SVN::Pool pool;
Path original(joriginal_file, pool);
if (JNIUtil::isJavaExceptionThrown())
return;
SVN_JNI_ERR(original.error_occurred(),);
Path modified(jmodified_file, pool);
if (JNIUtil::isJavaExceptionThrown())
return;
SVN_JNI_ERR(modified.error_occurred(),);
svn_diff_t* diff;
svn_diff_file_options_t* diff_options =
svn_diff_file_options_create(pool.getPool());
diff_options->ignore_space =
svn_diff_file_ignore_space_t(jignore_space_ordinal);
diff_options->ignore_eol_style = svn_boolean_t(jignore_eol_style);
diff_options->show_c_function = svn_boolean_t(jshow_c_function);
SVN_JNI_ERR(svn_diff_file_diff_2(&diff,
original.c_str(),
modified.c_str(),
diff_options,
pool.getPool()),);
JNIStringHolder original_header(joriginal_header);
if (JNIUtil::isJavaExceptionThrown())
return;
JNIStringHolder modified_header(jmodified_header);
if (JNIUtil::isJavaExceptionThrown())
return;
JNIStringHolder header_encoding(jheader_encoding);
if (JNIUtil::isJavaExceptionThrown())
return;
JNIStringHolder relative_to_dir(jrelative_to_dir);
if (JNIUtil::isJavaExceptionThrown())
return;
OutputStream result_stream(jresult_stream);
SVN_JNI_ERR(svn_diff_file_output_unified3(
result_stream.getStream(pool), diff,
original.c_str(), modified.c_str(),
original_header.c_str(), modified_header.c_str(),
header_encoding.c_str(), relative_to_dir.c_str(),
diff_options->show_c_function,
pool.getPool()),);
}
JNIEXPORT void JNICALL
Java_org_apache_subversion_javahl_util_DiffLib_nativeFileMerge(
JNIEnv* env, jobject jthis,
jstring joriginal_file,
jstring jmodified_file,
jstring jlatest_file,
jint jignore_space_ordinal,
jboolean jignore_eol_style,
jboolean jshow_c_function,
jstring jconflict_original,
jstring jconflict_modified,
jstring jconflict_latest,
jstring jconflict_separator,
jint jconflict_style_ordinal,
jobject jresult_stream)
{
JNIEntry(DiffLib, nativeFileMerge);
// Using a "global" request pool since we don't keep a context with
// its own pool around for these functions.
SVN::Pool pool;
Path original(joriginal_file, pool);
if (JNIUtil::isJavaExceptionThrown())
return;
SVN_JNI_ERR(original.error_occurred(),);
Path modified(jmodified_file, pool);
if (JNIUtil::isJavaExceptionThrown())
return;
SVN_JNI_ERR(modified.error_occurred(),);
Path latest(jlatest_file, pool);
if (JNIUtil::isJavaExceptionThrown())
return;
SVN_JNI_ERR(latest.error_occurred(),);
svn_diff_t* diff;
svn_diff_file_options_t* diff_options =
svn_diff_file_options_create(pool.getPool());
diff_options->ignore_space =
svn_diff_file_ignore_space_t(jignore_space_ordinal);
diff_options->ignore_eol_style = svn_boolean_t(jignore_eol_style);
diff_options->show_c_function = svn_boolean_t(jshow_c_function);
SVN_JNI_ERR(svn_diff_file_diff3_2(&diff,
original.c_str(),
modified.c_str(),
latest.c_str(),
diff_options,
pool.getPool()),);
JNIStringHolder conflict_original(jconflict_original);
if (JNIUtil::isJavaExceptionThrown())
return;
JNIStringHolder conflict_modified(jconflict_modified);
if (JNIUtil::isJavaExceptionThrown())
return;
JNIStringHolder conflict_latest(jconflict_latest);
if (JNIUtil::isJavaExceptionThrown())
return;
JNIStringHolder conflict_separator(jconflict_separator);
if (JNIUtil::isJavaExceptionThrown())
return;
OutputStream result_stream(jresult_stream);
SVN_JNI_ERR(svn_diff_file_output_merge2(
result_stream.getStream(pool), diff,
original.c_str(), modified.c_str(), latest.c_str(),
conflict_original.c_str(),
conflict_modified.c_str(),
conflict_latest.c_str(),
conflict_separator.c_str(),
svn_diff_conflict_display_style_t(jconflict_style_ordinal),
pool.getPool()),);
}
/* This implements the `svn_opt_subcommand_t' interface. */
svn_error_t *
svn_cl__blame(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_pool_t *subpool;
apr_array_header_t *targets;
blame_baton_t bl;
int i;
svn_boolean_t end_revision_unspecified = FALSE;
svn_diff_file_options_t *diff_options = svn_diff_file_options_create(pool);
svn_boolean_t seen_nonexistent_target = FALSE;
SVN_ERR(svn_cl__args_to_target_array_print_reserved(&targets, os,
opt_state->targets,
ctx, FALSE, pool));
/* Blame needs a file on which to operate. */
if (! targets->nelts)
return svn_error_create(SVN_ERR_CL_INSUFFICIENT_ARGS, 0, NULL);
if (opt_state->end_revision.kind == svn_opt_revision_unspecified)
{
if (opt_state->start_revision.kind != svn_opt_revision_unspecified)
{
/* In the case that -rX was specified, we actually want to set the
range to be -r1:X. */
opt_state->end_revision = opt_state->start_revision;
opt_state->start_revision.kind = svn_opt_revision_number;
opt_state->start_revision.value.number = 1;
}
else
end_revision_unspecified = TRUE;
}
if (opt_state->start_revision.kind == svn_opt_revision_unspecified)
{
opt_state->start_revision.kind = svn_opt_revision_number;
opt_state->start_revision.value.number = 1;
}
/* The final conclusion from issue #2431 is that blame info
is client output (unlike 'svn cat' which plainly cats the file),
so the EOL style should be the platform local one.
*/
if (! opt_state->xml)
SVN_ERR(svn_stream_for_stdout(&bl.out, pool));
else
bl.sbuf = svn_stringbuf_create("", pool);
bl.opt_state = opt_state;
subpool = svn_pool_create(pool);
if (opt_state->extensions)
{
apr_array_header_t *opts;
opts = svn_cstring_split(opt_state->extensions, " \t\n\r", TRUE, pool);
SVN_ERR(svn_diff_file_options_parse(diff_options, opts, pool));
}
if (opt_state->xml)
{
if (opt_state->verbose)
return svn_error_create(SVN_ERR_CL_ARG_PARSING_ERROR, NULL,
_("'verbose' option invalid in XML mode"));
/* If output is not incremental, output the XML header and wrap
everything in a top-level element. This makes the output in
its entirety a well-formed XML document. */
if (! opt_state->incremental)
SVN_ERR(svn_cl__xml_print_header("blame", pool));
}
else
{
if (opt_state->incremental)
return svn_error_create(SVN_ERR_CL_ARG_PARSING_ERROR, NULL,
_("'incremental' option only valid in XML "
"mode"));
}
for (i = 0; i < targets->nelts; i++)
{
svn_error_t *err;
const char *target = APR_ARRAY_IDX(targets, i, const char *);
const char *truepath;
svn_opt_revision_t peg_revision;
svn_client_blame_receiver3_t receiver;
svn_pool_clear(subpool);
SVN_ERR(svn_cl__check_cancel(ctx->cancel_baton));
/* Check for a peg revision. */
SVN_ERR(svn_opt_parse_path(&peg_revision, &truepath, target,
subpool));
if (end_revision_unspecified)
{
if (peg_revision.kind != svn_opt_revision_unspecified)
opt_state->end_revision = peg_revision;
else if (svn_path_is_url(target))
opt_state->end_revision.kind = svn_opt_revision_head;
else
opt_state->end_revision.kind = svn_opt_revision_working;
}
if (opt_state->xml)
{
/* "<target ...>" */
/* We don't output this tag immediately, which avoids creating
a target element if this path is skipped. */
const char *outpath = truepath;
if (! svn_path_is_url(target))
outpath = svn_dirent_local_style(truepath, subpool);
svn_xml_make_open_tag(&bl.sbuf, pool, svn_xml_normal, "target",
"path", outpath, NULL);
receiver = blame_receiver_xml;
}
else
receiver = blame_receiver;
err = svn_client_blame5(truepath,
&peg_revision,
&opt_state->start_revision,
&opt_state->end_revision,
diff_options,
opt_state->force,
opt_state->use_merge_history,
receiver,
&bl,
ctx,
subpool);
if (err)
{
if (err->apr_err == SVN_ERR_CLIENT_IS_BINARY_FILE)
{
svn_error_clear(err);
SVN_ERR(svn_cmdline_fprintf(stderr, subpool,
_("Skipping binary file: '%s'\n"),
target));
}
else if (err->apr_err == SVN_ERR_WC_PATH_NOT_FOUND ||
err->apr_err == SVN_ERR_FS_NOT_FILE ||
err->apr_err == SVN_ERR_FS_NOT_FOUND)
{
svn_handle_warning2(stderr, err, "svn: ");
svn_error_clear(err);
err = NULL;
seen_nonexistent_target = TRUE;
}
else
{
return svn_error_trace(err);
}
}
else if (opt_state->xml)
{
/* "</target>" */
svn_xml_make_close_tag(&(bl.sbuf), pool, "target");
SVN_ERR(svn_cl__error_checked_fputs(bl.sbuf->data, stdout));
}
if (opt_state->xml)
svn_stringbuf_setempty(bl.sbuf);
}
svn_pool_destroy(subpool);
if (opt_state->xml && ! opt_state->incremental)
SVN_ERR(svn_cl__xml_print_footer("blame", pool));
if (seen_nonexistent_target)
return svn_error_create(
SVN_ERR_ILLEGAL_TARGET, NULL,
_("Could not perform blame on all targets because some "
"targets don't exist"));
else
return SVN_NO_ERROR;
}
/* Internal version of svn_wc_merge, also used to (loggily) merge updates
from the repository.
In the case of updating, the update can have sent new properties,
which could affect the way the wc target is detranslated and
compared with LEFT and RIGHT for merging.
Property changes sent by the update are provided in PROP_DIFF.
If COPYFROM_TEXT is non-null, the working text is taken from this
file instead of from the actual version in the working copy (and
the merge_target is allowed to not be under version control in this
case).
*/
svn_error_t *
svn_wc__merge_internal(svn_stringbuf_t **log_accum,
enum svn_wc_merge_outcome_t *merge_outcome,
const char *left,
const char *right,
const char *merge_target,
const char *copyfrom_text,
svn_wc_adm_access_t *adm_access,
const char *left_label,
const char *right_label,
const char *target_label,
svn_boolean_t dry_run,
const char *diff3_cmd,
const apr_array_header_t *merge_options,
const apr_array_header_t *prop_diff,
svn_wc_conflict_resolver_func_t conflict_func,
void *conflict_baton,
apr_pool_t *pool)
{
const char *tmp_target, *result_target, *working_text;
const char *adm_path = svn_wc_adm_access_path(adm_access);
apr_file_t *result_f;
svn_boolean_t is_binary = FALSE;
const svn_wc_entry_t *entry;
svn_boolean_t contains_conflicts;
const svn_prop_t *mimeprop;
/* Sanity check: the merge target must be under revision control (unless
this is an add-with-history). */
SVN_ERR(svn_wc_entry(&entry, merge_target, adm_access, FALSE, pool));
if (! entry && ! copyfrom_text)
{
*merge_outcome = svn_wc_merge_no_merge;
return SVN_NO_ERROR;
}
/* Decide if the merge target is a text or binary file. */
if ((mimeprop = get_prop(prop_diff, SVN_PROP_MIME_TYPE))
&& mimeprop->value)
is_binary = svn_mime_type_is_binary(mimeprop->value->data);
else if (! copyfrom_text)
SVN_ERR(svn_wc_has_binary_prop(&is_binary, merge_target, adm_access, pool));
working_text = copyfrom_text ? copyfrom_text : merge_target;
SVN_ERR(detranslate_wc_file(&tmp_target, working_text, adm_access,
(! is_binary) && diff3_cmd != NULL,
prop_diff, pool));
/* We cannot depend on the left file to contain the same eols as the
right file. If the merge target has mods, this will mark the entire
file as conflicted, so we need to compensate. */
SVN_ERR(maybe_update_target_eols(&left, left, adm_access, prop_diff, pool));
if (! is_binary) /* this is a text file */
{
/* Open a second temporary file for writing; this is where diff3
will write the merged results. */
SVN_ERR(svn_wc_create_tmp_file2(&result_f, &result_target,
adm_path, svn_io_file_del_none,
pool));
/* Run an external merge if requested. */
if (diff3_cmd)
{
int exit_code;
SVN_ERR(svn_io_run_diff3_2(&exit_code, ".",
tmp_target, left, right,
target_label, left_label, right_label,
result_f, diff3_cmd,
merge_options, pool));
contains_conflicts = exit_code == 1;
}
else
{
svn_diff_t *diff;
const char *target_marker;
const char *left_marker;
const char *right_marker;
svn_stream_t *ostream;
svn_diff_file_options_t *options;
ostream = svn_stream_from_aprfile(result_f, pool);
options = svn_diff_file_options_create(pool);
if (merge_options)
SVN_ERR(svn_diff_file_options_parse(options, merge_options, pool));
SVN_ERR(svn_diff_file_diff3_2(&diff,
left, tmp_target, right,
options, pool));
/* Labels fall back to sensible defaults if not specified. */
if (target_label)
target_marker = apr_psprintf(pool, "<<<<<<< %s", target_label);
else
target_marker = "<<<<<<< .working";
if (left_label)
left_marker = apr_psprintf(pool, "||||||| %s", left_label);
else
left_marker = "||||||| .old";
if (right_label)
right_marker = apr_psprintf(pool, ">>>>>>> %s", right_label);
else
right_marker = ">>>>>>> .new";
SVN_ERR(svn_diff_file_output_merge(ostream, diff,
left, tmp_target, right,
left_marker,
target_marker,
right_marker,
"=======", /* seperator */
FALSE, /* display original */
FALSE, /* resolve conflicts */
pool));
SVN_ERR(svn_stream_close(ostream));
contains_conflicts = svn_diff_contains_conflicts(diff);
}
/* Close the output file */
SVN_ERR(svn_io_file_close(result_f, pool));
if (contains_conflicts && ! dry_run) /* got a conflict */
{
const char *left_copy, *right_copy, *target_copy;
const char *tmp_left, *tmp_right, *tmp_target_copy;
const char *parentt, *target_base;
svn_wc_adm_access_t *parent_access;
svn_wc_entry_t tmp_entry;
/* Give the conflict resolution callback a chance to clean
up the conflict before we mark the file 'conflicted' */
if (conflict_func)
{
svn_wc_conflict_result_t *result = NULL;
svn_wc_conflict_description_t cdesc;
cdesc.path = merge_target;
cdesc.node_kind = svn_node_file;
cdesc.kind = svn_wc_conflict_kind_text;
cdesc.is_binary = FALSE;
cdesc.mime_type = (mimeprop && mimeprop->value)
? mimeprop->value->data : NULL;
cdesc.access = adm_access;
cdesc.action = svn_wc_conflict_action_edit;
cdesc.reason = svn_wc_conflict_reason_edited;
cdesc.base_file = left;
cdesc.their_file = right;
cdesc.my_file = tmp_target;
cdesc.merged_file = result_target;
cdesc.property_name = NULL;
SVN_ERR(conflict_func(&result, &cdesc, conflict_baton, pool));
if (result == NULL)
return svn_error_create(SVN_ERR_WC_CONFLICT_RESOLVER_FAILURE,
NULL, _("Conflict callback violated API:"
" returned no results"));
switch (result->choice)
{
/* If the callback wants to use one of the fulltexts
to resolve the conflict, so be it.*/
case svn_wc_conflict_choose_base:
{
SVN_ERR(svn_wc__loggy_copy
(log_accum, NULL, adm_access,
svn_wc__copy_translate,
left, merge_target,
FALSE, pool));
*merge_outcome = svn_wc_merge_merged;
contains_conflicts = FALSE;
goto merge_complete;
}
case svn_wc_conflict_choose_theirs_full:
{
SVN_ERR(svn_wc__loggy_copy
(log_accum, NULL, adm_access,
svn_wc__copy_translate,
right, merge_target,
FALSE, pool));
*merge_outcome = svn_wc_merge_merged;
contains_conflicts = FALSE;
goto merge_complete;
}
case svn_wc_conflict_choose_mine_full:
{
/* Do nothing to merge_target, let it live untouched! */
*merge_outcome = svn_wc_merge_merged;
contains_conflicts = FALSE;
goto merge_complete;
}
/* For the case of 3-way file merging, we don't
really distinguish between these return values;
if the callback claims to have "generally
resolved" the situation, we still interpret
that as "OK, we'll assume the merged version is
good to use". */
case svn_wc_conflict_choose_merged:
{
SVN_ERR(svn_wc__loggy_copy
(log_accum, NULL, adm_access,
svn_wc__copy_translate,
/* Look for callback's own merged-file first: */
result->merged_file ?
result->merged_file : result_target,
merge_target,
FALSE, pool));
*merge_outcome = svn_wc_merge_merged;
contains_conflicts = FALSE;
goto merge_complete;
}
case svn_wc_conflict_choose_postpone:
default:
{
/* Assume conflict remains, fall through to code below. */
}
}
}
/* Preserve the three pre-merge files, and modify the
entry (mark as conflicted, track the preserved files). */
/* I miss Lisp. */
SVN_ERR(svn_io_open_unique_file2(NULL,
&left_copy,
merge_target,
left_label,
svn_io_file_del_none,
pool));
/* Have I mentioned how much I miss Lisp? */
SVN_ERR(svn_io_open_unique_file2(NULL,
&right_copy,
merge_target,
right_label,
svn_io_file_del_none,
pool));
/* Why, how much more pleasant to be forced to unroll my loops.
If I'd been writing in Lisp, I might have mapped an inline
lambda form over a list, or something equally disgusting.
Thank goodness C was here to protect me! */
SVN_ERR(svn_io_open_unique_file2(NULL,
&target_copy,
merge_target,
target_label,
svn_io_file_del_none,
pool));
/* We preserve all the files with keywords expanded and line
endings in local (working) form. */
svn_path_split(target_copy, &parentt, &target_base, pool);
SVN_ERR(svn_wc_adm_retrieve(&parent_access, adm_access, parentt,
pool));
/* Log files require their paths to be in the subtree
relative to the adm_access path they are executed in.
Make our LEFT and RIGHT files 'local' if they aren't... */
if (! svn_path_is_child(adm_path, left, pool))
{
SVN_ERR(svn_wc_create_tmp_file2
(NULL, &tmp_left,
adm_path, svn_io_file_del_none, pool));
SVN_ERR(svn_io_copy_file(left, tmp_left, TRUE, pool));
}
else
tmp_left = left;
if (! svn_path_is_child(adm_path, right, pool))
{
SVN_ERR(svn_wc_create_tmp_file2
(NULL, &tmp_right,
adm_path, svn_io_file_del_none, pool));
SVN_ERR(svn_io_copy_file(right, tmp_right, TRUE, pool));
}
else
tmp_right = right;
/* NOTE: Callers must ensure that the svn:eol-style and
svn:keywords property values are correct in the currently
installed props. With 'svn merge', it's no big deal. But
when 'svn up' calls this routine, it needs to make sure that
this routine is using the newest property values that may
have been received *during* the update. Since this routine
will be run from within a log-command, merge_file()
needs to make sure that a previous log-command to 'install
latest props' has already executed first. Ben and I just
checked, and that is indeed the order in which the log items
are written, so everything should be fine. Really. */
/* Create LEFT and RIGHT backup files, in expanded form.
We use merge_target's current properties to do the translation. */
/* Derive the basenames of the 3 backup files. */
SVN_ERR(svn_wc__loggy_translated_file(log_accum,
adm_access,
left_copy, tmp_left,
merge_target, pool));
SVN_ERR(svn_wc__loggy_translated_file(log_accum,
adm_access,
right_copy, tmp_right,
merge_target, pool));
/* Back up MERGE_TARGET through detranslation/retranslation:
the new translation properties may not match the current ones */
SVN_ERR(svn_wc_translated_file2(&tmp_target_copy,
merge_target,
merge_target,
adm_access,
SVN_WC_TRANSLATE_TO_NF
| SVN_WC_TRANSLATE_NO_OUTPUT_CLEANUP,
pool));
SVN_ERR(svn_wc__loggy_translated_file
(log_accum, adm_access,
target_copy, tmp_target_copy, merge_target, pool));
tmp_entry.conflict_old
= svn_path_is_child(adm_path, left_copy, pool);
tmp_entry.conflict_new
= svn_path_is_child(adm_path, right_copy, pool);
tmp_entry.conflict_wrk = target_base;
/* Mark merge_target's entry as "Conflicted", and start tracking
the backup files in the entry as well. */
SVN_ERR(svn_wc__loggy_entry_modify
(log_accum, adm_access,
merge_target, &tmp_entry,
SVN_WC__ENTRY_MODIFY_CONFLICT_OLD
| SVN_WC__ENTRY_MODIFY_CONFLICT_NEW
| SVN_WC__ENTRY_MODIFY_CONFLICT_WRK,
pool));
*merge_outcome = svn_wc_merge_conflict;
}
else if (contains_conflicts && dry_run)
{
*merge_outcome = svn_wc_merge_conflict;
} /* end of conflict handling */
else if (copyfrom_text)
{
*merge_outcome = svn_wc_merge_merged;
}
else
{
svn_boolean_t same, special;
/* If 'special', then use the detranslated form of the
target file. This is so we don't try to follow symlinks,
but the same treatment is probably also appropriate for
whatever special file types we may invent in the future. */
SVN_ERR(svn_wc__get_special(&special, merge_target,
adm_access, pool));
SVN_ERR(svn_io_files_contents_same_p(&same, result_target,
(special ?
tmp_target :
merge_target),
pool));
*merge_outcome = same ? svn_wc_merge_unchanged : svn_wc_merge_merged;
}
if (*merge_outcome != svn_wc_merge_unchanged && ! dry_run)
/* replace MERGE_TARGET with the new merged file, expanding. */
SVN_ERR(svn_wc__loggy_copy(log_accum, NULL,
adm_access,
svn_wc__copy_translate,
result_target, merge_target,
FALSE, pool));
} /* end of merging for text files */
else if (! dry_run) /* merging procedure for binary files */
{
/* ### when making the binary-file backups, should we be honoring
keywords and eol stuff? */
const char *left_copy, *right_copy;
const char *parentt, *left_base, *right_base;
svn_wc_entry_t tmp_entry;
/* Give the conflict resolution callback a chance to clean
up the conflict before we mark the file 'conflicted' */
if (conflict_func)
{
svn_wc_conflict_result_t *result = NULL;
svn_wc_conflict_description_t cdesc;
cdesc.path = merge_target;
cdesc.node_kind = svn_node_file;
cdesc.kind = svn_wc_conflict_kind_text;
cdesc.is_binary = TRUE;
cdesc.mime_type = (mimeprop && mimeprop->value)
? mimeprop->value->data : NULL;
cdesc.access = adm_access;
cdesc.action = svn_wc_conflict_action_edit;
cdesc.reason = svn_wc_conflict_reason_edited;
cdesc.base_file = left;
cdesc.their_file = right;
cdesc.my_file = tmp_target;
cdesc.merged_file = NULL; /* notice there is NO merged file! */
cdesc.property_name = NULL;
SVN_ERR(conflict_func(&result, &cdesc, conflict_baton, pool));
if (result == NULL)
return svn_error_create(SVN_ERR_WC_CONFLICT_RESOLVER_FAILURE,
NULL, _("Conflict callback violated API:"
" returned no results"));
switch (result->choice)
{
/* For a binary file, there's no merged file to look at,
unless the conflict-callback did the merging itself. */
case svn_wc_conflict_choose_base:
{
SVN_ERR(svn_wc__loggy_copy
(log_accum, NULL, adm_access,
svn_wc__copy_translate,
left, merge_target,
FALSE, pool));
*merge_outcome = svn_wc_merge_merged;
contains_conflicts = FALSE;
goto merge_complete;
}
case svn_wc_conflict_choose_theirs_full:
{
SVN_ERR(svn_wc__loggy_copy
(log_accum, NULL, adm_access,
svn_wc__copy_translate,
right, merge_target,
FALSE, pool));
*merge_outcome = svn_wc_merge_merged;
contains_conflicts = FALSE;
goto merge_complete;
}
/* For a binary file, if the response is to use the
user's file, we do nothing. We also do nothing if
the response claims to have already resolved the
problem.*/
case svn_wc_conflict_choose_mine_full:
{
*merge_outcome = svn_wc_merge_merged;
contains_conflicts = FALSE;
goto merge_complete;
}
case svn_wc_conflict_choose_merged:
{
if (! result->merged_file)
{
/* Callback asked us to choose its own
merged file, but didn't provide one! */
return svn_error_create
(SVN_ERR_WC_CONFLICT_RESOLVER_FAILURE,
NULL, _("Conflict callback violated API:"
" returned no merged file"));
}
else
{
SVN_ERR(svn_wc__loggy_copy
(log_accum, NULL, adm_access,
svn_wc__copy_translate,
result->merged_file, merge_target,
FALSE, pool));
*merge_outcome = svn_wc_merge_merged;
contains_conflicts = FALSE;
goto merge_complete;
}
}
case svn_wc_conflict_choose_postpone:
default:
{
/* Assume conflict remains, fall through to code below. */
}
}
}
/* reserve names for backups of left and right fulltexts */
SVN_ERR(svn_io_open_unique_file2(NULL,
&left_copy,
merge_target,
left_label,
svn_io_file_del_none,
pool));
SVN_ERR(svn_io_open_unique_file2(NULL,
&right_copy,
merge_target,
right_label,
svn_io_file_del_none,
pool));
/* create the backup files */
SVN_ERR(svn_io_copy_file(left,
left_copy, TRUE, pool));
SVN_ERR(svn_io_copy_file(right,
right_copy, TRUE, pool));
/* Was the merge target detranslated? */
if (merge_target != tmp_target)
{
/* Create a .mine file too */
const char *mine_copy;
SVN_ERR(svn_io_open_unique_file2(NULL,
&mine_copy,
merge_target,
target_label,
svn_io_file_del_none,
pool));
SVN_ERR(svn_wc__loggy_move(log_accum, NULL,
adm_access,
tmp_target,
mine_copy,
FALSE, pool));
mine_copy = svn_path_is_child(adm_path, mine_copy, pool);
tmp_entry.conflict_wrk = mine_copy;
}
else
tmp_entry.conflict_wrk = NULL;
/* Derive the basenames of the backup files. */
svn_path_split(left_copy, &parentt, &left_base, pool);
svn_path_split(right_copy, &parentt, &right_base, pool);
/* Mark merge_target's entry as "Conflicted", and start tracking
the backup files in the entry as well. */
tmp_entry.conflict_old = left_base;
tmp_entry.conflict_new = right_base;
SVN_ERR(svn_wc__loggy_entry_modify
(log_accum,
adm_access, merge_target,
&tmp_entry,
SVN_WC__ENTRY_MODIFY_CONFLICT_OLD
| SVN_WC__ENTRY_MODIFY_CONFLICT_NEW
| SVN_WC__ENTRY_MODIFY_CONFLICT_WRK,
pool));
*merge_outcome = svn_wc_merge_conflict; /* a conflict happened */
} /* end of binary conflict handling */
else
*merge_outcome = svn_wc_merge_conflict; /* dry_run for binary files. */
merge_complete:
/* Merging is complete. Regardless of text or binariness, we might
need to tweak the executable bit on the new working file. */
if (! dry_run)
{
SVN_ERR(svn_wc__loggy_maybe_set_executable(log_accum,
adm_access, merge_target,
pool));
SVN_ERR(svn_wc__loggy_maybe_set_readonly(log_accum,
adm_access, merge_target,
pool));
}
return SVN_NO_ERROR;
}
Py::Object pysvn_client::cmd_annotate( const Py::Tuple &a_args, const Py::Dict &a_kws )
{
static argument_description args_desc[] =
{
{ true, name_url_or_path },
{ false, name_revision_start },
{ false, name_revision_end },
#if defined( PYSVN_HAS_CLIENT_ANNOTATE2 )
{ false, name_peg_revision },
#endif
#if defined( PYSVN_HAS_CLIENT_ANNOTATE3 )
{ false, name_ignore_space },
{ false, name_ignore_eol_style },
{ false, name_ignore_mime_type },
#endif
#if defined( PYSVN_HAS_CLIENT_ANNOTATE4 )
{ false, name_include_merged_revisions },
#endif
{ false, NULL }
};
FunctionArguments args( "annotate", args_desc, a_args, a_kws );
args.check();
std::string path( args.getUtf8String( name_url_or_path, empty_string ) );
svn_opt_revision_t revision_start = args.getRevision( name_revision_start, svn_opt_revision_number );
svn_opt_revision_t revision_end = args.getRevision( name_revision_end, svn_opt_revision_head );
#if defined( PYSVN_HAS_CLIENT_ANNOTATE2 )
svn_opt_revision_t peg_revision = args.getRevision( name_peg_revision, revision_end );
#endif
#if defined( PYSVN_HAS_CLIENT_ANNOTATE3 )
svn_diff_file_ignore_space_t ignore_space = svn_diff_file_ignore_space_none;
if( args.hasArg( name_ignore_space ) )
{
Py::ExtensionObject< pysvn_enum_value<svn_diff_file_ignore_space_t> > py_ignore_space( args.getArg( name_ignore_space ) );
ignore_space = svn_diff_file_ignore_space_t( py_ignore_space.extensionObject()->m_value );
}
svn_boolean_t ignore_eol_style = args.getBoolean( name_ignore_eol_style, false );
svn_boolean_t ignore_mime_type = args.getBoolean( name_ignore_mime_type, false );
#endif
#if defined( PYSVN_HAS_CLIENT_ANNOTATE4 )
svn_boolean_t include_merged_revisions = args.getBoolean( name_include_merged_revisions, false );
#endif
SvnPool pool( m_context );
#if defined( PYSVN_HAS_CLIENT_ANNOTATE3 )
svn_diff_file_options_t *diff_options = svn_diff_file_options_create( pool );
diff_options->ignore_space = ignore_space;
diff_options->ignore_eol_style = ignore_eol_style;
#endif
bool is_url = is_svn_url( path );
#if defined( PYSVN_HAS_CLIENT_ANNOTATE2 )
revisionKindCompatibleCheck( is_url, peg_revision, name_peg_revision, name_url_or_path );
#endif
revisionKindCompatibleCheck( is_url, revision_start, name_revision_start, name_url_or_path );
revisionKindCompatibleCheck( is_url, revision_end, name_revision_end, name_url_or_path );
std::list<AnnotatedLineInfo> all_entries;
try
{
std::string norm_path( svnNormalisedIfPath( path, pool ) );
checkThreadPermission();
PythonAllowThreads permission( m_context );
#if defined( PYSVN_HAS_CLIENT_ANNOTATE4 )
svn_error_t *error = svn_client_blame4
(
norm_path.c_str(),
&peg_revision,
&revision_start,
&revision_end,
diff_options,
ignore_mime_type,
include_merged_revisions,
annotate_receiver,
&all_entries,
m_context,
pool
);
#elif defined( PYSVN_HAS_CLIENT_ANNOTATE3 )
svn_error_t *error = svn_client_blame3
(
norm_path.c_str(),
&peg_revision,
&revision_start,
&revision_end,
diff_options,
ignore_mime_type,
annotate_receiver,
&all_entries,
m_context,
pool
);
#elif defined( PYSVN_HAS_CLIENT_ANNOTATE2 )
svn_error_t *error = svn_client_blame2
(
norm_path.c_str(),
&peg_revision,
&revision_start,
&revision_end,
annotate_receiver,
&all_entries,
m_context,
pool
);
#else
svn_error_t *error = svn_client_blame
(
norm_path.c_str(),
&revision_start,
&revision_end,
annotate_receiver,
&all_entries,
m_context,
pool
);
#endif
permission.allowThisThread();
if( error != NULL )
{
throw SvnException( error );
}
}
catch( SvnException &e )
{
// use callback error over ClientException
m_context.checkForError( m_module.client_error );
throw_client_error( e );
}
// convert the entries into python objects
Py::List entries_list;
std::list<AnnotatedLineInfo>::const_iterator entry_it = all_entries.begin();
while( entry_it != all_entries.end() )
{
const AnnotatedLineInfo &entry = *entry_it;
++entry_it;
Py::Dict entry_dict;
entry_dict[name_author] = Py::String( entry.m_author, name_utf8 );
entry_dict[name_date] = Py::String( entry.m_date );
entry_dict[name_line] = Py::String( entry.m_line );
entry_dict[name_number] = Py::Int( long( entry.m_line_no ) );
entry_dict[name_revision] = Py::asObject( new pysvn_revision( svn_opt_revision_number, 0, entry.m_revision ) );
entries_list.append( entry_dict );
}
return entries_list;
}
