From ec1fcc16af94810dd822c6da533f58fa2750f14a Mon Sep 17 00:00:00 2001 From: Junio C Hamano Date: Fri, 7 Oct 2005 03:42:00 -0700 Subject: Show original and resulting blob object info in diff output. This adds more cruft to diff --git header to record the blob SHA1 and the mode the patch/diff is intended to be applied against, to help the receiving end fall back on a three-way merge. The new header looks like this: diff --git a/apply.c b/apply.c index 7be5041..8366082 100644 --- a/apply.c +++ b/apply.c @@ -14,6 +14,7 @@ // files that are being modified, but doesn't apply the patch // --stat does just a diffstat, and doesn't actually apply +// --show-index-info shows the old and new index info for... ... Upon receiving such a patch, if the patch did not apply cleanly to the target tree, the recipient can try to find the matching old objects in her object database and create a temporary tree, apply the patch to that temporary tree, and attempt a 3-way merge between the patched temporary tree and the target tree using the original temporary tree as the common ancestor. The patch lifts the code to compute the hash for an on-filesystem object from update-index.c and makes it available to the diff output routine. Signed-off-by: Junio C Hamano --- diff.c | 77 +++++++++++++++++++++++++++++++++++++++++++++++++----------------- 1 file changed, 57 insertions(+), 20 deletions(-) (limited to 'diff.c') diff --git a/diff.c b/diff.c index 7d06b035ae..cbb86320a6 100644 --- a/diff.c +++ b/diff.c @@ -596,15 +596,31 @@ static void run_external_diff(const char *pgm, remove_tempfile(); } +static void diff_fill_sha1_info(struct diff_filespec *one) +{ + if (DIFF_FILE_VALID(one)) { + if (!one->sha1_valid) { + struct stat st; + if (stat(one->path, &st) < 0) + die("stat %s", one->path); + if (index_path(one->sha1, one->path, &st, 0)) + die("cannot hash %s\n", one->path); + } + } + else + memset(one->sha1, 0, 20); +} + static void run_diff(struct diff_filepair *p) { const char *pgm = external_diff(); - char msg_[PATH_MAX*2+200], *xfrm_msg; + char msg[PATH_MAX*2+300], *xfrm_msg; struct diff_filespec *one; struct diff_filespec *two; const char *name; const char *other; int complete_rewrite = 0; + int len; if (DIFF_PAIR_UNMERGED(p)) { /* unmerged */ @@ -616,39 +632,60 @@ static void run_diff(struct diff_filepair *p) name = p->one->path; other = (strcmp(name, p->two->path) ? p->two->path : NULL); one = p->one; two = p->two; + + diff_fill_sha1_info(one); + diff_fill_sha1_info(two); + + len = 0; 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_; + len += snprintf(msg + len, sizeof(msg) - len, + "similarity index %d%%\n" + "copy from %s\n" + "copy to %s\n", + (int)(0.5 + p->score * 100.0/MAX_SCORE), + name, other); 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_; + len += snprintf(msg + len, sizeof(msg) - len, + "similarity index %d%%\n" + "rename from %s\n" + "rename to %s\n", + (int)(0.5 + p->score * 100.0/MAX_SCORE), + name, other); 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_; + len += snprintf(msg + len, sizeof(msg) - len, + "dissimilarity index %d%%\n", + (int)(0.5 + p->score * + 100.0/MAX_SCORE)); complete_rewrite = 1; break; } /* fallthru */ default: - xfrm_msg = NULL; + /* nothing */ + ; } + if (memcmp(one->sha1, two->sha1, 20)) { + char one_sha1[41]; + memcpy(one_sha1, sha1_to_hex(one->sha1), 41); + + len += snprintf(msg + len, sizeof(msg) - len, + "index %.7s..%.7s", one_sha1, + sha1_to_hex(two->sha1)); + if (one->mode == two->mode) + len += snprintf(msg + len, sizeof(msg) - len, + " %06o", one->mode); + len += snprintf(msg + len, sizeof(msg) - len, "\n"); + } + + if (len) + msg[--len] = 0; + xfrm_msg = len ? msg : NULL; + if (!pgm && DIFF_FILE_VALID(one) && DIFF_FILE_VALID(two) && (S_IFMT & one->mode) != (S_IFMT & two->mode)) { -- cgit v1.3 From cf9dfc669e9bae724286d919dec0cd30e3f592e4 Mon Sep 17 00:00:00 2001 From: Junio C Hamano Date: Fri, 14 Oct 2005 21:56:46 -0700 Subject: Update git-diff-* to use C-style quoting for funny pathnames. Signed-off-by: Junio C Hamano --- diff.c | 135 ++++++++++++++++++++++++++++++++++++++++++++++------------------- 1 file changed, 95 insertions(+), 40 deletions(-) (limited to 'diff.c') diff --git a/diff.c b/diff.c index cbb86320a6..823c8d0aab 100644 --- a/diff.c +++ b/diff.c @@ -13,6 +13,46 @@ static const char *diff_opts = "-pu"; static int use_size_cache; +static char *quote_one(const char *str) +{ + int needlen; + char *xp; + + if (!str) + return NULL; + needlen = quote_c_style(str, NULL, NULL, 0); + if (!needlen) + return strdup(str); + xp = xmalloc(needlen + 1); + quote_c_style(str, xp, NULL, 0); + return xp; +} + +static char *quote_two(const char *one, const char *two) +{ + int need_one = quote_c_style(one, NULL, NULL, 1); + int need_two = quote_c_style(two, NULL, NULL, 1); + char *xp; + + if (need_one + need_two) { + if (!need_one) need_one = strlen(one); + if (!need_two) need_one = strlen(two); + + xp = xmalloc(need_one + need_two + 3); + xp[0] = '"'; + quote_c_style(one, xp + 1, NULL, 1); + quote_c_style(two, xp + need_one + 1, NULL, 1); + strcpy(xp + need_one + need_two + 1, "\""); + return xp; + } + need_one = strlen(one); + need_two = strlen(two); + xp = xmalloc(need_one + need_two + 1); + strcpy(xp, one); + strcpy(xp + need_one, two); + return xp; +} + static const char *external_diff(void) { static const char *external_diff_cmd = NULL; @@ -133,55 +173,52 @@ static void builtin_diff(const char *name_a, int complete_rewrite) { int i, next_at, cmd_size; - const char *const diff_cmd = "diff -L%s%s -L%s%s"; + const char *const diff_cmd = "diff -L%s -L%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]; + const char *label_path[2]; char *cmd; - 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. + /* diff_cmd and diff_arg have 4 %s in total which makes + * the sum of these strings 8 bytes larger than required. * we use 2 spaces around diff-opts, and we need to count - * terminating NUL, so we subtract 9 here. + * terminating NUL; we used to subtract 5 here, but we do not + * care about small leaks in this subprocess that is about + * to exec "diff" anymore. */ - cmd_size = (strlen(diff_cmd) + strlen(diff_opts) + - strlen(diff_arg) - 9); + cmd_size = (strlen(diff_cmd) + strlen(diff_opts) + strlen(diff_arg) + + 128); + for (i = 0; i < 2; i++) { input_name_sq[i] = sq_quote(temp[i].name); - if (!strcmp(temp[i].name, "/dev/null")) { - path0[i] = "/dev/null"; - path1[i] = ""; - } else { - path0[i] = i ? "b/" : "a/"; - path1[i] = name_sq[i]; - } - cmd_size += (strlen(path0[i]) + strlen(path1[i]) + - strlen(input_name_sq[i])); + if (!strcmp(temp[i].name, "/dev/null")) + label_path[i] = "/dev/null"; + else if (!i) + label_path[i] = sq_quote(quote_two("a/", name_a)); + else + label_path[i] = sq_quote(quote_two("b/", name_b)); + cmd_size += (strlen(label_path[i]) + strlen(input_name_sq[i])); } cmd = xmalloc(cmd_size); next_at = 0; next_at += snprintf(cmd+next_at, cmd_size-next_at, - diff_cmd, - path0[0], path1[0], path0[1], path1[1]); + diff_cmd, label_path[0], label_path[1]); next_at += snprintf(cmd+next_at, cmd_size-next_at, " %s ", diff_opts); next_at += snprintf(cmd+next_at, cmd_size-next_at, 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]) { + printf("diff --git %s %s\n", + quote_two("a/", name_a), quote_two("b/", name_b)); + if (label_path[0][0] == '/') { + /* dev/null */ printf("new file mode %s\n", temp[1].mode); if (xfrm_msg && xfrm_msg[0]) puts(xfrm_msg); } - else if (!path1[1][0]) { + else if (label_path[1][0] == '/') { printf("deleted file mode %s\n", temp[0].mode); if (xfrm_msg && xfrm_msg[0]) puts(xfrm_msg); @@ -619,6 +656,7 @@ static void run_diff(struct diff_filepair *p) struct diff_filespec *two; const char *name; const char *other; + char *name_munged, *other_munged; int complete_rewrite = 0; int len; @@ -631,6 +669,8 @@ static void run_diff(struct diff_filepair *p) name = p->one->path; other = (strcmp(name, p->two->path) ? p->two->path : NULL); + name_munged = quote_one(name); + other_munged = quote_one(other); one = p->one; two = p->two; diff_fill_sha1_info(one); @@ -644,7 +684,7 @@ static void run_diff(struct diff_filepair *p) "copy from %s\n" "copy to %s\n", (int)(0.5 + p->score * 100.0/MAX_SCORE), - name, other); + name_munged, other_munged); break; case DIFF_STATUS_RENAMED: len += snprintf(msg + len, sizeof(msg) - len, @@ -652,7 +692,7 @@ static void run_diff(struct diff_filepair *p) "rename from %s\n" "rename to %s\n", (int)(0.5 + p->score * 100.0/MAX_SCORE), - name, other); + name_munged, other_munged); break; case DIFF_STATUS_MODIFIED: if (p->score) { @@ -702,6 +742,9 @@ static void run_diff(struct diff_filepair *p) else run_external_diff(pgm, name, other, one, two, xfrm_msg, complete_rewrite); + + free(name_munged); + free(other_munged); } void diff_setup(struct diff_options *options) @@ -878,16 +921,13 @@ static void diff_flush_raw(struct diff_filepair *p, { int two_paths; char status[10]; + const char *path_one, *path_two; + path_one = p->one->path; + path_two = p->two->path; 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); + path_one = quote_one(path_one); + path_two = quote_one(path_two); } if (p->score) @@ -915,16 +955,29 @@ static void diff_flush_raw(struct diff_filepair *p, p->one->mode, p->two->mode, sha1_to_hex(p->one->sha1)); printf("%s ", sha1_to_hex(p->two->sha1)); } - printf("%s%c%s",status, inter_name_termination, p->one->path); + printf("%s%c%s", status, inter_name_termination, path_one); if (two_paths) - printf("%c%s", inter_name_termination, p->two->path); + printf("%c%s", inter_name_termination, path_two); putchar(line_termination); + if (path_one != p->one->path) + free((void*)path_one); + if (path_two != p->two->path) + free((void*)path_two); } static void diff_flush_name(struct diff_filepair *p, + int inter_name_termination, int line_termination) { - printf("%s%c", p->two->path, line_termination); + char *path = p->two->path; + + if (line_termination) + path = quote_one(p->two->path); + else + path = p->two->path; + printf("%s%c", path, line_termination); + if (p->two->path != path) + free(path); } int diff_unmodified_pair(struct diff_filepair *p) @@ -1111,7 +1164,9 @@ void diff_flush(struct diff_options *options) diff_output_format); break; case DIFF_FORMAT_NAME: - diff_flush_name(p, line_termination); + diff_flush_name(p, + inter_name_termination, + line_termination); break; } diff_free_filepair(q->queue[i]); -- cgit v1.3 From 694a764fc2af9463c2462ab1fc92b442fce1a54c Mon Sep 17 00:00:00 2001 From: Linus Torvalds Date: Tue, 18 Oct 2005 00:16:45 -0700 Subject: Handle "-" at beginning of filenames, part 3 This fixes the default built-in exec() of "diff" to add a "--" before the filenames, so that if a filename starts with a "-", the diff program won't think it's an option. Signed-off-by: Linus Torvalds Signed-off-by: Junio C Hamano --- diff.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'diff.c') diff --git a/diff.c b/diff.c index 823c8d0aab..306bcd9807 100644 --- a/diff.c +++ b/diff.c @@ -174,7 +174,7 @@ static void builtin_diff(const char *name_a, { int i, next_at, cmd_size; const char *const diff_cmd = "diff -L%s -L%s"; - const char *const diff_arg = "%s %s||:"; /* "||:" is to return 0 */ + const char *const diff_arg = "-- %s %s||:"; /* "||:" is to return 0 */ const char *input_name_sq[2]; const char *label_path[2]; char *cmd; -- cgit v1.3 From ac1b3d1248f36b26c2eab55022b9a54bde36b1ee Mon Sep 17 00:00:00 2001 From: Linus Torvalds Date: Thu, 20 Oct 2005 21:05:05 -0700 Subject: Split up tree diff functions into tree-diff.c library This makes the tree diff functionality independent of the "git-diff-tree" program, by splitting the core functionality up into a library file. This will be needed for when we teach git-rev-list to only follow a specified set of pathnames, rather than the global revision history. Most of it is a fairly straightforward code move, but it also involves some calling convention cleanup, and moving some of the static variables from diff-tree.c into the options structure. The actual tree change callback routines also become paramterized by the diff_options structure, allowing the library functionality to do something else than just show the diff on stdout. Right now the only user of this functionality remains git-diff-tree itself. Signed-off-by: Linus Torvalds Signed-off-by: Junio C Hamano --- Makefile | 2 +- diff-tree.c | 282 +++--------------------------------------------------------- diff.c | 3 + diff.h | 29 +++++++ tree-diff.c | 270 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 5 files changed, 317 insertions(+), 269 deletions(-) create mode 100644 tree-diff.c (limited to 'diff.c') diff --git a/Makefile b/Makefile index 903c57cdaf..7eacf61b3f 100644 --- a/Makefile +++ b/Makefile @@ -151,7 +151,7 @@ LIB_H = \ DIFF_OBJS = \ diff.o diffcore-break.o diffcore-order.o diffcore-pathspec.o \ - diffcore-pickaxe.o diffcore-rename.o + diffcore-pickaxe.o diffcore-rename.o tree-diff.o LIB_OBJS = \ blob.o commit.o connect.o count-delta.o csum-file.o \ diff --git a/diff-tree.c b/diff-tree.c index 851722037d..382011a2a6 100644 --- a/diff-tree.c +++ b/diff-tree.c @@ -5,256 +5,13 @@ static int show_root_diff = 0; static int verbose_header = 0; static int ignore_merges = 1; -static int recursive = 0; -static int show_tree_entry_in_recursive = 0; static int read_stdin = 0; -static struct diff_options diff_options; - static const char *header = NULL; static const char *header_prefix = ""; static enum cmit_fmt commit_format = CMIT_FMT_RAW; -// What paths are we interested in? -static int nr_paths = 0; -static const char **paths = NULL; -static int *pathlens = NULL; - -static int diff_tree_sha1(const unsigned char *old, const unsigned char *new, const char *base); - -static void update_tree_entry(void **bufp, unsigned long *sizep) -{ - void *buf = *bufp; - unsigned long size = *sizep; - int len = strlen(buf) + 1 + 20; - - if (size < len) - die("corrupt tree file"); - *bufp = buf + len; - *sizep = size - len; -} - -static const unsigned char *extract(void *tree, unsigned long size, const char **pathp, unsigned int *modep) -{ - int len = strlen(tree)+1; - const unsigned char *sha1 = tree + len; - const char *path = strchr(tree, ' '); - unsigned int mode; - - if (!path || size < len + 20 || sscanf(tree, "%o", &mode) != 1) - die("corrupt tree file"); - *pathp = path+1; - *modep = DIFF_FILE_CANON_MODE(mode); - return sha1; -} - -static char *malloc_base(const char *base, const char *path, int pathlen) -{ - int baselen = strlen(base); - char *newbase = xmalloc(baselen + pathlen + 2); - memcpy(newbase, base, baselen); - memcpy(newbase + baselen, path, pathlen); - memcpy(newbase + baselen + pathlen, "/", 2); - return newbase; -} - -static void show_file(const char *prefix, void *tree, unsigned long size, const char *base); -static void show_tree(const char *prefix, void *tree, unsigned long size, const char *base); - -/* A file entry went away or appeared */ -static void show_file(const char *prefix, void *tree, unsigned long size, const char *base) -{ - unsigned mode; - const char *path; - const unsigned char *sha1 = extract(tree, size, &path, &mode); - - if (recursive && S_ISDIR(mode)) { - char type[20]; - unsigned long size; - char *newbase = malloc_base(base, path, strlen(path)); - void *tree; - - tree = read_sha1_file(sha1, type, &size); - if (!tree || strcmp(type, "tree")) - die("corrupt tree sha %s", sha1_to_hex(sha1)); - - show_tree(prefix, tree, size, newbase); - - free(tree); - free(newbase); - return; - } - - diff_addremove(&diff_options, prefix[0], mode, sha1, base, path); -} - -static int compare_tree_entry(void *tree1, unsigned long size1, void *tree2, unsigned long size2, const char *base) -{ - unsigned mode1, mode2; - const char *path1, *path2; - const unsigned char *sha1, *sha2; - int cmp, pathlen1, pathlen2; - - sha1 = extract(tree1, size1, &path1, &mode1); - sha2 = extract(tree2, size2, &path2, &mode2); - - pathlen1 = strlen(path1); - pathlen2 = strlen(path2); - cmp = base_name_compare(path1, pathlen1, mode1, path2, pathlen2, mode2); - if (cmp < 0) { - show_file("-", tree1, size1, base); - return -1; - } - if (cmp > 0) { - show_file("+", tree2, size2, base); - return 1; - } - if (!diff_options.find_copies_harder && - !memcmp(sha1, sha2, 20) && mode1 == mode2) - return 0; - - /* - * If the filemode has changed to/from a directory from/to a regular - * file, we need to consider it a remove and an add. - */ - if (S_ISDIR(mode1) != S_ISDIR(mode2)) { - show_file("-", tree1, size1, base); - show_file("+", tree2, size2, base); - return 0; - } - - if (recursive && S_ISDIR(mode1)) { - int retval; - char *newbase = malloc_base(base, path1, pathlen1); - if (show_tree_entry_in_recursive) - diff_change(&diff_options, mode1, mode2, - sha1, sha2, base, path1); - retval = diff_tree_sha1(sha1, sha2, newbase); - free(newbase); - return retval; - } - - diff_change(&diff_options, mode1, mode2, sha1, sha2, base, path1); - return 0; -} - -static int interesting(void *tree, unsigned long size, const char *base) -{ - const char *path; - unsigned mode; - int i; - int baselen, pathlen; - - if (!nr_paths) - return 1; - - (void)extract(tree, size, &path, &mode); - - pathlen = strlen(path); - baselen = strlen(base); - - for (i=0; i < nr_paths; i++) { - const char *match = paths[i]; - int matchlen = pathlens[i]; - - if (baselen >= matchlen) { - /* If it doesn't match, move along... */ - if (strncmp(base, match, matchlen)) - continue; - - /* The base is a subdirectory of a path which was specified. */ - return 1; - } - - /* Does the base match? */ - if (strncmp(base, match, baselen)) - continue; - - match += baselen; - matchlen -= baselen; - - if (pathlen > matchlen) - continue; - - if (matchlen > pathlen) { - if (match[pathlen] != '/') - continue; - if (!S_ISDIR(mode)) - continue; - } - - if (strncmp(path, match, pathlen)) - continue; - - return 1; - } - return 0; /* No matches */ -} - -/* A whole sub-tree went away or appeared */ -static void show_tree(const char *prefix, void *tree, unsigned long size, const char *base) -{ - while (size) { - if (interesting(tree, size, base)) - show_file(prefix, tree, size, base); - update_tree_entry(&tree, &size); - } -} - -static int diff_tree(void *tree1, unsigned long size1, void *tree2, unsigned long size2, const char *base) -{ - while (size1 | size2) { - if (nr_paths && size1 && !interesting(tree1, size1, base)) { - update_tree_entry(&tree1, &size1); - continue; - } - if (nr_paths && size2 && !interesting(tree2, size2, base)) { - update_tree_entry(&tree2, &size2); - continue; - } - if (!size1) { - show_file("+", tree2, size2, base); - update_tree_entry(&tree2, &size2); - continue; - } - if (!size2) { - show_file("-", tree1, size1, base); - update_tree_entry(&tree1, &size1); - continue; - } - switch (compare_tree_entry(tree1, size1, tree2, size2, base)) { - case -1: - update_tree_entry(&tree1, &size1); - continue; - case 0: - update_tree_entry(&tree1, &size1); - /* Fallthrough */ - case 1: - update_tree_entry(&tree2, &size2); - continue; - } - die("git-diff-tree: internal error"); - } - return 0; -} - -static int diff_tree_sha1(const unsigned char *old, const unsigned char *new, const char *base) -{ - void *tree1, *tree2; - unsigned long size1, size2; - int retval; - - tree1 = read_object_with_reference(old, "tree", &size1, NULL); - if (!tree1) - die("unable to read source tree (%s)", sha1_to_hex(old)); - tree2 = read_object_with_reference(new, "tree", &size2, NULL); - if (!tree2) - die("unable to read destination tree (%s)", sha1_to_hex(new)); - retval = diff_tree(tree1, size1, tree2, size2, base); - free(tree1); - free(tree2); - return retval; -} +static struct diff_options diff_options; static void call_diff_setup_done(void) { @@ -285,7 +42,7 @@ static int diff_tree_sha1_top(const unsigned char *old, int ret; call_diff_setup_done(); - ret = diff_tree_sha1(old, new, base); + ret = diff_tree_sha1(old, new, base, &diff_options); call_diff_flush(); return ret; } @@ -294,13 +51,17 @@ static int diff_root_tree(const unsigned char *new, const char *base) { int retval; void *tree; - unsigned long size; + struct tree_desc empty, real; call_diff_setup_done(); - tree = read_object_with_reference(new, "tree", &size, NULL); + tree = read_object_with_reference(new, "tree", &real.size, NULL); if (!tree) die("unable to read root tree (%s)", sha1_to_hex(new)); - retval = diff_tree("", 0, tree, size, base); + real.buf = tree; + + empty.buf = ""; + empty.size = 0; + retval = diff_tree(&empty, &real, base, &diff_options); free(tree); call_diff_flush(); return retval; @@ -387,14 +148,6 @@ static int diff_tree_stdin(char *line) return diff_tree_commit(commit, line); } -static int count_paths(const char **paths) -{ - int i = 0; - while (*paths++) - i++; - return i; -} - static const char diff_tree_usage[] = "git-diff-tree [--stdin] [-m] [-s] [-v] [--pretty] [-t] " "[] " @@ -445,11 +198,12 @@ int main(int argc, const char **argv) break; } if (!strcmp(arg, "-r")) { - recursive = 1; + diff_options.recursive = 1; continue; } if (!strcmp(arg, "-t")) { - recursive = show_tree_entry_in_recursive = 1; + diff_options.recursive = 1; + diff_options.tree_in_recursive = 1; continue; } if (!strcmp(arg, "-m")) { @@ -478,17 +232,9 @@ int main(int argc, const char **argv) usage(diff_tree_usage); } if (diff_options.output_format == DIFF_FORMAT_PATCH) - recursive = 1; + diff_options.recursive = 1; - paths = get_pathspec(prefix, argv); - if (paths) { - int i; - - nr_paths = count_paths(paths); - pathlens = xmalloc(nr_paths * sizeof(int)); - for (i=0; iline_termination = '\n'; options->break_opt = -1; options->rename_limit = -1; + + options->change = diff_change; + options->add_remove = diff_addremove; } int diff_setup_done(struct diff_options *options) diff --git a/diff.h b/diff.h index 2f4a7b463b..51155479a4 100644 --- a/diff.h +++ b/diff.h @@ -8,11 +8,31 @@ (S_ISREG(mode) ? (S_IFREG | ce_permissions(mode)) : \ S_ISLNK(mode) ? S_IFLNK : S_IFDIR) +struct tree_desc { + void *buf; + unsigned long size; +}; + +struct diff_options; + +typedef void (*change_fn_t)(struct diff_options *options, + unsigned old_mode, unsigned new_mode, + const unsigned char *old_sha1, + const unsigned char *new_sha1, + const char *base, const char *path); + +typedef void (*add_remove_fn_t)(struct diff_options *options, + int addremove, unsigned mode, + const unsigned char *sha1, + const char *base, const char *path); + struct diff_options { const char **paths; const char *filter; const char *orderfile; const char *pickaxe; + unsigned recursive:1, + tree_in_recursive:1; int break_opt; int detect_rename; int find_copies_harder; @@ -23,8 +43,17 @@ struct diff_options { int reverse_diff; int rename_limit; int setup; + + change_fn_t change; + add_remove_fn_t add_remove; }; +extern void diff_tree_setup_paths(const char **paths); +extern int diff_tree(struct tree_desc *t1, struct tree_desc *t2, + const char *base, struct diff_options *opt); +extern int diff_tree_sha1(const unsigned char *old, const unsigned char *new, + const char *base, struct diff_options *opt); + extern void diff_addremove(struct diff_options *, int addremove, unsigned mode, diff --git a/tree-diff.c b/tree-diff.c new file mode 100644 index 0000000000..0ef06a9e36 --- /dev/null +++ b/tree-diff.c @@ -0,0 +1,270 @@ +/* + * Helper functions for tree diff generation + */ +#include "cache.h" +#include "diff.h" + +// What paths are we interested in? +static int nr_paths = 0; +static const char **paths = NULL; +static int *pathlens = NULL; + +static void update_tree_entry(struct tree_desc *desc) +{ + void *buf = desc->buf; + unsigned long size = desc->size; + int len = strlen(buf) + 1 + 20; + + if (size < len) + die("corrupt tree file"); + desc->buf = buf + len; + desc->size = size - len; +} + +static const unsigned char *extract(struct tree_desc *desc, const char **pathp, unsigned int *modep) +{ + void *tree = desc->buf; + unsigned long size = desc->size; + int len = strlen(tree)+1; + const unsigned char *sha1 = tree + len; + const char *path = strchr(tree, ' '); + unsigned int mode; + + if (!path || size < len + 20 || sscanf(tree, "%o", &mode) != 1) + die("corrupt tree file"); + *pathp = path+1; + *modep = DIFF_FILE_CANON_MODE(mode); + return sha1; +} + +static char *malloc_base(const char *base, const char *path, int pathlen) +{ + int baselen = strlen(base); + char *newbase = xmalloc(baselen + pathlen + 2); + memcpy(newbase, base, baselen); + memcpy(newbase + baselen, path, pathlen); + memcpy(newbase + baselen + pathlen, "/", 2); + return newbase; +} + +static int show_entry(struct diff_options *opt, const char *prefix, struct tree_desc *desc, const char *base); + +static int compare_tree_entry(struct tree_desc *t1, struct tree_desc *t2, const char *base, struct diff_options *opt) +{ + unsigned mode1, mode2; + const char *path1, *path2; + const unsigned char *sha1, *sha2; + int cmp, pathlen1, pathlen2; + + sha1 = extract(t1, &path1, &mode1); + sha2 = extract(t2, &path2, &mode2); + + pathlen1 = strlen(path1); + pathlen2 = strlen(path2); + cmp = base_name_compare(path1, pathlen1, mode1, path2, pathlen2, mode2); + if (cmp < 0) { + show_entry(opt, "-", t1, base); + return -1; + } + if (cmp > 0) { + show_entry(opt, "+", t2, base); + return 1; + } + if (!opt->find_copies_harder && + !memcmp(sha1, sha2, 20) && mode1 == mode2) + return 0; + + /* + * If the filemode has changed to/from a directory from/to a regular + * file, we need to consider it a remove and an add. + */ + if (S_ISDIR(mode1) != S_ISDIR(mode2)) { + show_entry(opt, "-", t1, base); + show_entry(opt, "+", t2, base); + return 0; + } + + if (opt->recursive && S_ISDIR(mode1)) { + int retval; + char *newbase = malloc_base(base, path1, pathlen1); + if (opt->tree_in_recursive) + opt->change(opt, mode1, mode2, + sha1, sha2, base, path1); + retval = diff_tree_sha1(sha1, sha2, newbase, opt); + free(newbase); + return retval; + } + + opt->change(opt, mode1, mode2, sha1, sha2, base, path1); + return 0; +} + +static int interesting(struct tree_desc *desc, const char *base) +{ + const char *path; + unsigned mode; + int i; + int baselen, pathlen; + + if (!nr_paths) + return 1; + + (void)extract(desc, &path, &mode); + + pathlen = strlen(path); + baselen = strlen(base); + + for (i=0; i < nr_paths; i++) { + const char *match = paths[i]; + int matchlen = pathlens[i]; + + if (baselen >= matchlen) { + /* If it doesn't match, move along... */ + if (strncmp(base, match, matchlen)) + continue; + + /* The base is a subdirectory of a path which was specified. */ + return 1; + } + + /* Does the base match? */ + if (strncmp(base, match, baselen)) + continue; + + match += baselen; + matchlen -= baselen; + + if (pathlen > matchlen) + continue; + + if (matchlen > pathlen) { + if (match[pathlen] != '/') + continue; + if (!S_ISDIR(mode)) + continue; + } + + if (strncmp(path, match, pathlen)) + continue; + + return 1; + } + return 0; /* No matches */ +} + +/* A whole sub-tree went away or appeared */ +static void show_tree(struct diff_options *opt, const char *prefix, struct tree_desc *desc, const char *base) +{ + while (desc->size) { + if (interesting(desc, base)) + show_entry(opt, prefix, desc, base); + update_tree_entry(desc); + } +} + +/* A file entry went away or appeared */ +static int show_entry(struct diff_options *opt, const char *prefix, struct tree_desc *desc, const char *base) +{ + unsigned mode; + const char *path; + const unsigned char *sha1 = extract(desc, &path, &mode); + + if (opt->recursive && S_ISDIR(mode)) { + char type[20]; + char *newbase = malloc_base(base, path, strlen(path)); + struct tree_desc inner; + void *tree; + + tree = read_sha1_file(sha1, type, &inner.size); + if (!tree || strcmp(type, "tree")) + die("corrupt tree sha %s", sha1_to_hex(sha1)); + + inner.buf = tree; + show_tree(opt, prefix, &inner, newbase); + + free(tree); + free(newbase); + return 0; + } + + opt->add_remove(opt, prefix[0], mode, sha1, base, path); + return 0; +} + +int diff_tree(struct tree_desc *t1, struct tree_desc *t2, const char *base, struct diff_options *opt) +{ + while (t1->size | t2->size) { + if (nr_paths && t1->size && !interesting(t1, base)) { + update_tree_entry(t1); + continue; + } + if (nr_paths && t2->size && !interesting(t2, base)) { + update_tree_entry(t2); + continue; + } + if (!t1->size) { + show_entry(opt, "+", t2, base); + update_tree_entry(t2); + continue; + } + if (!t2->size) { + show_entry(opt, "-", t1, base); + update_tree_entry(t1); + continue; + } + switch (compare_tree_entry(t1, t2, base, opt)) { + case -1: + update_tree_entry(t1); + continue; + case 0: + update_tree_entry(t1); + /* Fallthrough */ + case 1: + update_tree_entry(t2); + continue; + } + die("git-diff-tree: internal error"); + } + return 0; +} + +int diff_tree_sha1(const unsigned char *old, const unsigned char *new, const char *base, struct diff_options *opt) +{ + void *tree1, *tree2; + struct tree_desc t1, t2; + int retval; + + tree1 = read_object_with_reference(old, "tree", &t1.size, NULL); + if (!tree1) + die("unable to read source tree (%s)", sha1_to_hex(old)); + tree2 = read_object_with_reference(new, "tree", &t2.size, NULL); + if (!tree2) + die("unable to read destination tree (%s)", sha1_to_hex(new)); + t1.buf = tree1; + t2.buf = tree2; + retval = diff_tree(&t1, &t2, base, opt); + free(tree1); + free(tree2); + return retval; +} + +static int count_paths(const char **paths) +{ + int i = 0; + while (*paths++) + i++; + return i; +} + +void diff_tree_setup_paths(const char **p) +{ + if (p) { + int i; + + paths = p; + nr_paths = count_paths(paths); + pathlens = xmalloc(nr_paths * sizeof(int)); + for (i=0; i