Skip to content

Commit

Permalink
[PATCH] Fix the way diffcore-rename records unremoved source.
Browse files Browse the repository at this point in the history 
Earier version of diffcore-rename used to keep unmodified
filepair in its output so that the last stage of the processing
that tells renames from copies can make all of rename/copy to
copies.  However this had a bad interaction with other diffcore
filters that wanted to run after diffcore-rename, in that such
unmodified filepair must be retained for proper distinction
between renames and copies to happen.

This patch fixes the problem by changing the way diffcore-rename
records the information needed to distinguish "all are copies"
case and "the last one is a rename" case.

Signed-off-by: Junio C Hamano <junkio@cox.net>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
  • Loading branch information
Junio C Hamano authored and Linus Torvalds committed May 29, 2005
1 parent 367cec1 commit 15d061b
Show file tree
Hide file tree
Showing 4 changed files with 169 additions and 80 deletions.
76 changes: 37 additions & 39 deletions diff.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -518,6 +518,7 @@ struct diff_filepair *diff_queue(struct diff_queue_struct *queue,
dp->one = one;
dp->two = two;
dp->score = 0;
dp->source_stays = 0;
diff_q(queue, dp);
return dp;
}
Expand Down Expand Up @@ -675,8 +676,8 @@ void diff_debug_filepair(const struct diff_filepair *p, int i)
{
diff_debug_filespec(p->one, i, "one");
diff_debug_filespec(p->two, i, "two");
fprintf(stderr, "score %d, status %c\n",
p->score, p->status ? : '?');
fprintf(stderr, "score %d, status %c source_stays %d\n",
p->score, p->status ? : '?', p->source_stays);
}

void diff_debug_queue(const char *msg, struct diff_queue_struct *q)
Expand All @@ -698,32 +699,35 @@ static void diff_resolve_rename_copy(void)
struct diff_filepair *p, *pp;
struct diff_queue_struct *q = &diff_queued_diff;

/* This should not depend on the ordering of things. */

diff_debug_queue("resolve-rename-copy", q);

for (i = 0; i < q->nr; i++) {
p = q->queue[i];
p->status = 0; /* undecided */
if (DIFF_PAIR_UNMERGED(p))
p->status = 'U';
else if (!DIFF_FILE_VALID((p)->one))
else if (!DIFF_FILE_VALID(p->one))
p->status = 'N';
else if (!DIFF_FILE_VALID((p)->two)) {
/* Deletion record should be omitted if there
* are rename/copy entries using this one as
* the source. Then we can say one of them
* is a rename and the rest are copies.
else if (!DIFF_FILE_VALID(p->two)) {
/* Deleted entry may have been picked up by
* another rename-copy entry. So we scan the
* queue and if we find one that uses us as the
* source we do not say delete for this entry.
*/
p->status = 'D';
for (j = 0; j < q->nr; j++) {
pp = q->queue[j];
if (!strcmp(pp->one->path, p->one->path) &&
strcmp(pp->one->path, pp->two->path)) {
if (!strcmp(p->one->path, pp->one->path) &&
pp->score) {
/* rename/copy are always valid
* so we do not say DIFF_FILE_VALID()
* on pp->one and pp->two.
*/
p->status = 'X';
break;
}
}
if (!p->status)
p->status = 'D';
}
else if (DIFF_PAIR_TYPE_CHANGED(p))
p->status = 'T';
Expand All @@ -732,33 +736,24 @@ static void diff_resolve_rename_copy(void)
* whose both sides are valid and of the same type, i.e.
* either in-place edit or rename/copy edit.
*/
else if (strcmp(p->one->path, p->two->path)) {
/* See if there is somebody else anywhere that
* will keep the path (either modified or
* unmodified). If so, we have to be a copy,
* not a rename. In addition, if there is
* some other rename or copy that comes later
* than us that uses the same source, we
* have to be a copy, not a rename.
else if (p->score) {
if (p->source_stays) {
p->status = 'C';
continue;
}
/* See if there is some other filepair that
* copies from the same source as us. If so
* we are a copy. Otherwise we are a rename.
*/
for (j = 0; j < q->nr; j++) {
for (j = i + 1; j < q->nr; j++) {
pp = q->queue[j];
if (strcmp(pp->one->path, p->one->path))
continue;
if (!strcmp(pp->one->path, pp->two->path)) {
if (DIFF_FILE_VALID(pp->two)) {
/* non-delete */
p->status = 'C';
break;
}
continue;
}
/* pp is a rename/copy ... */
if (i < j) {
/* ... and comes later than us */
p->status = 'C';
break;
}
continue; /* not us */
if (!pp->score)
continue; /* not a rename/copy */
/* pp is a rename/copy from the same source */
p->status = 'C';
break;
}
if (!p->status)
p->status = 'R';
Expand All @@ -767,8 +762,11 @@ static void diff_resolve_rename_copy(void)
p->one->mode != p->two->mode)
p->status = 'M';
else
/* this is a "no-change" entry */
p->status = 'X';
/* this is a "no-change" entry.
* should not happen anymore.
* p->status = 'X';
*/
die("internal error in diffcore: unmodified entry remains");
}
diff_debug_queue("resolve-rename-copy done", q);
}
Expand Down
63 changes: 24 additions & 39 deletions diffcore-rename.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -52,14 +52,15 @@ static struct diff_rename_dst *locate_rename_dst(struct diff_filespec *two,
return &(rename_dst[first]);
}

/* Table of rename/copy src files */
static struct diff_rename_src {
struct diff_filespec *one;
unsigned src_used : 1;
unsigned src_stays : 1;
} *rename_src;
static int rename_src_nr, rename_src_alloc;

static struct diff_rename_src *locate_rename_src(struct diff_filespec *one,
int insert_ok)
static struct diff_rename_src *register_rename_src(struct diff_filespec *one,
int src_stays)
{
int first, last;

Expand All @@ -77,9 +78,7 @@ static struct diff_rename_src *locate_rename_src(struct diff_filespec *one,
}
first = next+1;
}
/* not found */
if (!insert_ok)
return NULL;

/* insert to make it at "first" */
if (rename_src_alloc <= rename_src_nr) {
rename_src_alloc = alloc_nr(rename_src_alloc);
Expand All @@ -91,7 +90,7 @@ static struct diff_rename_src *locate_rename_src(struct diff_filespec *one,
memmove(rename_src + first + 1, rename_src + first,
(rename_src_nr - first - 1) * sizeof(*rename_src));
rename_src[first].one = one;
rename_src[first].src_used = 0;
rename_src[first].src_stays = src_stays;
return &(rename_src[first]);
}

Expand Down Expand Up @@ -199,15 +198,14 @@ static void record_rename_pair(struct diff_queue_struct *renq,
fill_filespec(two, dst->sha1, dst->mode);

dp = diff_queue(renq, one, two);
dp->score = score;

rename_src[src_index].src_used = 1;
dp->score = score ? : 1; /* make sure it is at least 1 */
dp->source_stays = rename_src[src_index].src_stays;
rename_dst[dst_index].pair = dp;
}

/*
* We sort the rename similarity matrix with the score, in descending
* order (more similar first).
* order (the most similar first).
*/
static int score_compare(const void *a_, const void *b_)
{
Expand Down Expand Up @@ -254,9 +252,9 @@ void diffcore_rename(int detect_rename, int minimum_score)
else
locate_rename_dst(p->two, 1);
else if (!DIFF_FILE_VALID(p->two))
locate_rename_src(p->one, 1);
else if (1 < detect_rename) /* find copy, too */
locate_rename_src(p->one, 1);
register_rename_src(p->one, 0);
else if (detect_rename == DIFF_DETECT_COPY)
register_rename_src(p->one, 1);
}
if (rename_dst_nr == 0)
goto cleanup; /* nothing to do */
Expand All @@ -280,7 +278,7 @@ void diffcore_rename(int detect_rename, int minimum_score)
* doing the delta matrix altogether.
*/
if (renq.nr == rename_dst_nr)
goto flush_rest;
goto cleanup;

num_create = (rename_dst_nr - renq.nr);
num_src = rename_src_nr;
Expand All @@ -307,37 +305,30 @@ void diffcore_rename(int detect_rename, int minimum_score)
if (dst->pair)
continue; /* already done, either exact or fuzzy. */
if (mx[i].score < minimum_score)
break; /* there is not any more diffs applicable. */
break; /* there is no more usable pair. */
record_rename_pair(&renq, mx[i].dst, mx[i].src, mx[i].score);
}
free(mx);
diff_debug_queue("done detecting fuzzy", &renq);

flush_rest:
cleanup:
/* At this point, we have found some renames and copies and they
* are kept in renq. The original list is still in *q.
*
* Scan the original list and move them into the outq; we will sort
* outq and swap it into the queue supplied to pass that to
* downstream, so we assign the sort keys in this loop.
*
* See comments at the top of record_rename_pair for numbers used
* to assign rename_rank.
*/
outq.queue = NULL;
outq.nr = outq.alloc = 0;
for (i = 0; i < q->nr; i++) {
struct diff_filepair *p = q->queue[i];
struct diff_rename_src *src = locate_rename_src(p->one, 0);
struct diff_rename_dst *dst = locate_rename_dst(p->two, 0);
struct diff_filepair *pair_to_free = NULL;

if (dst) {
/* creation */
if (dst->pair) {
/* renq has rename/copy already to produce
* this file, so we do not emit the creation
* record in the output.
/* renq has rename/copy to produce
* this file already, so we do not
* emit the creation record in the
* output.
*/
diff_q(&outq, dst->pair);
pair_to_free = p;
Expand All @@ -349,17 +340,12 @@ void diffcore_rename(int detect_rename, int minimum_score)
diff_q(&outq, p);
}
else if (!diff_unmodified_pair(p))
/* all the other cases need to be recorded as is */
/* all the usual ones need to be kept */
diff_q(&outq, p);
else {
/* unmodified pair needs to be recorded only if
* it is used as the source of rename/copy
*/
if (src && src->src_used)
diff_q(&outq, p);
else
pair_to_free = p;
}
else
/* no need to keep unmodified pairs */
pair_to_free = p;

if (pair_to_free)
diff_free_filepair(pair_to_free);
}
Expand All @@ -370,7 +356,6 @@ void diffcore_rename(int detect_rename, int minimum_score)
*q = outq;
diff_debug_queue("done collapsing", q);

cleanup:
free(rename_dst);
rename_dst = NULL;
rename_dst_nr = rename_dst_alloc = 0;
Expand Down
7 changes: 5 additions & 2 deletions diffcore.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -39,8 +39,11 @@ extern void diff_free_filespec_data(struct diff_filespec *);
struct diff_filepair {
struct diff_filespec *one;
struct diff_filespec *two;
int score; /* only valid when one and two are different paths */
int status; /* M C R N D U (see Documentation/diff-format.txt) */
unsigned short int score; /* only valid when one and two are
* different paths
*/
char source_stays; /* all of R/C are copies */
char status; /* M C R N D U (see Documentation/diff-format.txt) */
};
#define DIFF_PAIR_UNMERGED(p) \
(!DIFF_FILE_VALID((p)->one) && !DIFF_FILE_VALID((p)->two))
Expand Down
Loading

0 comments on commit 15d061b

Please sign in to comment.