X-Git-Url: https://git.octo.it/?a=blobdiff_plain;f=revision.c;h=0505f3f455151ac2fafc7fe2df2e6fd147d20f08;hb=42b5c78845feb44f1d36eecad4c72336d5c2a9c5;hp=2a33637f62878f225c4eb74fbbd2ed5272cc36bb;hpb=3bcd59a546333ae355c87577ba63f8dccd50a519;p=git.git diff --git a/revision.c b/revision.c index 2a33637f..0505f3f4 100644 --- a/revision.c +++ b/revision.c @@ -82,18 +82,20 @@ void mark_parents_uninteresting(struct commit *commit) while (parents) { struct commit *commit = parents->item; - commit->object.flags |= UNINTERESTING; - - /* - * Normally we haven't parsed the parent - * yet, so we won't have a parent of a parent - * here. However, it may turn out that we've - * reached this commit some other way (where it - * wasn't uninteresting), in which case we need - * to mark its parents recursively too.. - */ - if (commit->parents) - mark_parents_uninteresting(commit); + if (!(commit->object.flags & UNINTERESTING)) { + commit->object.flags |= UNINTERESTING; + + /* + * Normally we haven't parsed the parent + * yet, so we won't have a parent of a parent + * here. However, it may turn out that we've + * reached this commit some other way (where it + * wasn't uninteresting), in which case we need + * to mark its parents recursively too.. + */ + if (commit->parents) + mark_parents_uninteresting(commit); + } /* * A missing commit is ok iff its parent is marked @@ -197,31 +199,27 @@ static int everybody_uninteresting(struct commit_list *orig) return 1; } -#define TREE_SAME 0 -#define TREE_NEW 1 -#define TREE_DIFFERENT 2 -static int tree_difference = TREE_SAME; +static int tree_difference = REV_TREE_SAME; static void file_add_remove(struct diff_options *options, int addremove, unsigned mode, const unsigned char *sha1, const char *base, const char *path) { - int diff = TREE_DIFFERENT; + int diff = REV_TREE_DIFFERENT; /* - * Is it an add of a new file? It means that - * the old tree didn't have it at all, so we - * will turn "TREE_SAME" -> "TREE_NEW", but - * leave any "TREE_DIFFERENT" alone (and if - * it already was "TREE_NEW", we'll keep it - * "TREE_NEW" of course). + * Is it an add of a new file? It means that the old tree + * didn't have it at all, so we will turn "REV_TREE_SAME" -> + * "REV_TREE_NEW", but leave any "REV_TREE_DIFFERENT" alone + * (and if it already was "REV_TREE_NEW", we'll keep it + * "REV_TREE_NEW" of course). */ if (addremove == '+') { diff = tree_difference; - if (diff != TREE_SAME) + if (diff != REV_TREE_SAME) return; - diff = TREE_NEW; + diff = REV_TREE_NEW; } tree_difference = diff; } @@ -232,28 +230,23 @@ static void file_change(struct diff_options *options, const unsigned char *new_sha1, const char *base, const char *path) { - tree_difference = TREE_DIFFERENT; + tree_difference = REV_TREE_DIFFERENT; } -static struct diff_options diff_opt = { - .recursive = 1, - .add_remove = file_add_remove, - .change = file_change, -}; - -static int compare_tree(struct tree *t1, struct tree *t2) +int rev_compare_tree(struct rev_info *revs, struct tree *t1, struct tree *t2) { if (!t1) - return TREE_NEW; + return REV_TREE_NEW; if (!t2) - return TREE_DIFFERENT; - tree_difference = TREE_SAME; - if (diff_tree_sha1(t1->object.sha1, t2->object.sha1, "", &diff_opt) < 0) - return TREE_DIFFERENT; + return REV_TREE_DIFFERENT; + tree_difference = REV_TREE_SAME; + if (diff_tree_sha1(t1->object.sha1, t2->object.sha1, "", + &revs->diffopt) < 0) + return REV_TREE_DIFFERENT; return tree_difference; } -static int same_tree_as_empty(struct tree *t1) +int rev_same_tree_as_empty(struct rev_info *revs, struct tree *t1) { int retval; void *tree; @@ -262,7 +255,7 @@ static int same_tree_as_empty(struct tree *t1) if (!t1) return 0; - tree = read_object_with_reference(t1->object.sha1, "tree", &real.size, NULL); + tree = read_object_with_reference(t1->object.sha1, tree_type, &real.size, NULL); if (!tree) return 0; real.buf = tree; @@ -271,7 +264,7 @@ static int same_tree_as_empty(struct tree *t1) empty.size = 0; tree_difference = 0; - retval = diff_tree(&empty, &real, "", &diff_opt); + retval = diff_tree(&empty, &real, "", &revs->diffopt); free(tree); return retval >= 0 && !tree_difference; @@ -280,12 +273,13 @@ static int same_tree_as_empty(struct tree *t1) static void try_to_simplify_commit(struct rev_info *revs, struct commit *commit) { struct commit_list **pp, *parent; + int tree_changed = 0; if (!commit->tree) return; if (!commit->parents) { - if (!same_tree_as_empty(commit->tree)) + if (!rev_same_tree_as_empty(revs, commit->tree)) commit->object.flags |= TREECHANGE; return; } @@ -294,37 +288,57 @@ static void try_to_simplify_commit(struct rev_info *revs, struct commit *commit) while ((parent = *pp) != NULL) { struct commit *p = parent->item; - if (p->object.flags & UNINTERESTING) { - pp = &parent->next; - continue; - } - parse_commit(p); - switch (compare_tree(p->tree, commit->tree)) { - case TREE_SAME: + switch (rev_compare_tree(revs, p->tree, commit->tree)) { + case REV_TREE_SAME: + if (p->object.flags & UNINTERESTING) { + /* Even if a merge with an uninteresting + * side branch brought the entire change + * we are interested in, we do not want + * to lose the other branches of this + * merge, so we just keep going. + */ + pp = &parent->next; + continue; + } parent->next = NULL; commit->parents = parent; return; - case TREE_NEW: - if (revs->remove_empty_trees && same_tree_as_empty(p->tree)) { - *pp = parent->next; - continue; + case REV_TREE_NEW: + if (revs->remove_empty_trees && + rev_same_tree_as_empty(revs, p->tree)) { + /* We are adding all the specified + * paths from this parent, so the + * history beyond this parent is not + * interesting. Remove its parents + * (they are grandparents for us). + * IOW, we pretend this parent is a + * "root" commit. + */ + parse_commit(p); + p->parents = NULL; } /* fallthrough */ - case TREE_DIFFERENT: + case REV_TREE_DIFFERENT: + tree_changed = 1; pp = &parent->next; continue; } die("bad tree compare for commit %s", sha1_to_hex(commit->object.sha1)); } - commit->object.flags |= TREECHANGE; + if (tree_changed) + commit->object.flags |= TREECHANGE; } static void add_parents_to_list(struct rev_info *revs, struct commit *commit, struct commit_list **list) { struct commit_list *parent = commit->parents; + if (commit->object.flags & ADDED) + return; + commit->object.flags |= ADDED; + /* * If the commit is uninteresting, don't try to * prune parents - we want the maximal uninteresting @@ -358,8 +372,8 @@ static void add_parents_to_list(struct rev_info *revs, struct commit *commit, st * simplify the commit history and find the parent * that has no differences in the path set if one exists. */ - if (revs->paths) - try_to_simplify_commit(revs, commit); + if (revs->prune_fn) + revs->prune_fn(revs, commit); parent = commit->parents; while (parent) { @@ -381,9 +395,6 @@ static void limit_list(struct rev_info *revs) struct commit_list *newlist = NULL; struct commit_list **p = &newlist; - if (revs->paths) - diff_tree_setup_paths(revs->paths); - while (list) { struct commit_list *entry = list; struct commit *commit = list->item; @@ -407,6 +418,36 @@ static void limit_list(struct rev_info *revs) continue; p = &commit_list_insert(commit, p)->next; } + if (revs->boundary) { + /* mark the ones that are on the result list first */ + for (list = newlist; list; list = list->next) { + struct commit *commit = list->item; + commit->object.flags |= TMP_MARK; + } + for (list = newlist; list; list = list->next) { + struct commit *commit = list->item; + struct object *obj = &commit->object; + struct commit_list *parent; + if (obj->flags & UNINTERESTING) + continue; + for (parent = commit->parents; + parent; + parent = parent->next) { + struct commit *pcommit = parent->item; + if (!(pcommit->object.flags & UNINTERESTING)) + continue; + pcommit->object.flags |= BOUNDARY; + if (pcommit->object.flags & TMP_MARK) + continue; + pcommit->object.flags |= TMP_MARK; + p = &commit_list_insert(pcommit, p)->next; + } + } + for (list = newlist; list; list = list->next) { + struct commit *commit = list->item; + commit->object.flags &= ~TMP_MARK; + } + } revs->commits = newlist; } @@ -435,6 +476,26 @@ static void handle_all(struct rev_info *revs, unsigned flags) for_each_ref(handle_one_ref); } +void init_revisions(struct rev_info *revs) +{ + memset(revs, 0, sizeof(*revs)); + revs->diffopt.recursive = 1; + revs->diffopt.add_remove = file_add_remove; + revs->diffopt.change = file_change; + revs->lifo = 1; + revs->dense = 1; + revs->prefix = setup_git_directory(); + revs->max_age = -1; + revs->min_age = -1; + revs->max_count = -1; + + revs->prune_fn = NULL; + revs->prune_data = NULL; + + revs->topo_setter = topo_sort_default_setter; + revs->topo_getter = topo_sort_default_getter; +} + /* * Parse revision information, filling in the "rev_info" structure, * and removing the used arguments from the argument list. @@ -448,13 +509,7 @@ int setup_revisions(int argc, const char **argv, struct rev_info *revs, const ch const char **unrecognized = argv + 1; int left = 1; - memset(revs, 0, sizeof(*revs)); - revs->lifo = 1; - revs->dense = 1; - revs->prefix = setup_git_directory(); - revs->max_age = -1; - revs->min_age = -1; - revs->max_count = -1; + init_revisions(revs); /* First, search for "--" */ seen_dashdash = 0; @@ -464,7 +519,7 @@ int setup_revisions(int argc, const char **argv, struct rev_info *revs, const ch continue; argv[i] = NULL; argc = i; - revs->paths = get_pathspec(revs->prefix, argv + i + 1); + revs->prune_data = get_pathspec(revs->prefix, argv + i + 1); seen_dashdash = 1; break; } @@ -499,32 +554,26 @@ int setup_revisions(int argc, const char **argv, struct rev_info *revs, const ch } if (!strncmp(arg, "--max-age=", 10)) { revs->max_age = atoi(arg + 10); - revs->limited = 1; - continue; - } - if (!strncmp(arg, "--min-age=", 10)) { - revs->min_age = atoi(arg + 10); - revs->limited = 1; continue; } if (!strncmp(arg, "--since=", 8)) { revs->max_age = approxidate(arg + 8); - revs->limited = 1; continue; } if (!strncmp(arg, "--after=", 8)) { revs->max_age = approxidate(arg + 8); - revs->limited = 1; + continue; + } + if (!strncmp(arg, "--min-age=", 10)) { + revs->min_age = atoi(arg + 10); continue; } if (!strncmp(arg, "--before=", 9)) { revs->min_age = approxidate(arg + 9); - revs->limited = 1; continue; } if (!strncmp(arg, "--until=", 8)) { revs->min_age = approxidate(arg + 8); - revs->limited = 1; continue; } if (!strcmp(arg, "--all")) { @@ -543,13 +592,15 @@ int setup_revisions(int argc, const char **argv, struct rev_info *revs, const ch } if (!strcmp(arg, "--topo-order")) { revs->topo_order = 1; - revs->limited = 1; continue; } if (!strcmp(arg, "--date-order")) { revs->lifo = 0; revs->topo_order = 1; - revs->limited = 1; + continue; + } + if (!strcmp(arg, "--parents")) { + revs->parents = 1; continue; } if (!strcmp(arg, "--dense")) { @@ -564,10 +615,14 @@ int setup_revisions(int argc, const char **argv, struct rev_info *revs, const ch revs->remove_empty_trees = 1; continue; } - if (!strncmp(arg, "--no-merges", 11)) { + if (!strcmp(arg, "--no-merges")) { revs->no_merges = 1; continue; } + if (!strcmp(arg, "--boundary")) { + revs->boundary = 1; + continue; + } if (!strcmp(arg, "--objects")) { revs->tag_objects = 1; revs->tree_objects = 1; @@ -583,7 +638,6 @@ int setup_revisions(int argc, const char **argv, struct rev_info *revs, const ch } if (!strcmp(arg, "--unpacked")) { revs->unpacked = 1; - revs->limited = 1; continue; } *unrecognized++ = arg; @@ -593,15 +647,19 @@ int setup_revisions(int argc, const char **argv, struct rev_info *revs, const ch dotdot = strstr(arg, ".."); if (dotdot) { unsigned char from_sha1[20]; - char *next = dotdot + 2; + const char *next = dotdot + 2; + const char *this = arg; *dotdot = 0; if (!*next) next = "HEAD"; - if (!get_sha1(arg, from_sha1) && !get_sha1(next, sha1)) { + if (dotdot == arg) + this = "HEAD"; + if (!get_sha1(this, from_sha1) && + !get_sha1(next, sha1)) { struct commit *exclude; struct commit *include; - exclude = get_commit_reference(revs, arg, from_sha1, flags ^ UNINTERESTING); + exclude = get_commit_reference(revs, this, from_sha1, flags ^ UNINTERESTING); include = get_commit_reference(revs, next, sha1, flags); if (!exclude || !include) die("Invalid revision range %s..%s", arg, next); @@ -626,9 +684,9 @@ int setup_revisions(int argc, const char **argv, struct rev_info *revs, const ch /* If we didn't have a "--", all filenames must exist */ for (j = i; j < argc; j++) { if (lstat(argv[j], &st) < 0) - die("'%s': %s", arg, strerror(errno)); + die("'%s': %s", argv[j], strerror(errno)); } - revs->paths = get_pathspec(revs->prefix, argv + i); + revs->prune_data = get_pathspec(revs->prefix, argv + i); break; } commit = get_commit_reference(revs, arg, sha1, flags ^ local_flags); @@ -642,8 +700,15 @@ int setup_revisions(int argc, const char **argv, struct rev_info *revs, const ch commit = get_commit_reference(revs, def, sha1, 0); add_one_commit(commit, revs); } - if (revs->paths) + + if (revs->topo_order || revs->unpacked) revs->limited = 1; + + if (revs->prune_data) { + diff_tree_setup_paths(revs->prune_data, &revs->diffopt); + revs->prune_fn = try_to_simplify_commit; + } + return left; } @@ -653,13 +718,17 @@ void prepare_revision_walk(struct rev_info *revs) if (revs->limited) limit_list(revs); if (revs->topo_order) - sort_in_topological_order(&revs->commits, revs->lifo); + sort_in_topological_order_fn(&revs->commits, revs->lifo, + revs->topo_setter, + revs->topo_getter); } -static int rewrite_one(struct commit **pp) +static int rewrite_one(struct rev_info *revs, struct commit **pp) { for (;;) { struct commit *p = *pp; + if (!revs->limited) + add_parents_to_list(revs, p, &revs->commits); if (p->object.flags & (TREECHANGE | UNINTERESTING)) return 0; if (!p->parents) @@ -668,12 +737,12 @@ static int rewrite_one(struct commit **pp) } } -static void rewrite_parents(struct commit *commit) +static void rewrite_parents(struct rev_info *revs, struct commit *commit) { struct commit_list **pp = &commit->parents; while (*pp) { struct commit_list *parent = *pp; - if (rewrite_one(&parent->item) < 0) { + if (rewrite_one(revs, &parent->item) < 0) { *pp = parent->next; continue; } @@ -701,26 +770,39 @@ struct commit *get_revision(struct rev_info *revs) do { struct commit *commit = revs->commits->item; - if (commit->object.flags & (UNINTERESTING|SHOWN)) - goto next; + revs->commits = revs->commits->next; + + /* + * If we haven't done the list limiting, we need to look at + * the parents here. We also need to do the date-based limiting + * that we'd otherwise have done in limit_list(). + */ + if (!revs->limited) { + if ((revs->unpacked && + has_sha1_pack(commit->object.sha1)) || + (revs->max_age != -1 && + (commit->date < revs->max_age))) + continue; + add_parents_to_list(revs, commit, &revs->commits); + } + if (commit->object.flags & SHOWN) + continue; + if (!(commit->object.flags & BOUNDARY) && + (commit->object.flags & UNINTERESTING)) + continue; if (revs->min_age != -1 && (commit->date > revs->min_age)) - goto next; - if (revs->max_age != -1 && (commit->date < revs->max_age)) - return NULL; - if (revs->no_merges && commit->parents && commit->parents->next) - goto next; - if (revs->paths && revs->dense) { + continue; + if (revs->no_merges && + commit->parents && commit->parents->next) + continue; + if (revs->prune_fn && revs->dense) { if (!(commit->object.flags & TREECHANGE)) - goto next; - rewrite_parents(commit); + continue; + if (revs->parents) + rewrite_parents(revs, commit); } - /* More to go? */ - if (revs->max_count) - pop_most_recent_commit(&revs->commits, SEEN); commit->object.flags |= SHOWN; return commit; -next: - pop_most_recent_commit(&revs->commits, SEEN); } while (revs->commits); return NULL; }