X-Git-Url: https://git.verplant.org/?a=blobdiff_plain;f=diff.c;h=315eb5c26ac347a54ff0a4013ad40844ecf2812e;hb=000182eacf99cde27d5916aa415921924b82972c;hp=ebec71aeee3d318b81c67d4a00687cd363145cf7;hpb=15d061b435a7e3b6bead39df3889f4af78c4b00a;p=git.git diff --git a/diff.c b/diff.c index ebec71ae..315eb5c2 100644 --- a/diff.c +++ b/diff.c @@ -12,6 +12,7 @@ static const char *diff_opts = "-pu"; static unsigned char null_sha1[20] = { 0, }; static int reverse_diff; +static int use_size_cache; static const char *external_diff(void) { @@ -131,10 +132,16 @@ static void builtin_diff(const char *name_a, diff_arg, input_name_sq[0], input_name_sq[1]); printf("diff --git a/%s b/%s\n", name_a, name_b); - if (!path1[0][0]) + if (!path1[0][0]) { printf("new file mode %s\n", temp[1].mode); - else if (!path1[1][0]) + if (xfrm_msg && xfrm_msg[0]) + puts(xfrm_msg); + } + else if (!path1[1][0]) { printf("deleted file mode %s\n", temp[0].mode); + if (xfrm_msg && xfrm_msg[0]) + puts(xfrm_msg); + } else { if (strcmp(temp[0].mode, temp[1].mode)) { printf("old mode %s\n", temp[0].mode); @@ -222,12 +229,60 @@ static int work_tree_matches(const char *name, const unsigned char *sha1) return 1; } +static struct sha1_size_cache { + unsigned char sha1[20]; + unsigned long size; +} **sha1_size_cache; +static int sha1_size_cache_nr, sha1_size_cache_alloc; + +static struct sha1_size_cache *locate_size_cache(unsigned char *sha1, + unsigned long size) +{ + int first, last; + struct sha1_size_cache *e; + + first = 0; + last = sha1_size_cache_nr; + while (last > first) { + int next = (last + first) >> 1; + e = sha1_size_cache[next]; + int cmp = memcmp(e->sha1, sha1, 20); + if (!cmp) + return e; + if (cmp < 0) { + last = next; + continue; + } + first = next+1; + } + /* not found */ + if (size == UINT_MAX) + return NULL; + /* insert to make it at "first" */ + if (sha1_size_cache_alloc <= sha1_size_cache_nr) { + sha1_size_cache_alloc = alloc_nr(sha1_size_cache_alloc); + sha1_size_cache = xrealloc(sha1_size_cache, + sha1_size_cache_alloc * + sizeof(*sha1_size_cache)); + } + sha1_size_cache_nr++; + if (first < sha1_size_cache_nr) + memmove(sha1_size_cache + first + 1, sha1_size_cache + first, + (sha1_size_cache_nr - first - 1) * + sizeof(*sha1_size_cache)); + e = xmalloc(sizeof(struct sha1_size_cache)); + sha1_size_cache[first] = e; + memcpy(e->sha1, sha1, 20); + e->size = size; + return e; +} + /* * While doing rename detection and pickaxe operation, we may need to * grab the data for the blob (or file) for our own in-core comparison. * diff_filespec has data and size fields for this purpose. */ -int diff_populate_filespec(struct diff_filespec *s) +int diff_populate_filespec(struct diff_filespec *s, int size_only) { int err = 0; if (!DIFF_FILE_VALID(s)) @@ -235,6 +290,9 @@ int diff_populate_filespec(struct diff_filespec *s) if (S_ISDIR(s->mode)) return -1; + if (!use_size_cache) + size_only = 0; + if (s->data) return err; if (!s->sha1_valid || @@ -254,6 +312,8 @@ int diff_populate_filespec(struct diff_filespec *s) s->size = st.st_size; if (!s->size) goto empty; + if (size_only) + return 0; if (S_ISLNK(st.st_mode)) { int ret; s->data = xmalloc(s->size); @@ -274,8 +334,21 @@ int diff_populate_filespec(struct diff_filespec *s) } else { char type[20]; - s->data = read_sha1_file(s->sha1, type, &s->size); - s->should_free = 1; + struct sha1_size_cache *e; + + if (size_only) { + e = locate_size_cache(s->sha1, UINT_MAX); + if (e) { + s->size = e->size; + return 0; + } + if (!sha1_file_size(s->sha1, &s->size)) + locate_size_cache(s->sha1, s->size); + } + else { + s->data = read_sha1_file(s->sha1, type, &s->size); + s->should_free = 1; + } } return 0; } @@ -355,13 +428,18 @@ static void prepare_temp_file(const char *name, strcpy(temp->hex, sha1_to_hex(null_sha1)); else strcpy(temp->hex, sha1_to_hex(one->sha1)); - sprintf(temp->mode, "%06o", - S_IFREG |ce_permissions(st.st_mode)); + /* Even though we may sometimes borrow the + * contents from the work tree, we always want + * one->mode. mode is trustworthy even when + * !(one->sha1_valid), as long as + * DIFF_FILE_VALID(one). + */ + sprintf(temp->mode, "%06o", one->mode); } return; } else { - if (diff_populate_filespec(one)) + if (diff_populate_filespec(one, 0)) die("cannot read data blob for %s", one->path); prep_temp_blob(temp, one->data, one->size, one->sha1, one->mode); @@ -496,6 +574,70 @@ void diff_setup(int flags) { if (flags & DIFF_SETUP_REVERSE) reverse_diff = 1; + if (flags & DIFF_SETUP_USE_CACHE) { + if (!active_cache) + /* read-cache does not die even when it fails + * so it is safe for us to do this here. Also + * it does not smudge active_cache or active_nr + * when it fails, so we do not have to worry about + * cleaning it up oufselves either. + */ + read_cache(); + } + if (flags & DIFF_SETUP_USE_SIZE_CACHE) + use_size_cache = 1; + +} + +static int parse_num(const char **cp_p) +{ + int num, scale, ch, cnt; + const char *cp = *cp_p; + + cnt = num = 0; + scale = 1; + while ('0' <= (ch = *cp) && ch <= '9') { + if (cnt++ < 5) { + /* We simply ignore more than 5 digits precision. */ + scale *= 10; + num = num * 10 + ch - '0'; + } + *cp++; + } + *cp_p = cp; + + /* user says num divided by scale and we say internally that + * is MAX_SCORE * num / scale. + */ + return (MAX_SCORE * num / scale); +} + +int diff_scoreopt_parse(const char *opt) +{ + int opt1, opt2, cmd; + + if (*opt++ != '-') + return -1; + cmd = *opt++; + if (cmd != 'M' && cmd != 'C' && cmd != 'B') + return -1; /* that is not a -M, -C nor -B option */ + + opt1 = parse_num(&opt); + if (cmd != 'B') + opt2 = 0; + else { + if (*opt == 0) + opt2 = 0; + else if (*opt != '/') + return -1; /* we expect -B80/99 or -B80 */ + else { + opt++; + opt2 = parse_num(&opt); + } + } + if (*opt != 0) + return -1; + return opt1 | (opt2 << 16); } struct diff_queue_struct diff_queued_diff; @@ -519,6 +661,7 @@ struct diff_filepair *diff_queue(struct diff_queue_struct *queue, dp->two = two; dp->score = 0; dp->source_stays = 0; + dp->broken_pair = 0; diff_q(queue, dp); return dp; } @@ -553,6 +696,16 @@ static void diff_flush_raw(struct diff_filepair *p, sprintf(status, "%c%03d", p->status, (int)(0.5 + p->score * 100.0/MAX_SCORE)); break; + case 'N': case 'D': + two_paths = 0; + if (p->score) + sprintf(status, "%c%03d", p->status, + (int)(0.5 + p->score * 100.0/MAX_SCORE)); + else { + status[0] = p->status; + status[1] = 0; + } + break; default: two_paths = 0; status[0] = p->status; @@ -638,6 +791,16 @@ static void diff_flush_patch(struct diff_filepair *p) p->one->path, p->two->path); msg = msg_; break; + case 'D': case 'N': + if (DIFF_PAIR_BROKEN(p)) { + sprintf(msg_, + "dissimilarity index %d%%", + (int)(0.5 + p->score * 100.0/MAX_SCORE)); + msg = msg_; + } + else + msg = NULL; + break; default: msg = NULL; } @@ -676,8 +839,9 @@ 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 source_stays %d\n", - p->score, p->status ? : '?', p->source_stays); + fprintf(stderr, "score %d, status %c stays %d broken %d\n", + p->score, p->status ? : '?', + p->source_stays, p->broken_pair); } void diff_debug_queue(const char *msg, struct diff_queue_struct *q) @@ -708,27 +872,8 @@ static void diff_resolve_rename_copy(void) p->status = 'U'; else if (!DIFF_FILE_VALID(p->one)) p->status = 'N'; - 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. - */ - for (j = 0; j < q->nr; j++) { - pp = q->queue[j]; - 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_FILE_VALID(p->two)) + p->status = 'D'; else if (DIFF_PAIR_TYPE_CHANGED(p)) p->status = 'T'; @@ -736,7 +881,7 @@ 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 (p->score) { + else if (DIFF_PAIR_RENAME(p)) { if (p->source_stays) { p->status = 'C'; continue; @@ -749,7 +894,7 @@ static void diff_resolve_rename_copy(void) pp = q->queue[j]; if (strcmp(pp->one->path, p->one->path)) continue; /* not us */ - if (!pp->score) + if (!DIFF_PAIR_RENAME(pp)) continue; /* not a rename/copy */ /* pp is a rename/copy from the same source */ p->status = 'C'; @@ -761,12 +906,14 @@ static void diff_resolve_rename_copy(void) else if (memcmp(p->one->sha1, p->two->sha1, 20) || p->one->mode != p->two->mode) p->status = 'M'; - else - /* this is a "no-change" entry. - * should not happen anymore. - * p->status = 'X'; + else { + /* This is a "no-change" entry and should not + * happen anymore, but prepare for broken callers. */ - die("internal error in diffcore: unmodified entry remains"); + error("feeding unmodified %s to diffcore", + p->one->path); + p->status = 'X'; + } } diff_debug_queue("resolve-rename-copy done", q); } @@ -808,6 +955,26 @@ void diff_flush(int diff_output_style, int resolve_rename_copy) q->nr = q->alloc = 0; } +void diffcore_std(const char **paths, + int detect_rename, int rename_score, + const char *pickaxe, int pickaxe_opts, + int break_opt, + const char *orderfile) +{ + if (paths && paths[0]) + diffcore_pathspec(paths); + if (0 <= break_opt) + diffcore_break(break_opt); + if (detect_rename) + diffcore_rename(detect_rename, rename_score); + if (0 <= break_opt) + diffcore_merge_broken(); + if (pickaxe) + diffcore_pickaxe(pickaxe, pickaxe_opts); + if (orderfile) + diffcore_order(orderfile); +} + void diff_addremove(int addremove, unsigned mode, const unsigned char *sha1, const char *base, const char *path)