#include "cache.h"
#include "diff.h"
#include "diffcore.h"
-#include "delta.h"
-#include "count-delta.h"
static int should_break(struct diff_filespec *src,
struct diff_filespec *dst,
* The value we return is 1 if we want the pair to be broken,
* or 0 if we do not.
*/
- void *delta;
- unsigned long delta_size, base_size, src_copied, literal_added;
- int to_break = 0;
+ unsigned long delta_size, base_size, src_copied, literal_added,
+ src_removed;
*merge_score_p = 0; /* assume no deletion --- "do not break"
* is the default.
if (!S_ISREG(src->mode) || !S_ISREG(dst->mode))
return 0; /* leave symlink rename alone */
+ if (src->sha1_valid && dst->sha1_valid &&
+ !hashcmp(src->sha1, dst->sha1))
+ return 0; /* they are the same */
+
if (diff_populate_filespec(src, 0) || diff_populate_filespec(dst, 0))
return 0; /* error but caught downstream */
- delta_size = ((src->size < dst->size) ?
- (dst->size - src->size) : (src->size - dst->size));
-
- /* Notice that we use max of src and dst as the base size,
- * unlike rename similarity detection. This is so that we do
- * not mistake a large addition as a complete rewrite.
- */
- base_size = ((src->size < dst->size) ? dst->size : src->size);
+ base_size = ((src->size < dst->size) ? src->size : dst->size);
+ if (base_size < MINIMUM_BREAK_SIZE)
+ return 0; /* we do not break too small filepair */
- delta = diff_delta(src->data, src->size,
- dst->data, dst->size,
- &delta_size);
+ if (diffcore_count_changes(src->data, src->size,
+ dst->data, dst->size,
+ NULL, NULL,
+ 0,
+ &src_copied, &literal_added))
+ return 0;
- /* Estimate the edit size by interpreting delta. */
- if (count_delta(delta, delta_size,
- &src_copied, &literal_added)) {
- free(delta);
- return 0; /* we cannot tell */
+ /* sanity */
+ if (src->size < src_copied)
+ src_copied = src->size;
+ if (dst->size < literal_added + src_copied) {
+ if (src_copied < dst->size)
+ literal_added = dst->size - src_copied;
+ else
+ literal_added = 0;
}
- free(delta);
+ src_removed = src->size - src_copied;
/* Compute merge-score, which is "how much is removed
* from the source material". The clean-up stage will
* merge the surviving pair together if the score is
* less than the minimum, after rename/copy runs.
*/
- if (src->size <= src_copied)
- delta_size = 0; /* avoid wrapping around */
- else
- delta_size = src->size - src_copied;
- *merge_score_p = delta_size * MAX_SCORE / src->size;
-
+ *merge_score_p = src_removed * MAX_SCORE / src->size;
+
/* Extent of damage, which counts both inserts and
* deletes.
*/
- if (src->size + literal_added <= src_copied)
- delta_size = 0; /* avoid wrapping around */
- else
- delta_size = (src->size - src_copied) + literal_added;
-
- /* We break if the edit exceeds the minimum.
- * i.e. (break_score / MAX_SCORE < delta_size / base_size)
+ delta_size = src_removed + literal_added;
+ if (delta_size * MAX_SCORE / base_size < break_score)
+ return 0;
+
+ /* If you removed a lot without adding new material, that is
+ * not really a rewrite.
*/
- if (break_score * base_size < delta_size * MAX_SCORE)
- to_break = 1;
+ if ((src->size * break_score < src_removed * MAX_SCORE) &&
+ (literal_added * 20 < src_removed) &&
+ (literal_added * 20 < src_copied))
+ return 0;
- return to_break;
+ return 1;
}
void diffcore_break(int break_score)
* Also we do not want to break very
* small files.
*/
- if ((score < merge_score) ||
- (p->one->size < MINIMUM_BREAK_SIZE))
+ if (score < merge_score)
score = 0;
/* deletion of one */
struct diff_queue_struct *outq)
{
/* p and pp are broken pairs we want to merge */
- struct diff_filepair *c = p, *d = pp;
+ struct diff_filepair *c = p, *d = pp, *dp;
if (DIFF_FILE_VALID(p->one)) {
/* this must be a delete half */
d = p; c = pp;
if (!DIFF_FILE_VALID(c->two))
die("internal error in merge #4");
- diff_queue(outq, d->one, c->two);
+ dp = diff_queue(outq, d->one, c->two);
+ dp->score = p->score;
diff_free_filespec_data(d->two);
diff_free_filespec_data(c->one);
free(d);
/* we already merged this with its peer */
continue;
else if (p->broken_pair &&
- p->score == 0 &&
!strcmp(p->one->path, p->two->path)) {
/* If the peer also survived rename/copy, then
* we merge them back together.
for (j = i + 1; j < q->nr; j++) {
struct diff_filepair *pp = q->queue[j];
if (pp->broken_pair &&
- p->score == 0 &&
!strcmp(pp->one->path, pp->two->path) &&
!strcmp(p->one->path, pp->two->path)) {
/* Peer survived. Merge them */