X-Git-Url: https://git.tokkee.org/?a=blobdiff_plain;f=tree-diff.c;h=852498eb49fe0cba5e1cd21661288e8321a4b20e;hb=1346c9996350e96c7b38a57ede5d503821d84fe3;hp=3940962e79a5094e61270cd951d5d37c307d11a9;hpb=94b9816c5ce5bfc8bf4a8baf2128fa2d429a6898;p=git.git diff --git a/tree-diff.c b/tree-diff.c index 3940962e7..852498eb4 100644 --- a/tree-diff.c +++ b/tree-diff.c @@ -66,13 +66,23 @@ static int compare_tree_entry(struct tree_desc *t1, struct tree_desc *t2, const return 0; } -static int interesting(struct tree_desc *desc, const char *base, int baselen, struct diff_options *opt) +/* + * Is a tree entry interesting given the pathspec we have? + * + * Return: + * - 2 for "yes, and all subsequent entries will be" + * - 1 for yes + * - zero for no + * - negative for "no, and no subsequent entries will be either" + */ +static int tree_entry_interesting(struct tree_desc *desc, const char *base, int baselen, struct diff_options *opt) { const char *path; const unsigned char *sha1; unsigned mode; int i; int pathlen; + int never_interesting = -1; if (!opt->nr_paths) return 1; @@ -81,17 +91,21 @@ static int interesting(struct tree_desc *desc, const char *base, int baselen, st pathlen = tree_entry_len(path, sha1); - for (i=0; i < opt->nr_paths; i++) { + for (i = 0; i < opt->nr_paths; i++) { const char *match = opt->paths[i]; int matchlen = opt->pathlens[i]; + int m = -1; /* signals that we haven't called strncmp() */ 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; + /* + * The base is a subdirectory of a path which + * was specified, so all of them are interesting. + */ + return 2; } /* Does the base match? */ @@ -101,6 +115,37 @@ static int interesting(struct tree_desc *desc, const char *base, int baselen, st match += baselen; matchlen -= baselen; + if (never_interesting) { + /* + * We have not seen any match that sorts later + * than the current path. + */ + + /* + * Does match sort strictly earlier than path + * with their common parts? + */ + m = strncmp(match, path, + (matchlen < pathlen) ? matchlen : pathlen); + if (m < 0) + continue; + + /* + * If we come here even once, that means there is at + * least one pathspec that would sort equal to or + * later than the path we are currently looking at. + * In other words, if we have never reached this point + * after iterating all pathspecs, it means all + * pathspecs are either outside of base, or inside the + * base but sorts strictly earlier than the current + * one. In either case, they will never match the + * subsequent entries. In such a case, we initialized + * the variable to -1 and that is what will be + * returned, allowing the caller to terminate early. + */ + never_interesting = 0; + } + if (pathlen > matchlen) continue; @@ -111,19 +156,42 @@ static int interesting(struct tree_desc *desc, const char *base, int baselen, st continue; } - if (strncmp(path, match, pathlen)) - continue; - - return 1; + if (m == -1) + /* + * we cheated and did not do strncmp(), so we do + * that here. + */ + m = strncmp(match, path, pathlen); + + /* + * If common part matched earlier then it is a hit, + * because we rejected the case where path is not a + * leading directory and is shorter than match. + */ + if (!m) + return 1; } - return 0; /* No matches */ + return never_interesting; /* 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, int baselen) { + int all_interesting = 0; while (desc->size) { - if (interesting(desc, base, baselen, opt)) + int show; + + if (all_interesting) + show = 1; + else { + show = tree_entry_interesting(desc, base, baselen, + opt); + if (show == 2) + all_interesting = 1; + } + if (show < 0) + break; + if (show) show_entry(opt, prefix, desc, base, baselen); update_tree_entry(desc); } @@ -143,12 +211,13 @@ static void show_entry(struct diff_options *opt, const char *prefix, struct tree char *newbase = malloc_base(base, baselen, path, pathlen); struct tree_desc inner; void *tree; + unsigned long size; - tree = read_sha1_file(sha1, &type, &inner.size); + tree = read_sha1_file(sha1, &type, &size); if (!tree || type != OBJ_TREE) die("corrupt tree sha %s", sha1_to_hex(sha1)); - inner.buf = tree; + init_tree_desc(&inner, tree, size); show_tree(opt, prefix, &inner, newbase, baselen + 1 + pathlen); free(tree); @@ -158,22 +227,44 @@ static void show_entry(struct diff_options *opt, const char *prefix, struct tree } } +static void skip_uninteresting(struct tree_desc *t, const char *base, int baselen, struct diff_options *opt) +{ + int all_interesting = 0; + while (t->size) { + int show; + + if (all_interesting) + show = 1; + else { + show = tree_entry_interesting(t, base, baselen, opt); + if (show == 2) + all_interesting = 1; + } + if (!show) { + update_tree_entry(t); + continue; + } + /* Skip it all? */ + if (show < 0) + t->size = 0; + return; + } +} + int diff_tree(struct tree_desc *t1, struct tree_desc *t2, const char *base, struct diff_options *opt) { int baselen = strlen(base); - while (t1->size | t2->size) { + for (;;) { if (opt->quiet && opt->has_changes) break; - if (opt->nr_paths && t1->size && !interesting(t1, base, baselen, opt)) { - update_tree_entry(t1); - continue; - } - if (opt->nr_paths && t2->size && !interesting(t2, base, baselen, opt)) { - update_tree_entry(t2); - continue; + if (opt->nr_paths) { + skip_uninteresting(t1, base, baselen, opt); + skip_uninteresting(t2, base, baselen, opt); } if (!t1->size) { + if (!t2->size) + break; show_entry(opt, "+", t2, base, baselen); update_tree_entry(t2); continue; @@ -203,16 +294,17 @@ int diff_tree_sha1(const unsigned char *old, const unsigned char *new, const cha { void *tree1, *tree2; struct tree_desc t1, t2; + unsigned long size1, size2; int retval; - tree1 = read_object_with_reference(old, tree_type, &t1.size, NULL); + tree1 = read_object_with_reference(old, tree_type, &size1, NULL); if (!tree1) die("unable to read source tree (%s)", sha1_to_hex(old)); - tree2 = read_object_with_reference(new, tree_type, &t2.size, NULL); + tree2 = read_object_with_reference(new, tree_type, &size2, NULL); if (!tree2) die("unable to read destination tree (%s)", sha1_to_hex(new)); - t1.buf = tree1; - t2.buf = tree2; + init_tree_desc(&t1, tree1, size1); + init_tree_desc(&t2, tree2, size2); retval = diff_tree(&t1, &t2, base, opt); free(tree1); free(tree2); @@ -223,15 +315,15 @@ int diff_root_tree_sha1(const unsigned char *new, const char *base, struct diff_ { int retval; void *tree; + unsigned long size; struct tree_desc empty, real; - tree = read_object_with_reference(new, tree_type, &real.size, NULL); + tree = read_object_with_reference(new, tree_type, &size, NULL); if (!tree) die("unable to read root tree (%s)", sha1_to_hex(new)); - real.buf = tree; + init_tree_desc(&real, tree, size); - empty.size = 0; - empty.buf = ""; + init_tree_desc(&empty, "", 0); retval = diff_tree(&empty, &real, base, opt); free(tree); return retval;