X-Git-Url: https://git.octo.it/?a=blobdiff_plain;f=diff.c;h=d8d20c2fcb141124bf4c798eb054e5c1be451f68;hb=f1f0d0889e5557bc467490fdbd53f7b912503a33;hp=eae2fc36e8504a77a5d1ff360ff11bb925b7e9de;hpb=7ca45252a35df8c78060ff233957fc558714a5d6;p=git.git diff --git a/diff.c b/diff.c index eae2fc36..d8d20c2f 100644 --- a/diff.c +++ b/diff.c @@ -4,20 +4,22 @@ #include #include #include -#include #include "cache.h" +#include "quote.h" #include "diff.h" -#include "delta.h" +#include "diffcore.h" static const char *diff_opts = "-pu"; static unsigned char null_sha1[20] = { 0, }; -#define MAX_SCORE 10000 -#define DEFAULT_MINIMUM_SCORE 5000 + +static int reverse_diff; +static int use_size_cache; static const char *external_diff(void) { static const char *external_diff_cmd = NULL; static int done_preparing = 0; + const char *env_diff_opts; if (done_preparing) return external_diff_cmd; @@ -30,85 +32,119 @@ static const char *external_diff(void) * * GIT_DIFF_OPTS="-c"; */ - if (gitenv("GIT_EXTERNAL_DIFF")) - external_diff_cmd = gitenv("GIT_EXTERNAL_DIFF"); + external_diff_cmd = getenv("GIT_EXTERNAL_DIFF"); /* In case external diff fails... */ - diff_opts = gitenv("GIT_DIFF_OPTS") ? : diff_opts; + env_diff_opts = getenv("GIT_DIFF_OPTS"); + if (env_diff_opts) diff_opts = env_diff_opts; done_preparing = 1; return external_diff_cmd; } -/* Help to copy the thing properly quoted for the shell safety. - * any single quote is replaced with '\'', and the caller is - * expected to enclose the result within a single quote pair. - * - * E.g. - * original sq_expand result - * name ==> name ==> 'name' - * a b ==> a b ==> 'a b' - * a'b ==> a'\''b ==> 'a'\''b' - */ -static char *sq_expand(const char *src) -{ - static char *buf = NULL; - int cnt, c; - const char *cp; - char *bp; - - /* count bytes needed to store the quoted string. */ - for (cnt = 1, cp = src; *cp; cnt++, cp++) - if (*cp == '\'') - cnt += 3; - - buf = xmalloc(cnt); - bp = buf; - while ((c = *src++)) { - if (c != '\'') - *bp++ = c; - else { - bp = strcpy(bp, "'\\''"); - bp += 4; - } - } - *bp = 0; - return buf; -} +#define TEMPFILE_PATH_LEN 50 static struct diff_tempfile { - const char *name; + const char *name; /* filename external diff should read from */ char hex[41]; char mode[10]; - char tmp_path[50]; + char tmp_path[TEMPFILE_PATH_LEN]; } diff_temp[2]; -struct diff_spec { - unsigned char blob_sha1[20]; - unsigned short mode; /* file mode */ - unsigned sha1_valid : 1; /* if true, use blob_sha1 and trust mode; - * if false, use the name and read from - * the filesystem. - */ - unsigned file_valid : 1; /* if false the file does not exist */ -}; +static int count_lines(const char *filename) +{ + FILE *in; + int count, ch, completely_empty = 1, nl_just_seen = 0; + in = fopen(filename, "r"); + count = 0; + while ((ch = fgetc(in)) != EOF) + if (ch == '\n') { + count++; + nl_just_seen = 1; + completely_empty = 0; + } + else { + nl_just_seen = 0; + completely_empty = 0; + } + fclose(in); + if (completely_empty) + return 0; + if (!nl_just_seen) + count++; /* no trailing newline */ + return count; +} + +static void print_line_count(int count) +{ + switch (count) { + case 0: + printf("0,0"); + break; + case 1: + printf("1"); + break; + default: + printf("1,%d", count); + break; + } +} + +static void copy_file(int prefix, const char *filename) +{ + FILE *in; + int ch, nl_just_seen = 1; + in = fopen(filename, "r"); + while ((ch = fgetc(in)) != EOF) { + if (nl_just_seen) + putchar(prefix); + putchar(ch); + if (ch == '\n') + nl_just_seen = 1; + else + nl_just_seen = 0; + } + fclose(in); + if (!nl_just_seen) + printf("\n\\ No newline at end of file\n"); +} + +static void emit_rewrite_diff(const char *name_a, + const char *name_b, + struct diff_tempfile *temp) +{ + /* Use temp[i].name as input, name_a and name_b as labels */ + int lc_a, lc_b; + lc_a = count_lines(temp[0].name); + lc_b = count_lines(temp[1].name); + printf("--- %s\n+++ %s\n@@ -", name_a, name_b); + print_line_count(lc_a); + printf(" +"); + print_line_count(lc_b); + printf(" @@\n"); + if (lc_a) + copy_file('-', temp[0].name); + if (lc_b) + copy_file('+', temp[1].name); +} static void builtin_diff(const char *name_a, const char *name_b, struct diff_tempfile *temp, - int rename_score) + const char *xfrm_msg, + int complete_rewrite) { int i, next_at, cmd_size; - const char *diff_cmd = "diff -L'%s%s' -L'%s%s'"; - const char *diff_arg = "'%s' '%s'||:"; /* "||:" is to return 0 */ + const char *const diff_cmd = "diff -L%s%s -L%s%s"; + const char *const diff_arg = "%s %s||:"; /* "||:" is to return 0 */ const char *input_name_sq[2]; const char *path0[2]; const char *path1[2]; const char *name_sq[2]; char *cmd; - name_sq[0] = sq_expand(name_a); - name_sq[1] = sq_expand(name_b); + name_sq[0] = sq_quote(name_a); + name_sq[1] = sq_quote(name_b); /* diff_cmd and diff_arg have 6 %s in total which makes * the sum of these strings 12 bytes larger than required. @@ -118,7 +154,7 @@ static void builtin_diff(const char *name_a, cmd_size = (strlen(diff_cmd) + strlen(diff_opts) + strlen(diff_arg) - 9); for (i = 0; i < 2; i++) { - input_name_sq[i] = sq_expand(temp[i].name); + input_name_sq[i] = sq_quote(temp[i].name); if (!strcmp(temp[i].name, "/dev/null")) { path0[i] = "/dev/null"; path1[i] = ""; @@ -142,33 +178,59 @@ 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 (strcmp(name_a, name_b)) { - if (0 < rename_score) - printf("rename similarity index %d%%\n", - (int)(0.5+ - rename_score*100.0/MAX_SCORE)); - printf("rename old %s\n", name_a); - printf("rename new %s\n", name_b); - } + if (xfrm_msg && xfrm_msg[0]) + puts(xfrm_msg); if (strncmp(temp[0].mode, temp[1].mode, 3)) /* we do not run diff between different kind * of objects. */ exit(0); + if (complete_rewrite) { + fflush(NULL); + emit_rewrite_diff(name_a, name_b, temp); + exit(0); + } } fflush(NULL); execlp("/bin/sh","sh", "-c", cmd, NULL); } +struct diff_filespec *alloc_filespec(const char *path) +{ + int namelen = strlen(path); + struct diff_filespec *spec = xmalloc(sizeof(*spec) + namelen + 1); + + memset(spec, 0, sizeof(*spec)); + spec->path = (char *)(spec + 1); + memcpy(spec->path, path, namelen+1); + return spec; +} + +void fill_filespec(struct diff_filespec *spec, const unsigned char *sha1, + unsigned short mode) +{ + if (mode) { + spec->mode = DIFF_FILE_CANON_MODE(mode); + memcpy(spec->sha1, sha1, 20); + spec->sha1_valid = !!memcmp(sha1, null_sha1, 20); + } +} + /* * Given a name and sha1 pair, if the dircache tells us the file in * the work tree has that object contents, return true, so that @@ -201,13 +263,155 @@ static int work_tree_matches(const char *name, const unsigned char *sha1) return 0; ce = active_cache[pos]; if ((lstat(name, &st) < 0) || - !S_ISREG(st.st_mode) || + !S_ISREG(st.st_mode) || /* careful! */ ce_match_stat(ce, &st) || memcmp(sha1, ce->sha1, 20)) return 0; + /* we return 1 only when we can stat, it is a regular file, + * stat information matches, and sha1 recorded in the cache + * matches. I.e. we know the file in the work tree really is + * the same as the pair. + */ 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, + int find_only, + unsigned long size) +{ + int first, last; + struct sha1_size_cache *e; + + first = 0; + last = sha1_size_cache_nr; + while (last > first) { + int cmp, next = (last + first) >> 1; + e = sha1_size_cache[next]; + cmp = memcmp(e->sha1, sha1, 20); + if (!cmp) + return e; + if (cmp < 0) { + last = next; + continue; + } + first = next+1; + } + /* not found */ + if (find_only) + 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 size_only) +{ + int err = 0; + if (!DIFF_FILE_VALID(s)) + die("internal error: asking to populate invalid file."); + if (S_ISDIR(s->mode)) + return -1; + + if (!use_size_cache) + size_only = 0; + + if (s->data) + return err; + if (!s->sha1_valid || + work_tree_matches(s->path, s->sha1)) { + struct stat st; + int fd; + if (lstat(s->path, &st) < 0) { + if (errno == ENOENT) { + err_empty: + err = -1; + empty: + s->data = ""; + s->size = 0; + return err; + } + } + 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); + s->should_free = 1; + ret = readlink(s->path, s->data, s->size); + if (ret < 0) { + free(s->data); + goto err_empty; + } + return 0; + } + fd = open(s->path, O_RDONLY); + if (fd < 0) + goto err_empty; + s->data = mmap(NULL, s->size, PROT_READ, MAP_PRIVATE, fd, 0); + close(fd); + if (s->data == MAP_FAILED) + goto err_empty; + s->should_munmap = 1; + } + else { + char type[20]; + struct sha1_size_cache *e; + + if (size_only) { + e = locate_size_cache(s->sha1, 1, 0); + if (e) { + s->size = e->size; + return 0; + } + if (!sha1_object_info(s->sha1, type, &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; + } + } + return 0; +} + +void diff_free_filespec_data(struct diff_filespec *s) +{ + if (s->should_free) + free(s->data); + else if (s->should_munmap) + munmap(s->data, s->size); + s->should_free = s->should_munmap = 0; + s->data = NULL; +} + static void prep_temp_blob(struct diff_tempfile *temp, void *blob, unsigned long size, @@ -216,8 +420,7 @@ static void prep_temp_blob(struct diff_tempfile *temp, { int fd; - strcpy(temp->tmp_path, ".diff_XXXXXX"); - fd = mkstemp(temp->tmp_path); + fd = git_mkstemp(temp->tmp_path, TEMPFILE_PATH_LEN, ".diff_XXXXXX"); if (fd < 0) die("unable to create temp-file"); if (write(fd, blob, size) != size) @@ -231,9 +434,9 @@ static void prep_temp_blob(struct diff_tempfile *temp, static void prepare_temp_file(const char *name, struct diff_tempfile *temp, - struct diff_spec *one) + struct diff_filespec *one) { - if (!one->file_valid) { + if (!DIFF_FILE_VALID(one)) { not_a_valid_file: /* A '-' entry produces this for file-2, and * a '+' entry produces this for file-1. @@ -245,13 +448,12 @@ static void prepare_temp_file(const char *name, } if (!one->sha1_valid || - work_tree_matches(name, one->blob_sha1)) { + work_tree_matches(name, one->sha1)) { struct stat st; - temp->name = name; - if (lstat(temp->name, &st) < 0) { + if (lstat(name, &st) < 0) { if (errno == ENOENT) goto not_a_valid_file; - die("stat(%s): %s", temp->name, strerror(errno)); + die("stat(%s): %s", name, strerror(errno)); } if (S_ISLNK(st.st_mode)) { int ret; @@ -263,31 +465,32 @@ static void prepare_temp_file(const char *name, die("readlink(%s)", name); prep_temp_blob(temp, buf, st.st_size, (one->sha1_valid ? - one->blob_sha1 : null_sha1), + one->sha1 : null_sha1), (one->sha1_valid ? one->mode : S_IFLNK)); } else { + /* we can borrow from the file in the work tree */ + temp->name = name; if (!one->sha1_valid) strcpy(temp->hex, sha1_to_hex(null_sha1)); else - strcpy(temp->hex, sha1_to_hex(one->blob_sha1)); - sprintf(temp->mode, "%06o", - S_IFREG |ce_permissions(st.st_mode)); + strcpy(temp->hex, sha1_to_hex(one->sha1)); + /* 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 { - void *blob; - char type[20]; - unsigned long size; - - blob = read_sha1_file(one->blob_sha1, type, &size); - if (!blob || strcmp(type, "blob")) - die("unable to read blob object for %s (%s)", - name, sha1_to_hex(one->blob_sha1)); - prep_temp_blob(temp, blob, size, one->blob_sha1, one->mode); - free(blob); + 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); } } @@ -307,55 +510,30 @@ static void remove_tempfile_on_signal(int signo) remove_tempfile(); } -static int detect_rename; -static int reverse_diff; -static int diff_raw_output = -1; -static const char **pathspec; -static int speccnt; -static int minimum_score; - -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_spec *one, - struct diff_spec *two, - int rename_score) + struct diff_filespec *one, + struct diff_filespec *two, + const char *xfrm_msg, + int complete_rewrite) { struct diff_tempfile *temp = diff_temp; pid_t pid; int status; static int atexit_asked = 0; + const char *othername; - if (!matches_pathspec(name) && (!other || !matches_pathspec(other))) - return; - + othername = (other? other : name); if (one && two) { prepare_temp_file(name, &temp[0], one); - prepare_temp_file(other ? : name, &temp[1], two); + prepare_temp_file(othername, &temp[1], two); if (! atexit_asked && (temp[0].name == temp[0].tmp_path || temp[1].name == temp[1].tmp_path)) { @@ -370,10 +548,9 @@ 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[9]; + const char *exec_arg[10]; const char **arg = &exec_arg[0]; *arg++ = pgm; *arg++ = name; @@ -383,9 +560,11 @@ static void run_external_diff(const char *name, *arg++ = temp[1].name; *arg++ = temp[1].hex; *arg++ = temp[1].mode; - if (other) + if (other) { *arg++ = other; - *arg = 0; + *arg++ = xfrm_msg; + } + *arg = NULL; execvp(pgm, (char *const*) exec_arg); } else @@ -395,7 +574,8 @@ static void run_external_diff(const char *name, * otherwise we use the built-in one. */ if (one && two) - builtin_diff(name, other ? : name, temp, rename_score); + builtin_diff(name, othername, temp, xfrm_msg, + complete_rewrite); else printf("* Unmerged path %s\n", name); exit(0); @@ -418,335 +598,522 @@ static void run_external_diff(const char *name, remove_tempfile(); } -/* - * We do not detect circular renames. Just hold created and deleted - * entries and later attempt to match them up. If they do not match, - * then spit them out as deletes or creates as original. - */ - -static struct diff_spec_hold { - struct diff_spec_hold *next; - struct diff_spec it; - unsigned long size; - int flags; -#define MATCHED 1 -#define SHOULD_FREE 2 -#define SHOULD_MUNMAP 4 - void *data; - char path[1]; -} *createdfile, *deletedfile; - -static void hold_diff(const char *name, - struct diff_spec *one, - struct diff_spec *two) +static void run_diff(struct diff_filepair *p) { - struct diff_spec_hold **list, *elem; - - if (one->file_valid && two->file_valid) - die("internal error"); + const char *pgm = external_diff(); + char msg_[PATH_MAX*2+200], *xfrm_msg; + struct diff_filespec *one; + struct diff_filespec *two; + const char *name; + const char *other; + int complete_rewrite = 0; - if (!detect_rename) { - run_external_diff(name, NULL, one, two, -1); + if (DIFF_PAIR_UNMERGED(p)) { + /* unmerged */ + run_external_diff(pgm, p->one->path, NULL, NULL, NULL, NULL, + 0); return; } - elem = xmalloc(sizeof(*elem) + strlen(name)); - strcpy(elem->path, name); - elem->size = 0; - elem->data = NULL; - elem->flags = 0; - if (one->file_valid) { - list = &deletedfile; - elem->it = *one; + + name = p->one->path; + other = (strcmp(name, p->two->path) ? p->two->path : NULL); + one = p->one; two = p->two; + switch (p->status) { + case DIFF_STATUS_COPIED: + sprintf(msg_, + "similarity index %d%%\n" + "copy from %s\n" + "copy to %s", + (int)(0.5 + p->score * 100.0/MAX_SCORE), + name, other); + xfrm_msg = msg_; + break; + case DIFF_STATUS_RENAMED: + sprintf(msg_, + "similarity index %d%%\n" + "rename from %s\n" + "rename to %s", + (int)(0.5 + p->score * 100.0/MAX_SCORE), + name, other); + xfrm_msg = msg_; + break; + case DIFF_STATUS_MODIFIED: + if (p->score) { + sprintf(msg_, + "dissimilarity index %d%%", + (int)(0.5 + p->score * 100.0/MAX_SCORE)); + xfrm_msg = msg_; + complete_rewrite = 1; + break; + } + /* fallthru */ + default: + xfrm_msg = NULL; } - else { - list = &createdfile; - elem->it = *two; + + 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, 0); + free(null); + null = alloc_filespec(one->path); + run_external_diff(NULL, name, other, null, two, xfrm_msg, 0); + free(null); } - elem->next = *list; - *list = elem; + else + run_external_diff(pgm, name, other, one, two, xfrm_msg, + complete_rewrite); } -static int populate_data(struct diff_spec_hold *s) +void diff_setup(int flags) { - char type[20]; + 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; + +} - if (s->data) - return 0; - if (s->it.sha1_valid) { - s->data = read_sha1_file(s->it.blob_sha1, type, &s->size); - s->flags |= SHOULD_FREE; +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 { - struct stat st; - int fd; - fd = open(s->path, O_RDONLY); - if (fd < 0) - return -1; - if (fstat(fd, &st)) { - close(fd); - return -1; + if (*opt == 0) + opt2 = 0; + else if (*opt != '/') + return -1; /* we expect -B80/99 or -B80 */ + else { + opt++; + opt2 = parse_num(&opt); } - s->size = st.st_size; - s->data = mmap(NULL, s->size, PROT_READ, MAP_PRIVATE, fd, 0); - close(fd); - if (!s->size) - s->data = ""; - else - s->flags |= SHOULD_MUNMAP; } - return 0; + if (*opt != 0) + return -1; + return opt1 | (opt2 << 16); } -static void free_data(struct diff_spec_hold *s) +struct diff_queue_struct diff_queued_diff; + +void diff_q(struct diff_queue_struct *queue, struct diff_filepair *dp) { - if (s->flags & SHOULD_FREE) - free(s->data); - else if (s->flags & SHOULD_MUNMAP) - munmap(s->data, s->size); - s->flags &= ~(SHOULD_FREE|SHOULD_MUNMAP); - s->data = 0; + if (queue->alloc <= queue->nr) { + queue->alloc = alloc_nr(queue->alloc); + queue->queue = xrealloc(queue->queue, + sizeof(dp) * queue->alloc); + } + queue->queue[queue->nr++] = dp; } -static void flush_remaining_diff(struct diff_spec_hold *elem, - int on_created_list) +struct diff_filepair *diff_queue(struct diff_queue_struct *queue, + struct diff_filespec *one, + struct diff_filespec *two) { - static struct diff_spec null_file_spec; + struct diff_filepair *dp = xmalloc(sizeof(*dp)); + dp->one = one; + dp->two = two; + dp->score = 0; + dp->status = 0; + dp->source_stays = 0; + dp->broken_pair = 0; + if (queue) + diff_q(queue, dp); + return dp; +} - null_file_spec.file_valid = 0; - for ( ; elem ; elem = elem->next) { - free_data(elem); - if (elem->flags & MATCHED) - continue; - if (on_created_list) - run_external_diff(elem->path, NULL, - &null_file_spec, &elem->it, -1); - else - run_external_diff(elem->path, NULL, - &elem->it, &null_file_spec, -1); +void diff_free_filepair(struct diff_filepair *p) +{ + diff_free_filespec_data(p->one); + diff_free_filespec_data(p->two); + free(p->one); + free(p->two); + free(p); +} + +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 *const 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); + } + + 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; } + switch (p->status) { + case DIFF_STATUS_COPIED: + case DIFF_STATUS_RENAMED: + two_paths = 1; + break; + case DIFF_STATUS_ADDED: + case DIFF_STATUS_DELETED: + two_paths = 0; + break; + default: + two_paths = 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 is_exact_match(struct diff_spec_hold *src, - struct diff_spec_hold *dst) +static void diff_flush_name(struct diff_filepair *p, + int line_termination) { - if (src->it.sha1_valid && dst->it.sha1_valid && - !memcmp(src->it.blob_sha1, dst->it.blob_sha1, 20)) - return 1; - if (populate_data(src) || populate_data(dst)) - /* this is an error but will be caught downstream */ - return 0; - if (src->size == dst->size && - !memcmp(src->data, dst->data, src->size)) - return 1; - return 0; + printf("%s%c", p->two->path, line_termination); } -int estimate_similarity(struct diff_spec_hold *src, struct diff_spec_hold *dst) +int diff_unmodified_pair(struct diff_filepair *p) { - /* src points at a deleted file and dst points at a created - * file. They may be quite similar, in which case we want to - * say src is renamed to dst. - * - * Compare them and return how similar they are, representing - * the score as an integer between 0 and 10000, except - * where they match exactly it is considered better than anything - * else. + /* 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. */ - void *delta; - unsigned long delta_size; - int score; + struct diff_filespec *one, *two; - delta_size = ((src->size < dst->size) ? - (dst->size - src->size) : (src->size - dst->size)); + if (DIFF_PAIR_UNMERGED(p)) + return 0; /* unmerged is interesting */ - /* We would not consider rename followed by more than - * minimum_score/MAX_SCORE edits; that is, delta_size must be smaller - * than (src->size + dst->size)/2 * minimum_score/MAX_SCORE, - * which means... - */ + one = p->one; + two = p->two; - if ((src->size+dst->size)*minimum_score < delta_size*MAX_SCORE*2) + /* deletion, addition, mode or type change + * and rename are all interesting. + */ + if (DIFF_FILE_VALID(one) != DIFF_FILE_VALID(two) || + DIFF_PAIR_MODE_CHANGED(p) || + strcmp(one->path, two->path)) return 0; - delta = diff_delta(src->data, src->size, - dst->data, dst->size, - &delta_size); - free(delta); - - /* This "delta" is really xdiff with adler32 and all the - * overheads but it is a quick and dirty approximation. - * - * Now we will give some score to it. 100% edit gets - * 0 points and 0% edit gets MAX_SCORE points. That is, every - * 1/MAX_SCORE edit gets 1 point penalty. The amount of penalty is: - * - * (delta_size * 2 / (src->size + dst->size)) * MAX_SCORE - * + /* both are valid and point at the same path. that is, we are + * dealing with a change. */ - score = MAX_SCORE-(MAX_SCORE*2*delta_size/(src->size+dst->size)); - if (score < 0) return 0; - if (MAX_SCORE < score) return MAX_SCORE; - return score; + if (one->sha1_valid && two->sha1_valid && + !memcmp(one->sha1, two->sha1, sizeof(one->sha1))) + return 1; /* no change */ + if (!one->sha1_valid && !two->sha1_valid) + return 1; /* both look at the same file on the filesystem. */ + return 0; } -struct diff_score { - struct diff_spec_hold *src; - struct diff_spec_hold *dst; - int score; -}; - -static int score_compare(const void *a_, const void *b_) +static void diff_flush_patch(struct diff_filepair *p) { - const struct diff_score *a = a_, *b = b_; - return b->score - a->score; + if (diff_unmodified_pair(p)) + return; + + 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 */ + + run_diff(p); } -static void flush_rename_pair(struct diff_spec_hold *src, - struct diff_spec_hold *dst, - int rename_score) +int diff_queue_is_empty(void) { - src->flags |= MATCHED; - dst->flags |= MATCHED; - free_data(src); - free_data(dst); - run_external_diff(src->path, dst->path, - &src->it, &dst->it, rename_score); + 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; } -static void free_held_diff(struct diff_spec_hold *list) +#if DIFF_DEBUG +void diff_debug_filespec(struct diff_filespec *s, int x, const char *one) { - struct diff_spec_hold *h; - for (h = list; list; list = h) { - h = list->next; - free_data(list); - free(list); - } + fprintf(stderr, "queue[%d] %s (%s) %s %06o %s\n", + x, one ? 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 ? one : "", + s->size, s->xfrm_flags); } -void diff_flush(void) +void diff_debug_filepair(const struct diff_filepair *p, int i) { - int num_create, num_delete, c, d; - struct diff_spec_hold *elem, *src, *dst; - struct diff_score *mx; + 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->status : '?', + p->source_stays, p->broken_pair); +} - /* We really want to cull the candidates list early - * with cheap tests in order to avoid doing deltas. - * - * With the current callers, we should not have already - * matched entries at this point, but it is nonetheless - * checked for sanity. - */ - for (dst = createdfile; dst; dst = dst->next) { - if (dst->flags & MATCHED) - continue; - for (src = deletedfile; src; src = src->next) { - if (src->flags & MATCHED) - continue; - if (! is_exact_match(src, dst)) - continue; - flush_rename_pair(src, dst, MAX_SCORE); - break; - } +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]; + diff_debug_filepair(p, i); } +} +#endif - /* Count surviving candidates */ - for (num_create = 0, elem = createdfile; elem; elem = elem->next) - if (!(elem->flags & MATCHED)) - num_create++; - - for (num_delete = 0, elem = deletedfile; elem; elem = elem->next) - if (!(elem->flags & MATCHED)) - num_delete++; - - if (num_create == 0 || num_delete == 0) - goto exit_path; - - mx = xmalloc(sizeof(*mx) * num_create * num_delete); - for (c = 0, dst = createdfile; dst; dst = dst->next) { - int base = c * num_delete; - if (dst->flags & MATCHED) - continue; - for (d = 0, src = deletedfile; src; src = src->next) { - struct diff_score *m = &mx[base+d]; - if (src->flags & MATCHED) +static void diff_resolve_rename_copy(void) +{ + int i, j; + struct diff_filepair *p, *pp; + struct diff_queue_struct *q = &diff_queued_diff; + + diff_debug_queue("resolve-rename-copy", q); + + for (i = 0; i < q->nr; i++) { + p = q->queue[i]; + p->status = 0; /* undecided */ + if (DIFF_PAIR_UNMERGED(p)) + p->status = DIFF_STATUS_UNMERGED; + else if (!DIFF_FILE_VALID(p->one)) + p->status = DIFF_STATUS_ADDED; + else if (!DIFF_FILE_VALID(p->two)) + p->status = DIFF_STATUS_DELETED; + else if (DIFF_PAIR_TYPE_CHANGED(p)) + p->status = DIFF_STATUS_TYPE_CHANGED; + + /* 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 = DIFF_STATUS_COPIED; continue; - m->src = src; - m->dst = dst; - m->score = estimate_similarity(src, dst); - d++; + } + /* See if there is some other filepair that + * copies from the same source as us. If so + * we are a copy. Otherwise we are either a + * copy if the path stays, or a rename if it + * does not, but we already handled "stays" case. + */ + 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 = DIFF_STATUS_COPIED; + break; + } + if (!p->status) + p->status = DIFF_STATUS_RENAMED; + } + else if (memcmp(p->one->sha1, p->two->sha1, 20) || + p->one->mode != p->two->mode) + p->status = DIFF_STATUS_MODIFIED; + else { + /* This is a "no-change" entry and should not + * happen anymore, but prepare for broken callers. + */ + error("feeding unmodified %s to diffcore", + p->one->path); + p->status = DIFF_STATUS_UNKNOWN; } - c++; } - qsort(mx, num_create*num_delete, sizeof(*mx), score_compare); + diff_debug_queue("resolve-rename-copy done", q); +} -#if 0 - for (c = 0; c < num_create * num_delete; c++) { - src = mx[c].src; - dst = mx[c].dst; - if ((src->flags & MATCHED) || (dst->flags & MATCHED)) - continue; - fprintf(stderr, - "**score ** %d %s %s\n", - mx[c].score, src->path, dst->path); - } -#endif +void diff_flush(int diff_output_style, int line_termination) +{ + struct diff_queue_struct *q = &diff_queued_diff; + int i; + int inter_name_termination = '\t'; + + if (!line_termination) + inter_name_termination = 0; - for (c = 0; c < num_create * num_delete; c++) { - src = mx[c].src; - dst = mx[c].dst; - if ((src->flags & MATCHED) || (dst->flags & MATCHED)) + for (i = 0; i < q->nr; i++) { + struct diff_filepair *p = q->queue[i]; + if ((diff_output_style == DIFF_FORMAT_NO_OUTPUT) || + (p->status == DIFF_STATUS_UNKNOWN)) continue; - if (mx[c].score < minimum_score) + 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_RAW: + diff_flush_raw(p, line_termination, + inter_name_termination); + break; + case DIFF_FORMAT_NAME: + diff_flush_name(p, line_termination); break; - flush_rename_pair(src, dst, mx[c].score); + } + diff_free_filepair(q->queue[i]); } - free(mx); - - exit_path: - flush_remaining_diff(createdfile, 1); - flush_remaining_diff(deletedfile, 0); - free_held_diff(createdfile); - free_held_diff(deletedfile); - createdfile = deletedfile = NULL; + free(q->queue); + q->queue = NULL; + q->nr = q->alloc = 0; } -int diff_scoreopt_parse(const char *opt) +static void diffcore_apply_filter(const char *filter) { - int diglen, num, scale, i; - if (opt[0] != '-' || opt[1] != 'M') - return -1; /* that is not -M 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; + int i; + struct diff_queue_struct *q = &diff_queued_diff; + struct diff_queue_struct outq; + outq.queue = NULL; + outq.nr = outq.alloc = 0; - /* user says num divided by scale and we say internally that - * is MAX_SCORE * num / scale. - */ - return MAX_SCORE * num / scale; + if (!filter) + return; + + if (strchr(filter, DIFF_STATUS_FILTER_AON)) { + int found; + for (i = found = 0; !found && i < q->nr; i++) { + struct diff_filepair *p = q->queue[i]; + if (((p->status == DIFF_STATUS_MODIFIED) && + ((p->score && + strchr(filter, DIFF_STATUS_FILTER_BROKEN)) || + (!p->score && + strchr(filter, DIFF_STATUS_MODIFIED)))) || + ((p->status != DIFF_STATUS_MODIFIED) && + 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->status == DIFF_STATUS_MODIFIED) && + ((p->score && + strchr(filter, DIFF_STATUS_FILTER_BROKEN)) || + (!p->score && + strchr(filter, DIFF_STATUS_MODIFIED)))) || + ((p->status != DIFF_STATUS_MODIFIED) && + strchr(filter, p->status))) + diff_q(&outq, p); + else + diff_free_filepair(p); + } + } + free(q->queue); + *q = outq; } -void diff_setup(int detect_rename_, int minimum_score_, int reverse_diff_, - int diff_raw_output_, - const char **pathspec_, int speccnt_) +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) { - free_held_diff(createdfile); - free_held_diff(deletedfile); - createdfile = deletedfile = NULL; - - detect_rename = detect_rename_; - reverse_diff = reverse_diff_; - pathspec = pathspec_; - diff_raw_output = diff_raw_output_; - speccnt = speccnt_; - minimum_score = minimum_score_ ? : DEFAULT_MINIMUM_SCORE; + 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); } -static const char *git_object_type(unsigned mode) + +void diffcore_std_no_resolve(const char **paths, + const char *pickaxe, int pickaxe_opts, + const char *orderfile, + const char *filter) { - return S_ISDIR(mode) ? "tree" : "blob"; + 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, @@ -754,49 +1121,67 @@ void diff_addremove(int addremove, unsigned mode, const char *base, const char *path) { char concatpath[PATH_MAX]; - struct diff_spec spec[2], *one, *two; - + struct diff_filespec *one, *two; + + /* This may look odd, but it is a preparation for + * feeding "there are unchanged files which should + * not produce diffs, but when you are doing copy + * detection you would need them, so here they are" + * 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() + * 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 == '+' ? '-' : '+'); - - if (0 <= diff_raw_output) { - if (!path) - path = ""; - printf("%c%06o %s %s %s%s%c", - addremove, - mode, - git_object_type(mode), sha1_to_hex(sha1), - base, path, diff_raw_output); - return; - } - if (S_ISDIR(mode)) - return; + addremove = (addremove == '+' ? '-' : + addremove == '-' ? '+' : addremove); - memcpy(spec[0].blob_sha1, sha1, 20); - spec[0].mode = mode; - spec[0].sha1_valid = !!memcmp(sha1, null_sha1, 20); - spec[0].file_valid = 1; - spec[1].file_valid = 0; + if (!path) path = ""; + sprintf(concatpath, "%s%s", base, path); + one = alloc_filespec(concatpath); + two = alloc_filespec(concatpath); - if (addremove == '+') { - one = spec + 1; two = spec; - } else { - one = spec; two = one + 1; - } + if (addremove != '+') + fill_filespec(one, sha1, mode); + if (addremove != '-') + fill_filespec(two, sha1, mode); - if (path) { - strcpy(concatpath, base); - strcat(concatpath, path); - } - hold_diff(path ? concatpath : base, one, two); + diff_queue(&diff_queued_diff, one, two); +} + +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; + + 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); + 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, const unsigned char *old_sha1, const unsigned char *new_sha1, - const char *base, const char *path) { + const char *base, const char *path) +{ char concatpath[PATH_MAX]; - struct diff_spec spec[2]; + struct diff_filespec *one, *two; if (reverse_diff) { unsigned tmp; @@ -804,48 +1189,20 @@ void diff_change(unsigned old_mode, unsigned new_mode, tmp = old_mode; old_mode = new_mode; new_mode = tmp; tmp_c = old_sha1; old_sha1 = new_sha1; new_sha1 = tmp_c; } - - if (0 <= diff_raw_output) { - char old_hex[41]; - strcpy(old_hex, sha1_to_hex(old_sha1)); - - if (!path) - path = ""; - printf("*%06o->%06o %s %s->%s %s%s%c", - old_mode, new_mode, - git_object_type(new_mode), - old_hex, sha1_to_hex(new_sha1), - base, path, diff_raw_output); - return; - } - if (S_ISDIR(new_mode)) - return; - - if (path) { - strcpy(concatpath, base); - strcat(concatpath, path); - } - - memcpy(spec[0].blob_sha1, old_sha1, 20); - spec[0].mode = old_mode; - memcpy(spec[1].blob_sha1, new_sha1, 20); - spec[1].mode = new_mode; - spec[0].sha1_valid = !!memcmp(old_sha1, null_sha1, 20); - spec[1].sha1_valid = !!memcmp(new_sha1, null_sha1, 20); - spec[1].file_valid = spec[0].file_valid = 1; - - /* We do not look at changed files as candidate for - * rename detection ever. - */ - run_external_diff(path ? concatpath : base, NULL, - &spec[0], &spec[1], -1); + if (!path) path = ""; + sprintf(concatpath, "%s%s", base, path); + one = alloc_filespec(concatpath); + two = alloc_filespec(concatpath); + fill_filespec(one, old_sha1, old_mode); + fill_filespec(two, new_sha1, new_mode); + + diff_queue(&diff_queued_diff, one, two); } void diff_unmerge(const char *path) { - if (0 <= diff_raw_output) { - printf("U %s%c", path, diff_raw_output); - return; - } - run_external_diff(path, NULL, NULL, NULL, -1); + struct diff_filespec *one, *two; + one = alloc_filespec(path); + two = alloc_filespec(path); + diff_queue(&diff_queued_diff, one, two); }