X-Git-Url: https://git.octo.it/?a=blobdiff_plain;f=diff.c;h=e9936016c6a2b40799317d6b2a1122396a5e59e6;hb=96069cf03aca672e93d862813f2e7f05c1c7ac72;hp=357c4efce1c76a42a56421ce90f35bc1555349dd;hpb=f0c6b2a2fd98b51f1f2655ea69ace9763da28e79;p=git.git diff --git a/diff.c b/diff.c index 357c4efc..e9936016 100644 --- a/diff.c +++ b/diff.c @@ -132,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); @@ -230,6 +236,7 @@ static struct sha1_size_cache { static int sha1_size_cache_nr, sha1_size_cache_alloc; static struct sha1_size_cache *locate_size_cache(unsigned char *sha1, + int find_only, unsigned long size) { int first, last; @@ -238,9 +245,9 @@ static struct sha1_size_cache *locate_size_cache(unsigned char *sha1, first = 0; last = sha1_size_cache_nr; while (last > first) { - int next = (last + first) >> 1; + int cmp, next = (last + first) >> 1; e = sha1_size_cache[next]; - int cmp = memcmp(e->sha1, sha1, 20); + cmp = memcmp(e->sha1, sha1, 20); if (!cmp) return e; if (cmp < 0) { @@ -250,7 +257,7 @@ static struct sha1_size_cache *locate_size_cache(unsigned char *sha1, first = next+1; } /* not found */ - if (size == UINT_MAX) + if (find_only) return NULL; /* insert to make it at "first" */ if (sha1_size_cache_alloc <= sha1_size_cache_nr) { @@ -327,21 +334,22 @@ int diff_populate_filespec(struct diff_filespec *s, int size_only) close(fd); } else { - /* We cannot do size only for SHA1 blobs */ char type[20]; struct sha1_size_cache *e; if (size_only) { - e = locate_size_cache(s->sha1, UINT_MAX); + e = locate_size_cache(s->sha1, 1, 0); if (e) { s->size = e->size; return 0; } + if (!sha1_file_size(s->sha1, &s->size)) + locate_size_cache(s->sha1, 0, s->size); + } + else { + s->data = read_sha1_file(s->sha1, type, &s->size); + s->should_free = 1; } - s->data = read_sha1_file(s->sha1, type, &s->size); - s->should_free = 1; - if (s->data && size_only) - locate_size_cache(s->sha1, s->size); } return 0; } @@ -421,8 +429,13 @@ 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; } @@ -542,6 +555,7 @@ static void run_diff(const char *name, { const char *pgm = external_diff(); if (!pgm && + one && two && DIFF_FILE_VALID(one) && DIFF_FILE_VALID(two) && (S_IFMT & one->mode) != (S_IFMT & two->mode)) { /* a filepair that changes between file and symlink @@ -577,6 +591,57 @@ void diff_setup(int flags) } +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; void diff_q(struct diff_queue_struct *queue, struct diff_filepair *dp) @@ -597,7 +662,9 @@ struct diff_filepair *diff_queue(struct diff_queue_struct *queue, dp->one = one; dp->two = two; dp->score = 0; + dp->status = 0; dp->source_stays = 0; + dp->broken_pair = 0; diff_q(queue, dp); return dp; } @@ -632,6 +699,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; @@ -711,12 +788,22 @@ static void diff_flush_patch(struct diff_filepair *p) case 'R': sprintf(msg_, "similarity index %d%%\n" - "rename old %s\n" - "rename new %s", + "rename from %s\n" + "rename to %s", (int)(0.5 + p->score * 100.0/MAX_SCORE), 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; } @@ -755,8 +842,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) @@ -787,27 +875,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'; @@ -815,7 +884,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; @@ -828,7 +897,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'; @@ -840,17 +909,19 @@ 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); } -void diff_flush(int diff_output_style, int resolve_rename_copy) +void diff_flush(int diff_output_style) { struct diff_queue_struct *q = &diff_queued_diff; int i; @@ -859,8 +930,6 @@ void diff_flush(int diff_output_style, int resolve_rename_copy) if (diff_output_style == DIFF_FORMAT_MACHINE) line_termination = inter_name_termination = 0; - if (resolve_rename_copy) - diff_resolve_rename_copy(); for (i = 0; i < q->nr; i++) { struct diff_filepair *p = q->queue[i]; @@ -887,6 +956,90 @@ void diff_flush(int diff_output_style, int resolve_rename_copy) q->nr = q->alloc = 0; } +static void diffcore_apply_filter(const char *filter) +{ + int i; + struct diff_queue_struct *q = &diff_queued_diff; + struct diff_queue_struct outq; + outq.queue = NULL; + outq.nr = outq.alloc = 0; + + if (!filter) + return; + + if (strchr(filter, 'A')) { + /* All-or-none */ + int found; + for (i = found = 0; !found && i < q->nr; i++) { + struct diff_filepair *p = q->queue[i]; + if ((p->broken_pair && strchr(filter, 'B')) || + (!p->broken_pair && strchr(filter, p->status))) + found++; + } + if (found) + return; + + /* otherwise we will clear the whole queue + * by copying the empty outq at the end of this + * function, but first clear the current entries + * in the queue. + */ + for (i = 0; i < q->nr; i++) + diff_free_filepair(q->queue[i]); + } + else { + /* Only the matching ones */ + for (i = 0; i < q->nr; i++) { + struct diff_filepair *p = q->queue[i]; + if ((p->broken_pair && strchr(filter, 'B')) || + (!p->broken_pair && strchr(filter, p->status))) + diff_q(&outq, p); + else + diff_free_filepair(p); + } + } + free(q->queue); + *q = outq; +} + +void diffcore_std(const char **paths, + int detect_rename, int rename_score, + const char *pickaxe, int pickaxe_opts, + int break_opt, + const char *orderfile, + const char *filter) +{ + if (paths && paths[0]) + diffcore_pathspec(paths); + if (break_opt != -1) + diffcore_break(break_opt); + if (detect_rename) + diffcore_rename(detect_rename, rename_score); + if (break_opt != -1) + diffcore_merge_broken(); + if (pickaxe) + diffcore_pickaxe(pickaxe, pickaxe_opts); + if (orderfile) + diffcore_order(orderfile); + diff_resolve_rename_copy(); + diffcore_apply_filter(filter); +} + + +void diffcore_std_no_resolve(const char **paths, + const char *pickaxe, int pickaxe_opts, + const char *orderfile, + const char *filter) +{ + if (paths && paths[0]) + diffcore_pathspec(paths); + if (pickaxe) + diffcore_pickaxe(pickaxe, pickaxe_opts); + if (orderfile) + diffcore_order(orderfile); + diffcore_apply_filter(filter); +} + void diff_addremove(int addremove, unsigned mode, const unsigned char *sha1, const char *base, const char *path)