Make path-limiting be incremental when possible.

[git.git] / revision.c

diff --git a/revision.c b/revision.c
index 38a8d1b..a8a54b6 100644 (file)
--- a/revision.c
+++ b/revision.c
@@ -313,12 +313,16 @@ static void try_to_simplify_commit(struct rev_info *revs, struct commit *commit)
                case REV_TREE_NEW:
                        if (revs->remove_empty_trees &&
                            rev_same_tree_as_empty(p->tree)) {
-                               /* We are adding all the specified paths from
-                                * this parent, so the parents of it is
-                                * not interesting, but the difference between
-                                * this parent and us still is interesting.
+                               /* 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.
                                 */
-                               p->object.flags |= UNINTERESTING;
+                               parse_commit(p);
+                               p->parents = NULL;
                        }
                /* fallthrough */
                case REV_TREE_DIFFERENT:
@@ -415,6 +419,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;
 }
 
@@ -571,6 +605,10 @@ int setup_revisions(int argc, const char **argv, struct rev_info *revs, const ch
                                revs->limited = 1;
                                continue;
                        }
+                       if (!strcmp(arg, "--parents")) {
+                               revs->parents = 1;
+                               continue;
+                       }
                        if (!strcmp(arg, "--dense")) {
                                revs->dense = 1;
                                continue;
@@ -583,10 +621,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;
@@ -612,15 +654,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);
@@ -645,7 +691,7 @@ 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->prune_data = get_pathspec(revs->prefix, argv + i);
                        break;
@@ -665,7 +711,13 @@ int setup_revisions(int argc, const char **argv, struct rev_info *revs, const ch
        if (revs->prune_data) {
                diff_tree_setup_paths(revs->prune_data);
                revs->prune_fn = try_to_simplify_commit;
-               revs->limited = 1;
+
+               /*
+                * If we fix up parent data, we currently cannot
+                * do that on-the-fly.
+                */
+               if (revs->parents)
+                       revs->limited = 1;
        }
 
        return left;
@@ -727,26 +779,34 @@ 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
+                */
+               if (!revs->limited)
+                       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;
+                       continue;
                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->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(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;
 }