1/* 2 * Copyright (C) 2005 Junio C Hamano 3 */ 4#include "cache.h" 5#include "diff.h" 6#include "diffcore.h" 7#include "delta.h" 8#include "count-delta.h" 9 10static int very_different(struct diff_filespec *src, 11 struct diff_filespec *dst, 12 int min_score) 13{ 14 /* dst is recorded as a modification of src. Are they so 15 * different that we are better off recording this as a pair 16 * of delete and create? min_score is the minimum amount of 17 * new material that must exist in the dst and not in src for 18 * the pair to be considered a complete rewrite, and recommended 19 * to be set to a very high value, 99% or so. 20 * 21 * The value we return represents the amount of new material 22 * that is in dst and not in src. We return 0 when we do not 23 * want to get the filepair broken. 24 */ 25 void *delta; 26 unsigned long delta_size, base_size; 27 28 if (!S_ISREG(src->mode) || !S_ISREG(dst->mode)) 29 return 0; /* leave symlink rename alone */ 30 31 if (diff_populate_filespec(src, 1) || diff_populate_filespec(dst, 1)) 32 return 0; /* error but caught downstream */ 33 34 delta_size = ((src->size < dst->size) ? 35 (dst->size - src->size) : (src->size - dst->size)); 36 37 /* Notice that we use max of src and dst as the base size, 38 * unlike rename similarity detection. This is so that we do 39 * not mistake a large addition as a complete rewrite. 40 */ 41 base_size = ((src->size < dst->size) ? dst->size : src->size); 42 43 /* 44 * If file size difference is too big compared to the 45 * base_size, we declare this a complete rewrite. 46 */ 47 if (base_size * min_score < delta_size * MAX_SCORE) 48 return MAX_SCORE; 49 50 if (diff_populate_filespec(src, 0) || diff_populate_filespec(dst, 0)) 51 return 0; /* error but caught downstream */ 52 53 delta = diff_delta(src->data, src->size, 54 dst->data, dst->size, 55 &delta_size); 56 57 /* A delta that has a lot of literal additions would have 58 * big delta_size no matter what else it does. 59 */ 60 if (base_size * min_score < delta_size * MAX_SCORE) 61 return MAX_SCORE; 62 63 /* Estimate the edit size by interpreting delta. */ 64 delta_size = count_delta(delta, delta_size); 65 free(delta); 66 if (delta_size == UINT_MAX) 67 return 0; /* error in delta computation */ 68 69 if (base_size < delta_size) 70 return MAX_SCORE; 71 72 return delta_size * MAX_SCORE / base_size; 73} 74 75void diffcore_break(int min_score) 76{ 77 struct diff_queue_struct *q = &diff_queued_diff; 78 struct diff_queue_struct outq; 79 int i; 80 81 if (!min_score) 82 min_score = DEFAULT_BREAK_SCORE; 83 84 outq.nr = outq.alloc = 0; 85 outq.queue = NULL; 86 87 for (i = 0; i < q->nr; i++) { 88 struct diff_filepair *p = q->queue[i]; 89 int score; 90 91 /* We deal only with in-place edit of non directory. 92 * We do not break anything else. 93 */ 94 if (DIFF_FILE_VALID(p->one) && DIFF_FILE_VALID(p->two) && 95 !S_ISDIR(p->one->mode) && !S_ISDIR(p->two->mode) && 96 !strcmp(p->one->path, p->two->path)) { 97 score = very_different(p->one, p->two, min_score); 98 if (min_score <= score) { 99 /* Split this into delete and create */ 100 struct diff_filespec *null_one, *null_two; 101 struct diff_filepair *dp; 102 103 /* deletion of one */ 104 null_one = alloc_filespec(p->one->path); 105 dp = diff_queue(&outq, p->one, null_one); 106 dp->score = score; 107 dp->broken_pair = 1; 108 109 /* creation of two */ 110 null_two = alloc_filespec(p->two->path); 111 dp = diff_queue(&outq, null_two, p->two); 112 dp->score = score; 113 dp->broken_pair = 1; 114 115 free(p); /* not diff_free_filepair(), we are 116 * reusing one and two here. 117 */ 118 continue; 119 } 120 } 121 diff_q(&outq, p); 122 } 123 free(q->queue); 124 *q = outq; 125 126 return; 127}