X-Git-Url: https://git.octo.it/?a=blobdiff_plain;f=diff.c;h=d7cde8fa056d5f83fe7b97ce44b6c86b87201f80;hb=97658004c311c54e2e4755dc545a9da261bd1441;hp=a6cbf44f443bf5dffb29576e1f426a252cc9eba9;hpb=81e50eabf06dd68e8e62a9b697eaf60904c58b22;p=git.git diff --git a/diff.c b/diff.c index a6cbf44f..d7cde8fa 100644 --- a/diff.c +++ b/diff.c @@ -4,7 +4,6 @@ #include #include #include -#include #include "cache.h" #include "diff.h" #include "diffcore.h" @@ -13,11 +12,7 @@ static const char *diff_opts = "-pu"; static unsigned char null_sha1[20] = { 0, }; static int reverse_diff; -static int generate_patch; -static int line_termination = '\n'; -static int inter_name_termination = '\t'; -static const char **pathspec; -static int speccnt; +static int use_size_cache; static const char *external_diff(void) { @@ -137,17 +132,23 @@ 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); printf("new mode %s\n", temp[1].mode); } if (xfrm_msg && xfrm_msg[0]) - fputs(xfrm_msg, stdout); + puts(xfrm_msg); if (strncmp(temp[0].mode, temp[1].mode, 3)) /* we do not run diff between different kind @@ -168,7 +169,7 @@ struct diff_filespec *alloc_filespec(const char *path) spec->should_free = spec->should_munmap = 0; spec->xfrm_flags = 0; spec->size = 0; - spec->data = 0; + spec->data = NULL; spec->mode = 0; memset(spec->sha1, 0, 20); return spec; @@ -177,8 +178,8 @@ struct diff_filespec *alloc_filespec(const char *path) void fill_filespec(struct diff_filespec *spec, const unsigned char *sha1, unsigned short mode) { - if (mode) { /* just playing defensive */ - spec->mode = mode; + if (mode) { + spec->mode = DIFF_FILE_CANON_MODE(mode); memcpy(spec->sha1, sha1, 20); spec->sha1_valid = !!memcmp(sha1, null_sha1, 20); } @@ -228,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)) @@ -241,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 || @@ -260,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); @@ -279,9 +333,21 @@ int diff_populate_filespec(struct diff_filespec *s) 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); + if (e) { + s->size = e->size; + return 0; + } + } 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; } @@ -293,7 +359,7 @@ void diff_free_filespec_data(struct diff_filespec *s) else if (s->should_munmap) munmap(s->data, s->size); s->should_free = s->should_munmap = 0; - s->data = 0; + s->data = NULL; } static void prep_temp_blob(struct diff_tempfile *temp, @@ -361,13 +427,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); @@ -390,32 +461,14 @@ static void remove_tempfile_on_signal(int signo) remove_tempfile(); } -static int matches_pathspec(const char *name) -{ - int i; - int namelen; - - if (speccnt == 0) - return 1; - - namelen = strlen(name); - for (i = 0; i < speccnt; i++) { - int speclen = strlen(pathspec[i]); - if (! strncmp(pathspec[i], name, speclen) && - speclen <= namelen && - (name[speclen] == 0 || name[speclen] == '/')) - return 1; - } - return 0; -} - /* An external diff command takes: * * diff-cmd name infile1 infile1-sha1 infile1-mode \ * infile2 infile2-sha1 infile2-mode [ rename-to ] * */ -static void run_external_diff(const char *name, +static void run_external_diff(const char *pgm, + const char *name, const char *other, struct diff_filespec *one, struct diff_filespec *two, @@ -426,9 +479,6 @@ static void run_external_diff(const char *name, int status; static int atexit_asked = 0; - if (!matches_pathspec(name) && (!other || !matches_pathspec(other))) - return; - if (one && two) { prepare_temp_file(name, &temp[0], one); prepare_temp_file(other ? : name, &temp[1], two); @@ -446,7 +496,6 @@ static void run_external_diff(const char *name, if (pid < 0) die("unable to fork"); if (!pid) { - const char *pgm = external_diff(); if (pgm) { if (one && two) { const char *exec_arg[10]; @@ -463,7 +512,7 @@ static void run_external_diff(const char *name, *arg++ = other; *arg++ = xfrm_msg; } - *arg = 0; + *arg = NULL; execvp(pgm, (char *const*) exec_arg); } else @@ -496,103 +545,153 @@ static void run_external_diff(const char *name, remove_tempfile(); } -int diff_scoreopt_parse(const char *opt) +static void run_diff(const char *name, + const char *other, + struct diff_filespec *one, + struct diff_filespec *two, + const char *xfrm_msg) { - int diglen, num, scale, i; - if (opt[0] != '-' || (opt[1] != 'M' && opt[1] != 'C')) - return -1; /* that is not a -M nor -C option */ - diglen = strspn(opt+2, "0123456789"); - if (diglen == 0 || strlen(opt+2) != diglen) - return 0; /* use default */ - sscanf(opt+2, "%d", &num); - for (i = 0, scale = 1; i < diglen; i++) - scale *= 10; - - /* user says num divided by scale and we say internally that - * is MAX_SCORE * num / scale. - */ - return MAX_SCORE * num / scale; + const char *pgm = external_diff(); + if (!pgm && + DIFF_FILE_VALID(one) && DIFF_FILE_VALID(two) && + (S_IFMT & one->mode) != (S_IFMT & two->mode)) { + /* a filepair that changes between file and symlink + * needs to be split into deletion and creation. + */ + struct diff_filespec *null = alloc_filespec(two->path); + run_external_diff(NULL, name, other, one, null, xfrm_msg); + free(null); + null = alloc_filespec(one->path); + run_external_diff(NULL, name, other, null, two, xfrm_msg); + free(null); + } + else + run_external_diff(pgm, name, other, one, two, xfrm_msg); } -void diff_setup(int reverse_diff_, int diff_output_style) +void diff_setup(int flags) { - reverse_diff = reverse_diff_; - generate_patch = 0; - switch (diff_output_style) { - case DIFF_FORMAT_HUMAN: - line_termination = '\n'; - inter_name_termination = '\t'; - break; - case DIFF_FORMAT_MACHINE: - line_termination = inter_name_termination = 0; - break; - case DIFF_FORMAT_PATCH: - generate_patch = 1; - break; + 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; + } struct diff_queue_struct diff_queued_diff; -struct diff_filepair *diff_queue(struct diff_queue_struct *queue, - struct diff_filespec *one, - struct diff_filespec *two) +void diff_q(struct diff_queue_struct *queue, struct diff_filepair *dp) { - struct diff_filepair *dp = xmalloc(sizeof(*dp)); - dp->one = one; - dp->two = two; - dp->xfrm_msg = 0; - dp->orig_order = queue->nr; - dp->xfrm_work = 0; if (queue->alloc <= queue->nr) { queue->alloc = alloc_nr(queue->alloc); queue->queue = xrealloc(queue->queue, - sizeof(dp) * queue->alloc); + sizeof(dp) * queue->alloc); } queue->queue[queue->nr++] = dp; - return dp; } -static void diff_flush_raw(struct diff_filepair *p) +struct diff_filepair *diff_queue(struct diff_queue_struct *queue, + struct diff_filespec *one, + struct diff_filespec *two) { - /* - * We used to reject rename/copy but new diff-raw can express them. - */ - printf(":%06o %06o %s ", - p->one->mode, p->two->mode, sha1_to_hex(p->one->sha1)); - printf("%s%c%s%c%s%c", - sha1_to_hex(p->two->sha1), inter_name_termination, - p->one->path, inter_name_termination, - p->two->path, line_termination); + struct diff_filepair *dp = xmalloc(sizeof(*dp)); + dp->one = one; + dp->two = two; + dp->score = 0; + dp->source_stays = 0; + dp->broken_pair = 0; + diff_q(queue, dp); + return dp; } -static void diff_flush_patch(struct diff_filepair *p) +void diff_free_filepair(struct diff_filepair *p) { - const char *name, *other; + diff_free_filespec_data(p->one); + diff_free_filespec_data(p->two); + free(p); +} - name = p->one->path; - other = (strcmp(name, p->two->path) ? p->two->path : NULL); - if ((DIFF_FILE_VALID(p->one) && S_ISDIR(p->one->mode)) || - (DIFF_FILE_VALID(p->two) && S_ISDIR(p->two->mode))) - return; /* no tree diffs in patch format */ +static void diff_flush_raw(struct diff_filepair *p, + int line_termination, + int inter_name_termination) +{ + int two_paths; + char status[10]; + + if (line_termination) { + const char *err = "path %s cannot be expressed without -z"; + if (strchr(p->one->path, line_termination) || + strchr(p->one->path, inter_name_termination)) + die(err, p->one->path); + if (strchr(p->two->path, line_termination) || + strchr(p->two->path, inter_name_termination)) + die(err, p->two->path); + } - run_external_diff(name, other, p->one, p->two, p->xfrm_msg); + switch (p->status) { + case 'C': case 'R': + two_paths = 1; + 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; + status[1] = 0; + break; + } + printf(":%06o %06o %s ", + p->one->mode, p->two->mode, sha1_to_hex(p->one->sha1)); + printf("%s %s%c%s", + sha1_to_hex(p->two->sha1), + status, + inter_name_termination, + p->one->path); + if (two_paths) + printf("%c%s", inter_name_termination, p->two->path); + putchar(line_termination); } -static int identical(struct diff_filespec *one, struct diff_filespec *two) +int diff_unmodified_pair(struct diff_filepair *p) { /* This function is written stricter than necessary to support * the currently implemented transformers, but the idea is to * let transformers to produce diff_filepairs any way they want, * and filter and clean them up here before producing the output. */ + struct diff_filespec *one, *two; + + if (DIFF_PAIR_UNMERGED(p)) + return 0; /* unmerged is interesting */ - if (!DIFF_FILE_VALID(one) && !DIFF_FILE_VALID(two)) - return 1; /* not interesting */ + one = p->one; + two = p->two; - /* deletion, addition, mode change and renames are all interesting. */ + /* deletion, addition, mode or type change + * and rename are all interesting. + */ if (DIFF_FILE_VALID(one) != DIFF_FILE_VALID(two) || - (one->mode != two->mode) || + DIFF_PAIR_MODE_CHANGED(p) || strcmp(one->path, two->path)) return 0; @@ -607,52 +706,219 @@ static int identical(struct diff_filespec *one, struct diff_filespec *two) return 0; } -static void diff_flush_one(struct diff_filepair *p) +static void diff_flush_patch(struct diff_filepair *p) { - if (identical(p->one, p->two)) + const char *name, *other; + char msg_[PATH_MAX*2+200], *msg; + + if (diff_unmodified_pair(p)) return; - if (generate_patch) - diff_flush_patch(p); + + name = p->one->path; + other = (strcmp(name, p->two->path) ? p->two->path : NULL); + if ((DIFF_FILE_VALID(p->one) && S_ISDIR(p->one->mode)) || + (DIFF_FILE_VALID(p->two) && S_ISDIR(p->two->mode))) + return; /* no tree diffs in patch format */ + + switch (p->status) { + case 'C': + sprintf(msg_, + "similarity index %d%%\n" + "copy from %s\n" + "copy to %s", + (int)(0.5 + p->score * 100.0/MAX_SCORE), + p->one->path, p->two->path); + msg = msg_; + break; + case 'R': + sprintf(msg_, + "similarity index %d%%\n" + "rename old %s\n" + "rename new %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; + } + + if (DIFF_PAIR_UNMERGED(p)) + run_diff(name, NULL, NULL, NULL, NULL); else - diff_flush_raw(p); + run_diff(name, other, p->one, p->two, msg); } int diff_queue_is_empty(void) { struct diff_queue_struct *q = &diff_queued_diff; int i; + for (i = 0; i < q->nr; i++) + if (!diff_unmodified_pair(q->queue[i])) + return 0; + return 1; +} +#if DIFF_DEBUG +void diff_debug_filespec(struct diff_filespec *s, int x, const char *one) +{ + fprintf(stderr, "queue[%d] %s (%s) %s %06o %s\n", + x, one ? : "", + s->path, + DIFF_FILE_VALID(s) ? "valid" : "invalid", + s->mode, + s->sha1_valid ? sha1_to_hex(s->sha1) : ""); + fprintf(stderr, "queue[%d] %s size %lu flags %d\n", + x, one ? : "", + s->size, s->xfrm_flags); +} + +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 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) +{ + int i; + if (msg) + fprintf(stderr, "%s\n", msg); + fprintf(stderr, "q->nr = %d\n", q->nr); for (i = 0; i < q->nr; i++) { struct diff_filepair *p = q->queue[i]; - if (!identical(p->one, p->two)) - return 0; + diff_debug_filepair(p, i); } - return 1; } +#endif -void diff_flush(const char **pathspec_, int speccnt_) +static void diff_resolve_rename_copy(void) { + int i, j; + struct diff_filepair *p, *pp; struct diff_queue_struct *q = &diff_queued_diff; - int i; - pathspec = pathspec_; - speccnt = speccnt_; + diff_debug_queue("resolve-rename-copy", q); - for (i = 0; i < q->nr; i++) - diff_flush_one(q->queue[i]); + 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)) + p->status = 'N'; + else if (!DIFF_FILE_VALID(p->two)) + p->status = 'D'; + else if (DIFF_PAIR_TYPE_CHANGED(p)) + p->status = 'T'; + + /* from this point on, we are dealing with a pair + * whose both sides are valid and of the same type, i.e. + * either in-place edit or rename/copy edit. + */ + else if (DIFF_PAIR_RENAME(p)) { + 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 = i + 1; j < q->nr; j++) { + pp = q->queue[j]; + if (strcmp(pp->one->path, p->one->path)) + continue; /* not us */ + if (!DIFF_PAIR_RENAME(pp)) + continue; /* not a rename/copy */ + /* pp is a rename/copy from the same source */ + p->status = 'C'; + break; + } + if (!p->status) + p->status = 'R'; + } + 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'; + */ + die("internal error in diffcore: unmodified entry remains"); + } + diff_debug_queue("resolve-rename-copy done", q); +} + +void diff_flush(int diff_output_style, int resolve_rename_copy) +{ + struct diff_queue_struct *q = &diff_queued_diff; + int i; + int line_termination = '\n'; + int inter_name_termination = '\t'; + + 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]; - diff_free_filespec_data(p->one); - diff_free_filespec_data(p->two); - free(p->xfrm_msg); - free(p); + if ((diff_output_style == DIFF_FORMAT_NO_OUTPUT) || + (p->status == 'X')) + continue; + if (p->status == 0) + die("internal error in diff-resolve-rename-copy"); + switch (diff_output_style) { + case DIFF_FORMAT_PATCH: + diff_flush_patch(p); + break; + case DIFF_FORMAT_HUMAN: + case DIFF_FORMAT_MACHINE: + diff_flush_raw(p, line_termination, + inter_name_termination); + break; + } } + for (i = 0; i < q->nr; i++) + diff_free_filepair(q->queue[i]); free(q->queue); q->queue = NULL; 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 (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) @@ -667,10 +933,10 @@ void diff_addremove(int addremove, unsigned mode, * entries to the diff-core. They will be prefixed * with something like '=' or '*' (I haven't decided * which but should not make any difference). - * Feeding the same new and old to diff_change() should - * also have the same effect. diff_flush() should - * filter the identical ones out at the final output - * stage. + * Feeding the same new and old to diff_change() + * also has the same effect. + * Before the final output happens, they are pruned after + * merged into rename/copy pairs as appropriate. */ if (reverse_diff) addremove = (addremove == '+' ? '-' : @@ -689,28 +955,27 @@ void diff_addremove(int addremove, unsigned mode, diff_queue(&diff_queued_diff, one, two); } -void diff_guif(unsigned old_mode, - unsigned new_mode, - const unsigned char *old_sha1, - const unsigned char *new_sha1, - const char *old_path, - const char *new_path) +void diff_helper_input(unsigned old_mode, + unsigned new_mode, + const unsigned char *old_sha1, + const unsigned char *new_sha1, + const char *old_path, + int status, + int score, + const char *new_path) { struct diff_filespec *one, *two; + struct diff_filepair *dp; - if (reverse_diff) { - unsigned tmp; - const unsigned char *tmp_c; - tmp = old_mode; old_mode = new_mode; new_mode = tmp; - tmp_c = old_sha1; old_sha1 = new_sha1; new_sha1 = tmp_c; - } one = alloc_filespec(old_path); two = alloc_filespec(new_path); if (old_mode) fill_filespec(one, old_sha1, old_mode); if (new_mode) fill_filespec(two, new_sha1, new_mode); - diff_queue(&diff_queued_diff, one, two); + dp = diff_queue(&diff_queued_diff, one, two); + dp->score = score * MAX_SCORE / 100; + dp->status = status; } void diff_change(unsigned old_mode, unsigned new_mode, @@ -739,8 +1004,8 @@ void diff_change(unsigned old_mode, unsigned new_mode, void diff_unmerge(const char *path) { - if (generate_patch) - run_external_diff(path, NULL, NULL, NULL, NULL); - else - printf("U %s%c", path, line_termination); + struct diff_filespec *one, *two; + one = alloc_filespec(path); + two = alloc_filespec(path); + diff_queue(&diff_queued_diff, one, two); }