2005-05-21 09:39:09 +00:00
|
|
|
/*
|
|
|
|
* Copyright (C) 2005 Junio C Hamano
|
|
|
|
*/
|
|
|
|
#include "cache.h"
|
|
|
|
#include "diff.h"
|
|
|
|
#include "diffcore.h"
|
|
|
|
#include "delta.h"
|
2005-05-24 19:09:32 +00:00
|
|
|
#include "count-delta.h"
|
2005-05-21 09:39:09 +00:00
|
|
|
|
2005-05-24 08:10:48 +00:00
|
|
|
/* Table of rename/copy destinations */
|
|
|
|
|
|
|
|
static struct diff_rename_dst {
|
|
|
|
struct diff_filespec *two;
|
|
|
|
struct diff_filepair *pair;
|
|
|
|
} *rename_dst;
|
|
|
|
static int rename_dst_nr, rename_dst_alloc;
|
2005-05-21 09:39:09 +00:00
|
|
|
|
2005-05-24 08:10:48 +00:00
|
|
|
static struct diff_rename_dst *locate_rename_dst(struct diff_filespec *two,
|
|
|
|
int insert_ok)
|
2005-05-21 09:39:09 +00:00
|
|
|
{
|
2005-05-24 08:10:48 +00:00
|
|
|
int first, last;
|
|
|
|
|
|
|
|
first = 0;
|
|
|
|
last = rename_dst_nr;
|
|
|
|
while (last > first) {
|
|
|
|
int next = (last + first) >> 1;
|
|
|
|
struct diff_rename_dst *dst = &(rename_dst[next]);
|
|
|
|
int cmp = strcmp(two->path, dst->two->path);
|
|
|
|
if (!cmp)
|
|
|
|
return dst;
|
|
|
|
if (cmp < 0) {
|
|
|
|
last = next;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
first = next+1;
|
|
|
|
}
|
|
|
|
/* not found */
|
|
|
|
if (!insert_ok)
|
|
|
|
return NULL;
|
|
|
|
/* insert to make it at "first" */
|
|
|
|
if (rename_dst_alloc <= rename_dst_nr) {
|
|
|
|
rename_dst_alloc = alloc_nr(rename_dst_alloc);
|
|
|
|
rename_dst = xrealloc(rename_dst,
|
|
|
|
rename_dst_alloc * sizeof(*rename_dst));
|
|
|
|
}
|
|
|
|
rename_dst_nr++;
|
|
|
|
if (first < rename_dst_nr)
|
|
|
|
memmove(rename_dst + first + 1, rename_dst + first,
|
|
|
|
(rename_dst_nr - first - 1) * sizeof(*rename_dst));
|
|
|
|
rename_dst[first].two = two;
|
|
|
|
rename_dst[first].pair = NULL;
|
|
|
|
return &(rename_dst[first]);
|
2005-05-21 09:39:09 +00:00
|
|
|
}
|
|
|
|
|
2005-05-27 22:55:55 +00:00
|
|
|
/* Table of rename/copy src files */
|
2005-05-24 08:10:48 +00:00
|
|
|
static struct diff_rename_src {
|
|
|
|
struct diff_filespec *one;
|
2005-05-27 22:55:55 +00:00
|
|
|
unsigned src_stays : 1;
|
2005-05-24 08:10:48 +00:00
|
|
|
} *rename_src;
|
|
|
|
static int rename_src_nr, rename_src_alloc;
|
2005-05-21 09:39:09 +00:00
|
|
|
|
2005-05-27 22:55:55 +00:00
|
|
|
static struct diff_rename_src *register_rename_src(struct diff_filespec *one,
|
|
|
|
int src_stays)
|
2005-05-24 08:10:48 +00:00
|
|
|
{
|
|
|
|
int first, last;
|
|
|
|
|
|
|
|
first = 0;
|
|
|
|
last = rename_src_nr;
|
|
|
|
while (last > first) {
|
|
|
|
int next = (last + first) >> 1;
|
|
|
|
struct diff_rename_src *src = &(rename_src[next]);
|
|
|
|
int cmp = strcmp(one->path, src->one->path);
|
|
|
|
if (!cmp)
|
|
|
|
return src;
|
|
|
|
if (cmp < 0) {
|
|
|
|
last = next;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
first = next+1;
|
|
|
|
}
|
2005-05-27 22:55:55 +00:00
|
|
|
|
2005-05-24 08:10:48 +00:00
|
|
|
/* insert to make it at "first" */
|
|
|
|
if (rename_src_alloc <= rename_src_nr) {
|
|
|
|
rename_src_alloc = alloc_nr(rename_src_alloc);
|
|
|
|
rename_src = xrealloc(rename_src,
|
|
|
|
rename_src_alloc * sizeof(*rename_src));
|
2005-05-21 09:39:09 +00:00
|
|
|
}
|
2005-05-24 08:10:48 +00:00
|
|
|
rename_src_nr++;
|
|
|
|
if (first < rename_src_nr)
|
|
|
|
memmove(rename_src + first + 1, rename_src + first,
|
|
|
|
(rename_src_nr - first - 1) * sizeof(*rename_src));
|
|
|
|
rename_src[first].one = one;
|
2005-05-27 22:55:55 +00:00
|
|
|
rename_src[first].src_stays = src_stays;
|
2005-05-24 08:10:48 +00:00
|
|
|
return &(rename_src[first]);
|
2005-05-21 09:39:09 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int is_exact_match(struct diff_filespec *src, struct diff_filespec *dst)
|
|
|
|
{
|
|
|
|
if (src->sha1_valid && dst->sha1_valid &&
|
|
|
|
!memcmp(src->sha1, dst->sha1, 20))
|
|
|
|
return 1;
|
2005-05-27 22:56:38 +00:00
|
|
|
if (diff_populate_filespec(src, 1) || diff_populate_filespec(dst, 1))
|
|
|
|
return 0;
|
|
|
|
if (src->size != dst->size)
|
|
|
|
return 0;
|
|
|
|
if (diff_populate_filespec(src, 0) || diff_populate_filespec(dst, 0))
|
2005-05-21 09:39:09 +00:00
|
|
|
return 0;
|
|
|
|
if (src->size == dst->size &&
|
|
|
|
!memcmp(src->data, dst->data, src->size))
|
|
|
|
return 1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
struct diff_score {
|
2005-05-24 08:10:48 +00:00
|
|
|
int src; /* index in rename_src */
|
|
|
|
int dst; /* index in rename_dst */
|
2005-05-21 09:39:09 +00:00
|
|
|
int score;
|
|
|
|
};
|
|
|
|
|
|
|
|
static int estimate_similarity(struct diff_filespec *src,
|
|
|
|
struct diff_filespec *dst,
|
|
|
|
int minimum_score)
|
|
|
|
{
|
|
|
|
/* src points at a file that existed in the original tree (or
|
|
|
|
* optionally a file in the destination tree) and dst points
|
|
|
|
* at a newly created file. They may be quite similar, in which
|
|
|
|
* case we want to say src is renamed to dst or src is copied into
|
|
|
|
* dst, and then some edit has been applied to dst.
|
|
|
|
*
|
|
|
|
* Compare them and return how similar they are, representing
|
2005-05-27 22:56:38 +00:00
|
|
|
* the score as an integer between 0 and MAX_SCORE.
|
|
|
|
*
|
|
|
|
* When there is an exact match, it is considered a better
|
|
|
|
* match than anything else; the destination does not even
|
|
|
|
* call into this function in that case.
|
2005-05-21 09:39:09 +00:00
|
|
|
*/
|
|
|
|
void *delta;
|
2005-06-03 08:36:03 +00:00
|
|
|
unsigned long delta_size, base_size, src_copied, literal_added;
|
2005-05-21 09:39:09 +00:00
|
|
|
int score;
|
|
|
|
|
2005-05-23 04:24:49 +00:00
|
|
|
/* We deal only with regular files. Symlink renames are handled
|
|
|
|
* only when they are exact matches --- in other words, no edits
|
|
|
|
* after renaming.
|
|
|
|
*/
|
|
|
|
if (!S_ISREG(src->mode) || !S_ISREG(dst->mode))
|
|
|
|
return 0;
|
|
|
|
|
2005-05-21 09:39:09 +00:00
|
|
|
delta_size = ((src->size < dst->size) ?
|
|
|
|
(dst->size - src->size) : (src->size - dst->size));
|
2005-05-21 22:55:18 +00:00
|
|
|
base_size = ((src->size < dst->size) ? src->size : dst->size);
|
2005-05-21 09:39:09 +00:00
|
|
|
|
2005-05-21 22:55:18 +00:00
|
|
|
/* We would not consider edits that change the file size so
|
|
|
|
* drastically. delta_size must be smaller than
|
2005-05-22 08:31:28 +00:00
|
|
|
* (MAX_SCORE-minimum_score)/MAX_SCORE * min(src->size, dst->size).
|
2005-05-27 22:56:38 +00:00
|
|
|
*
|
2005-05-21 22:55:18 +00:00
|
|
|
* Note that base_size == 0 case is handled here already
|
|
|
|
* and the final score computation below would not have a
|
|
|
|
* divide-by-zero issue.
|
2005-05-21 09:39:09 +00:00
|
|
|
*/
|
2005-05-22 08:31:28 +00:00
|
|
|
if (base_size * (MAX_SCORE-minimum_score) < delta_size * MAX_SCORE)
|
2005-05-21 09:39:09 +00:00
|
|
|
return 0;
|
|
|
|
|
2005-05-27 22:56:38 +00:00
|
|
|
if (diff_populate_filespec(src, 0) || diff_populate_filespec(dst, 0))
|
|
|
|
return 0; /* error but caught downstream */
|
|
|
|
|
2005-05-21 09:39:09 +00:00
|
|
|
delta = diff_delta(src->data, src->size,
|
|
|
|
dst->data, dst->size,
|
|
|
|
&delta_size);
|
2005-05-24 19:09:32 +00:00
|
|
|
|
|
|
|
/* A delta that has a lot of literal additions would have
|
|
|
|
* big delta_size no matter what else it does.
|
2005-05-21 22:55:18 +00:00
|
|
|
*/
|
2005-05-27 22:49:54 +00:00
|
|
|
if (base_size * (MAX_SCORE-minimum_score) < delta_size * MAX_SCORE)
|
2005-05-24 19:09:32 +00:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
/* Estimate the edit size by interpreting delta. */
|
2005-06-03 08:36:03 +00:00
|
|
|
if (count_delta(delta, delta_size, &src_copied, &literal_added)) {
|
|
|
|
free(delta);
|
2005-05-24 19:09:32 +00:00
|
|
|
return 0;
|
2005-06-03 08:36:03 +00:00
|
|
|
}
|
|
|
|
free(delta);
|
|
|
|
|
|
|
|
/* Extent of damage */
|
|
|
|
if (src->size + literal_added < src_copied)
|
|
|
|
delta_size = 0;
|
|
|
|
else
|
|
|
|
delta_size = (src->size - src_copied) + literal_added;
|
2005-05-21 09:39:09 +00:00
|
|
|
|
2005-05-21 22:55:18 +00:00
|
|
|
/*
|
|
|
|
* Now we will give some score to it. 100% edit gets 0 points
|
|
|
|
* and 0% edit gets MAX_SCORE points.
|
2005-05-21 09:39:09 +00:00
|
|
|
*/
|
2005-05-21 22:55:18 +00:00
|
|
|
score = MAX_SCORE - (MAX_SCORE * delta_size / base_size);
|
2005-05-21 09:39:09 +00:00
|
|
|
if (score < 0) return 0;
|
|
|
|
if (MAX_SCORE < score) return MAX_SCORE;
|
|
|
|
return score;
|
|
|
|
}
|
|
|
|
|
2005-05-24 08:10:48 +00:00
|
|
|
static void record_rename_pair(struct diff_queue_struct *renq,
|
|
|
|
int dst_index, int src_index, int score)
|
2005-05-21 09:39:09 +00:00
|
|
|
{
|
2005-05-24 08:10:48 +00:00
|
|
|
struct diff_filespec *one, *two, *src, *dst;
|
|
|
|
struct diff_filepair *dp;
|
[PATCH] Rename/copy detection fix.
The rename/copy detection logic in earlier round was only good
enough to show patch output and discussion on the mailing list
about the diff-raw format updates revealed many problems with
it. This patch fixes all the ones known to me, without making
things I want to do later impossible, mostly related to patch
reordering.
(1) Earlier rename/copy detector determined which one is rename
and which one is copy too early, which made it impossible
to later introduce diffcore transformers to reorder
patches. This patch fixes it by moving that logic to the
very end of the processing.
(2) Earlier output routine diff_flush() was pruning all the
"no-change" entries indiscriminatingly. This was done due
to my false assumption that one of the requirements in the
diff-raw output was not to show such an entry (which
resulted in my incorrect comment about "diff-helper never
being able to be equivalent to built-in diff driver"). My
special thanks go to Linus for correcting me about this.
When we produce diff-raw output, for the downstream to be
able to tell renames from copies, sometimes it _is_
necessary to output "no-change" entries, and this patch
adds diffcore_prune() function for doing it.
(3) Earlier diff_filepair structure was trying to be not too
specific about rename/copy operations, but the purpose of
the structure was to record one or two paths, which _was_
indeed about rename/copy. This patch discards xfrm_msg
field which was trying to be generic for this wrong reason,
and introduces a couple of fields (rename_score and
rename_rank) that are explicitly specific to rename/copy
logic. One thing to note is that the information in a
single diff_filepair structure _still_ does not distinguish
renames from copies, and it is deliberately so. This is to
allow patches to be reordered in later stages.
(4) This patch also adds some tests about diff-raw format
output and makes sure that necessary "no-change" entries
appear on the output.
Signed-off-by: Junio C Hamano <junkio@cox.net>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-05-23 04:26:09 +00:00
|
|
|
|
2005-05-24 08:10:48 +00:00
|
|
|
if (rename_dst[dst_index].pair)
|
|
|
|
die("internal error: dst already matched.");
|
2005-05-21 09:39:09 +00:00
|
|
|
|
2005-05-24 08:10:48 +00:00
|
|
|
src = rename_src[src_index].one;
|
|
|
|
one = alloc_filespec(src->path);
|
|
|
|
fill_filespec(one, src->sha1, src->mode);
|
2005-05-21 09:39:09 +00:00
|
|
|
|
2005-05-24 08:10:48 +00:00
|
|
|
dst = rename_dst[dst_index].two;
|
|
|
|
two = alloc_filespec(dst->path);
|
|
|
|
fill_filespec(two, dst->sha1, dst->mode);
|
2005-05-21 09:39:09 +00:00
|
|
|
|
2005-05-24 08:10:48 +00:00
|
|
|
dp = diff_queue(renq, one, two);
|
2005-05-29 23:56:48 +00:00
|
|
|
dp->score = score;
|
2005-05-27 22:55:55 +00:00
|
|
|
dp->source_stays = rename_src[src_index].src_stays;
|
2005-05-24 08:10:48 +00:00
|
|
|
rename_dst[dst_index].pair = dp;
|
2005-05-21 09:39:09 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We sort the rename similarity matrix with the score, in descending
|
2005-05-27 22:55:55 +00:00
|
|
|
* order (the most similar first).
|
2005-05-21 09:39:09 +00:00
|
|
|
*/
|
|
|
|
static int score_compare(const void *a_, const void *b_)
|
|
|
|
{
|
|
|
|
const struct diff_score *a = a_, *b = b_;
|
|
|
|
return b->score - a->score;
|
|
|
|
}
|
|
|
|
|
2005-05-22 17:04:37 +00:00
|
|
|
void diffcore_rename(int detect_rename, int minimum_score)
|
2005-05-21 09:39:09 +00:00
|
|
|
{
|
2005-05-22 02:40:36 +00:00
|
|
|
struct diff_queue_struct *q = &diff_queued_diff;
|
2005-05-24 08:10:48 +00:00
|
|
|
struct diff_queue_struct renq, outq;
|
2005-05-21 09:39:09 +00:00
|
|
|
struct diff_score *mx;
|
2005-05-24 08:10:48 +00:00
|
|
|
int i, j;
|
|
|
|
int num_create, num_src, dst_cnt;
|
2005-05-21 09:39:09 +00:00
|
|
|
|
2005-05-22 06:33:32 +00:00
|
|
|
if (!minimum_score)
|
[PATCH] Add -B flag to diff-* brothers.
A new diffcore transformation, diffcore-break.c, is introduced.
When the -B flag is given, a patch that represents a complete
rewrite is broken into a deletion followed by a creation. This
makes it easier to review such a complete rewrite patch.
The -B flag takes the same syntax as the -M and -C flags to
specify the minimum amount of non-source material the resulting
file needs to have to be considered a complete rewrite, and
defaults to 99% if not specified.
As the new test t4008-diff-break-rewrite.sh demonstrates, if a
file is a complete rewrite, it is broken into a delete/create
pair, which can further be subjected to the usual rename
detection if -M or -C is used. For example, if file0 gets
completely rewritten to make it as if it were rather based on
file1 which itself disappeared, the following happens:
The original change looks like this:
file0 --> file0' (quite different from file0)
file1 --> /dev/null
After diffcore-break runs, it would become this:
file0 --> /dev/null
/dev/null --> file0'
file1 --> /dev/null
Then diffcore-rename matches them up:
file1 --> file0'
The internal score values are finer grained now. Earlier
maximum of 10000 has been raised to 60000; there is no user
visible changes but there is no reason to waste available bits.
Signed-off-by: Junio C Hamano <junkio@cox.net>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-05-30 07:08:37 +00:00
|
|
|
minimum_score = DEFAULT_RENAME_SCORE;
|
2005-05-24 08:10:48 +00:00
|
|
|
renq.queue = NULL;
|
|
|
|
renq.nr = renq.alloc = 0;
|
2005-05-21 09:39:09 +00:00
|
|
|
|
|
|
|
for (i = 0; i < q->nr; i++) {
|
2005-05-21 09:40:01 +00:00
|
|
|
struct diff_filepair *p = q->queue[i];
|
2005-05-22 02:42:18 +00:00
|
|
|
if (!DIFF_FILE_VALID(p->one))
|
|
|
|
if (!DIFF_FILE_VALID(p->two))
|
2005-05-23 04:24:49 +00:00
|
|
|
continue; /* unmerged */
|
2005-05-21 09:39:09 +00:00
|
|
|
else
|
2005-05-24 08:10:48 +00:00
|
|
|
locate_rename_dst(p->two, 1);
|
2005-06-12 03:55:20 +00:00
|
|
|
else if (!DIFF_FILE_VALID(p->two)) {
|
|
|
|
/* If the source is a broken "delete", and
|
|
|
|
* they did not really want to get broken,
|
|
|
|
* that means the source actually stays.
|
|
|
|
*/
|
|
|
|
int stays = (p->broken_pair && !p->score);
|
|
|
|
register_rename_src(p->one, stays);
|
|
|
|
}
|
2005-05-27 22:55:55 +00:00
|
|
|
else if (detect_rename == DIFF_DETECT_COPY)
|
|
|
|
register_rename_src(p->one, 1);
|
2005-05-21 09:39:09 +00:00
|
|
|
}
|
2005-05-24 08:10:48 +00:00
|
|
|
if (rename_dst_nr == 0)
|
2005-05-21 09:39:09 +00:00
|
|
|
goto cleanup; /* nothing to do */
|
|
|
|
|
|
|
|
/* We really want to cull the candidates list early
|
|
|
|
* with cheap tests in order to avoid doing deltas.
|
|
|
|
*/
|
2005-05-24 08:10:48 +00:00
|
|
|
for (i = 0; i < rename_dst_nr; i++) {
|
|
|
|
struct diff_filespec *two = rename_dst[i].two;
|
|
|
|
for (j = 0; j < rename_src_nr; j++) {
|
|
|
|
struct diff_filespec *one = rename_src[j].one;
|
|
|
|
if (!is_exact_match(one, two))
|
|
|
|
continue;
|
|
|
|
record_rename_pair(&renq, i, j, MAX_SCORE);
|
|
|
|
break; /* we are done with this entry */
|
2005-05-21 09:39:09 +00:00
|
|
|
}
|
|
|
|
}
|
2005-05-24 08:10:48 +00:00
|
|
|
diff_debug_queue("done detecting exact", &renq);
|
2005-05-21 09:39:09 +00:00
|
|
|
|
|
|
|
/* Have we run out the created file pool? If so we can avoid
|
|
|
|
* doing the delta matrix altogether.
|
|
|
|
*/
|
2005-05-24 08:10:48 +00:00
|
|
|
if (renq.nr == rename_dst_nr)
|
2005-05-27 22:55:55 +00:00
|
|
|
goto cleanup;
|
2005-05-21 09:39:09 +00:00
|
|
|
|
2005-05-24 08:10:48 +00:00
|
|
|
num_create = (rename_dst_nr - renq.nr);
|
|
|
|
num_src = rename_src_nr;
|
2005-05-21 09:39:09 +00:00
|
|
|
mx = xmalloc(sizeof(*mx) * num_create * num_src);
|
2005-05-24 08:10:48 +00:00
|
|
|
for (dst_cnt = i = 0; i < rename_dst_nr; i++) {
|
2005-05-21 09:39:09 +00:00
|
|
|
int base = dst_cnt * num_src;
|
2005-05-24 08:10:48 +00:00
|
|
|
struct diff_filespec *two = rename_dst[i].two;
|
|
|
|
if (rename_dst[i].pair)
|
2005-05-21 09:39:09 +00:00
|
|
|
continue; /* dealt with exact match already. */
|
2005-05-24 08:10:48 +00:00
|
|
|
for (j = 0; j < rename_src_nr; j++) {
|
|
|
|
struct diff_filespec *one = rename_src[j].one;
|
|
|
|
struct diff_score *m = &mx[base+j];
|
|
|
|
m->src = j;
|
|
|
|
m->dst = i;
|
|
|
|
m->score = estimate_similarity(one, two,
|
|
|
|
minimum_score);
|
2005-05-21 09:39:09 +00:00
|
|
|
}
|
|
|
|
dst_cnt++;
|
|
|
|
}
|
|
|
|
/* cost matrix sorted by most to least similar pair */
|
|
|
|
qsort(mx, num_create * num_src, sizeof(*mx), score_compare);
|
|
|
|
for (i = 0; i < num_create * num_src; i++) {
|
2005-05-24 08:10:48 +00:00
|
|
|
struct diff_rename_dst *dst = &rename_dst[mx[i].dst];
|
|
|
|
if (dst->pair)
|
|
|
|
continue; /* already done, either exact or fuzzy. */
|
2005-05-21 09:39:09 +00:00
|
|
|
if (mx[i].score < minimum_score)
|
2005-05-27 22:55:55 +00:00
|
|
|
break; /* there is no more usable pair. */
|
2005-05-24 08:10:48 +00:00
|
|
|
record_rename_pair(&renq, mx[i].dst, mx[i].src, mx[i].score);
|
2005-05-21 09:39:09 +00:00
|
|
|
}
|
|
|
|
free(mx);
|
2005-05-24 08:10:48 +00:00
|
|
|
diff_debug_queue("done detecting fuzzy", &renq);
|
2005-05-21 09:39:09 +00:00
|
|
|
|
2005-05-27 22:55:55 +00:00
|
|
|
cleanup:
|
2005-05-21 09:39:09 +00:00
|
|
|
/* At this point, we have found some renames and copies and they
|
2005-05-24 08:10:48 +00:00
|
|
|
* are kept in renq. The original list is still in *q.
|
2005-05-21 09:39:09 +00:00
|
|
|
*/
|
2005-05-24 08:10:48 +00:00
|
|
|
outq.queue = NULL;
|
|
|
|
outq.nr = outq.alloc = 0;
|
2005-05-21 09:39:09 +00:00
|
|
|
for (i = 0; i < q->nr; i++) {
|
2005-05-24 08:10:48 +00:00
|
|
|
struct diff_filepair *p = q->queue[i];
|
|
|
|
struct diff_filepair *pair_to_free = NULL;
|
|
|
|
|
2005-05-30 07:08:07 +00:00
|
|
|
if (!DIFF_FILE_VALID(p->one) && DIFF_FILE_VALID(p->two)) {
|
|
|
|
/*
|
|
|
|
* Creation
|
|
|
|
*
|
|
|
|
* We would output this create record if it has
|
|
|
|
* not been turned into a rename/copy already.
|
|
|
|
*/
|
|
|
|
struct diff_rename_dst *dst =
|
|
|
|
locate_rename_dst(p->two, 0);
|
|
|
|
if (dst && dst->pair) {
|
2005-05-24 08:10:48 +00:00
|
|
|
diff_q(&outq, dst->pair);
|
|
|
|
pair_to_free = p;
|
|
|
|
}
|
|
|
|
else
|
2005-05-30 07:08:07 +00:00
|
|
|
/* no matching rename/copy source, so
|
|
|
|
* record this as a creation.
|
2005-05-24 08:10:48 +00:00
|
|
|
*/
|
|
|
|
diff_q(&outq, p);
|
2005-05-21 09:39:09 +00:00
|
|
|
}
|
2005-05-30 07:08:07 +00:00
|
|
|
else if (DIFF_FILE_VALID(p->one) && !DIFF_FILE_VALID(p->two)) {
|
|
|
|
/*
|
|
|
|
* Deletion
|
|
|
|
*
|
[PATCH] Add -B flag to diff-* brothers.
A new diffcore transformation, diffcore-break.c, is introduced.
When the -B flag is given, a patch that represents a complete
rewrite is broken into a deletion followed by a creation. This
makes it easier to review such a complete rewrite patch.
The -B flag takes the same syntax as the -M and -C flags to
specify the minimum amount of non-source material the resulting
file needs to have to be considered a complete rewrite, and
defaults to 99% if not specified.
As the new test t4008-diff-break-rewrite.sh demonstrates, if a
file is a complete rewrite, it is broken into a delete/create
pair, which can further be subjected to the usual rename
detection if -M or -C is used. For example, if file0 gets
completely rewritten to make it as if it were rather based on
file1 which itself disappeared, the following happens:
The original change looks like this:
file0 --> file0' (quite different from file0)
file1 --> /dev/null
After diffcore-break runs, it would become this:
file0 --> /dev/null
/dev/null --> file0'
file1 --> /dev/null
Then diffcore-rename matches them up:
file1 --> file0'
The internal score values are finer grained now. Earlier
maximum of 10000 has been raised to 60000; there is no user
visible changes but there is no reason to waste available bits.
Signed-off-by: Junio C Hamano <junkio@cox.net>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-05-30 07:08:37 +00:00
|
|
|
* We would output this delete record if:
|
|
|
|
*
|
|
|
|
* (1) this is a broken delete and the counterpart
|
|
|
|
* broken create remains in the output; or
|
|
|
|
* (2) this is not a broken delete, and renq does
|
|
|
|
* not have a rename/copy to move p->one->path
|
|
|
|
* out.
|
|
|
|
*
|
|
|
|
* Otherwise, the counterpart broken create
|
|
|
|
* has been turned into a rename-edit; or
|
|
|
|
* delete did not have a matching create to
|
|
|
|
* begin with.
|
2005-05-30 07:08:07 +00:00
|
|
|
*/
|
[PATCH] Add -B flag to diff-* brothers.
A new diffcore transformation, diffcore-break.c, is introduced.
When the -B flag is given, a patch that represents a complete
rewrite is broken into a deletion followed by a creation. This
makes it easier to review such a complete rewrite patch.
The -B flag takes the same syntax as the -M and -C flags to
specify the minimum amount of non-source material the resulting
file needs to have to be considered a complete rewrite, and
defaults to 99% if not specified.
As the new test t4008-diff-break-rewrite.sh demonstrates, if a
file is a complete rewrite, it is broken into a delete/create
pair, which can further be subjected to the usual rename
detection if -M or -C is used. For example, if file0 gets
completely rewritten to make it as if it were rather based on
file1 which itself disappeared, the following happens:
The original change looks like this:
file0 --> file0' (quite different from file0)
file1 --> /dev/null
After diffcore-break runs, it would become this:
file0 --> /dev/null
/dev/null --> file0'
file1 --> /dev/null
Then diffcore-rename matches them up:
file1 --> file0'
The internal score values are finer grained now. Earlier
maximum of 10000 has been raised to 60000; there is no user
visible changes but there is no reason to waste available bits.
Signed-off-by: Junio C Hamano <junkio@cox.net>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-05-30 07:08:37 +00:00
|
|
|
if (DIFF_PAIR_BROKEN(p)) {
|
|
|
|
/* broken delete */
|
|
|
|
struct diff_rename_dst *dst =
|
|
|
|
locate_rename_dst(p->one, 0);
|
|
|
|
if (dst && dst->pair)
|
|
|
|
/* counterpart is now rename/copy */
|
|
|
|
pair_to_free = p;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
for (j = 0; j < renq.nr; j++)
|
|
|
|
if (!strcmp(renq.queue[j]->one->path,
|
|
|
|
p->one->path))
|
|
|
|
break;
|
|
|
|
if (j < renq.nr)
|
|
|
|
/* this path remains */
|
|
|
|
pair_to_free = p;
|
|
|
|
}
|
2005-05-30 07:08:07 +00:00
|
|
|
|
|
|
|
if (pair_to_free)
|
|
|
|
;
|
|
|
|
else
|
|
|
|
diff_q(&outq, p);
|
|
|
|
}
|
2005-05-24 08:10:48 +00:00
|
|
|
else if (!diff_unmodified_pair(p))
|
2005-05-27 22:55:55 +00:00
|
|
|
/* all the usual ones need to be kept */
|
2005-05-24 08:10:48 +00:00
|
|
|
diff_q(&outq, p);
|
2005-05-27 22:55:55 +00:00
|
|
|
else
|
|
|
|
/* no need to keep unmodified pairs */
|
|
|
|
pair_to_free = p;
|
|
|
|
|
2005-05-27 22:50:30 +00:00
|
|
|
if (pair_to_free)
|
|
|
|
diff_free_filepair(pair_to_free);
|
2005-05-21 09:39:09 +00:00
|
|
|
}
|
2005-05-24 08:10:48 +00:00
|
|
|
diff_debug_queue("done copying original", &outq);
|
2005-05-21 09:39:09 +00:00
|
|
|
|
2005-05-24 08:10:48 +00:00
|
|
|
free(renq.queue);
|
|
|
|
free(q->queue);
|
|
|
|
*q = outq;
|
|
|
|
diff_debug_queue("done collapsing", q);
|
2005-05-21 09:39:09 +00:00
|
|
|
|
2005-05-24 08:10:48 +00:00
|
|
|
free(rename_dst);
|
|
|
|
rename_dst = NULL;
|
|
|
|
rename_dst_nr = rename_dst_alloc = 0;
|
|
|
|
free(rename_src);
|
|
|
|
rename_src = NULL;
|
|
|
|
rename_src_nr = rename_src_alloc = 0;
|
2005-05-21 09:39:09 +00:00
|
|
|
return;
|
|
|
|
}
|