#define SEEN (1u << 0)
#define INTERESTING (1u << 1)
#define COUNTED (1u << 2)
-#define SHOWN (LAST_EPOCH_FLAG << 2)
+#define SHOWN (1u << 3)
static const char rev_list_usage[] =
- "usage: git-rev-list [OPTION] commit-id <commit-id>\n"
+ "git-rev-list [OPTION] commit-id <commit-id>\n"
" --max-count=nr\n"
" --max-age=epoch\n"
" --min-age=epoch\n"
+ " --parents\n"
+ " --bisect\n"
+ " --objects\n"
+ " --unpacked\n"
" --header\n"
" --pretty\n"
- " --merge-order [ --show-breaks ]";
+ " --no-merges\n"
+ " --merge-order [ --show-breaks ]\n"
+ " --topo-order";
+static int unpacked = 0;
static int bisect_list = 0;
static int tag_objects = 0;
static int tree_objects = 0;
static int merge_order = 0;
static int show_breaks = 0;
static int stop_traversal = 0;
+static int topo_order = 0;
+static int no_merges = 0;
static void show_commit(struct commit *commit)
{
parents = parents->next;
}
}
- putchar('\n');
+ if (commit_format == CMIT_FMT_ONELINE)
+ putchar(' ');
+ else
+ putchar('\n');
+
if (verbose_header) {
static char pretty_header[16384];
pretty_print_commit(commit_format, commit->buffer, ~0, pretty_header, sizeof(pretty_header));
printf("%s%c", pretty_header, hdr_termination);
- }
+ }
+ fflush(stdout);
}
static int filter_commit(struct commit * commit)
{
- if (merge_order && stop_traversal && commit->object.flags & BOUNDARY)
+ if (stop_traversal && (commit->object.flags & BOUNDARY))
return STOP;
if (commit->object.flags & (UNINTERESTING|SHOWN))
return CONTINUE;
if (min_age != -1 && (commit->date > min_age))
return CONTINUE;
if (max_age != -1 && (commit->date < max_age)) {
- if (!merge_order)
- return STOP;
- else {
- stop_traversal = 1;
- return CONTINUE;
- }
+ stop_traversal=1;
+ return merge_order?CONTINUE:STOP;
}
if (max_count != -1 && !max_count--)
return STOP;
+ if (no_merges && (commit->parents && commit->parents->next))
+ return CONTINUE;
return DO;
}
if (obj->flags & UNINTERESTING)
return;
obj->flags |= UNINTERESTING;
+ if (!has_sha1_file(obj->sha1))
+ return;
if (parse_tree(tree) < 0)
die("bad tree %s", sha1_to_hex(obj->sha1));
entry = tree->entries;
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);
+
+ /*
+ * A missing commit is ok iff its parent is marked
+ * uninteresting.
+ *
+ * We just mark such a thing parsed, so that when
+ * it is popped next time around, we won't be trying
+ * to parse it and get an error.
+ */
+ if (!has_sha1_file(commit->object.sha1))
+ commit->object.parsed = 1;
parents = parents->next;
}
}
-static int everybody_uninteresting(struct commit_list *list)
+static int everybody_uninteresting(struct commit_list *orig)
{
+ struct commit_list *list = orig;
while (list) {
struct commit *commit = list->item;
list = list->next;
continue;
return 0;
}
+
+ /*
+ * Ok, go back and mark all the edge trees uninteresting,
+ * since otherwise we can have situations where a parent
+ * that was marked uninteresting (and we never even had
+ * to look at) had lots of objects that we don't want to
+ * include.
+ *
+ * NOTE! This still doesn't mean that the object list is
+ * "correct", since we may end up listing objects that
+ * even older commits (that we don't list) do actually
+ * reference, but it gets us to a minimal list (or very
+ * close) in practice.
+ */
+ if (!tree_objects)
+ return 1;
+
+ while (orig) {
+ struct commit *commit = orig->item;
+ if (!parse_commit(commit) && commit->tree)
+ mark_tree_uninteresting(commit->tree);
+ orig = orig->next;
+ }
return 1;
}
struct commit *commit = pop_most_recent_commit(&list, SEEN);
struct object *obj = &commit->object;
+ if (unpacked && has_sha1_pack(obj->sha1))
+ obj->flags |= UNINTERESTING;
if (obj->flags & UNINTERESTING) {
mark_parents_uninteresting(commit);
if (everybody_uninteresting(list))
/*
* Tag object? Look what it points to..
*/
- if (object->type == tag_type) {
+ while (object->type == tag_type) {
struct tag *tag = (struct tag *) object;
object->flags |= flags;
if (tag_objects && !(object->flags & UNINTERESTING))
add_pending_object(object, tag->tag);
- object = tag->tagged;
+ object = parse_object(tag->tagged->sha1);
+ if (!object)
+ die("bad object %s", sha1_to_hex(tag->tagged->sha1));
}
/*
object->flags |= flags;
if (parse_commit(commit) < 0)
die("unable to parse commit %s", name);
+ if (flags & UNINTERESTING)
+ mark_parents_uninteresting(commit);
return commit;
}
if (object->type == tree_type) {
struct tree *tree = (struct tree *)object;
if (!tree_objects)
- die("%s is a tree object, not a commit", name);
+ return NULL;
if (flags & UNINTERESTING) {
mark_tree_uninteresting(tree);
return NULL;
if (object->type == blob_type) {
struct blob *blob = (struct blob *)object;
if (!blob_objects)
- die("%s is a blob object, not a commit", name);
+ return NULL;
if (flags & UNINTERESTING) {
mark_blob_uninteresting(blob);
return NULL;
die("%s is unknown object", name);
}
+static void handle_one_commit(struct commit *com, struct commit_list **lst)
+{
+ if (!com || com->object.flags & SEEN)
+ return;
+ com->object.flags |= SEEN;
+ commit_list_insert(com, lst);
+}
+
+
int main(int argc, char **argv)
{
struct commit_list *list = NULL;
+ const char *prefix = setup_git_directory();
int i, limited = 0;
for (i = 1 ; i < argc; i++) {
int flags;
char *arg = argv[i];
+ char *dotdot;
struct commit *commit;
if (!strncmp(arg, "--max-count=", 12)) {
commit_format = get_commit_format(arg+8);
verbose_header = 1;
hdr_termination = '\n';
- prefix = "commit ";
+ if (commit_format == CMIT_FMT_ONELINE)
+ prefix = "";
+ else
+ prefix = "commit ";
+ continue;
+ }
+ if (!strncmp(arg, "--no-merges", 11)) {
+ no_merges = 1;
continue;
}
if (!strcmp(arg, "--parents")) {
blob_objects = 1;
continue;
}
- if (!strncmp(arg, "--merge-order", 13)) {
+ if (!strcmp(arg, "--unpacked")) {
+ unpacked = 1;
+ limited = 1;
+ continue;
+ }
+ if (!strcmp(arg, "--merge-order")) {
merge_order = 1;
continue;
}
- if (!strncmp(arg, "--show-breaks", 13)) {
+ if (!strcmp(arg, "--show-breaks")) {
show_breaks = 1;
continue;
}
+ if (!strcmp(arg, "--topo-order")) {
+ topo_order = 1;
+ limited = 1;
+ continue;
+ }
+
+ if (show_breaks && !merge_order)
+ usage(rev_list_usage);
flags = 0;
+ dotdot = strstr(arg, "..");
+ if (dotdot) {
+ char *next = dotdot + 2;
+ struct commit *exclude = NULL;
+ struct commit *include = NULL;
+ *dotdot = 0;
+ exclude = get_commit_reference(arg, UNINTERESTING);
+ include = get_commit_reference(next, 0);
+ if (exclude && include) {
+ limited = 1;
+ handle_one_commit(exclude, &list);
+ handle_one_commit(include, &list);
+ continue;
+ }
+ *next = '.';
+ }
if (*arg == '^') {
flags = UNINTERESTING;
arg++;
limited = 1;
}
- if (show_breaks && !merge_order)
- usage(rev_list_usage);
commit = get_commit_reference(arg, flags);
- if (!commit)
- continue;
- commit_list_insert(commit, &list);
+ handle_one_commit(commit, &list);
}
if (!merge_order) {
+ sort_by_date(&list);
if (limited)
list = limit_list(list);
+ if (topo_order)
+ sort_in_topological_order(&list);
show_commit_list(list);
} else {
+#ifndef NO_OPENSSL
if (sort_list_in_merge_order(list, &process_commit)) {
- die("merge order sort failed\n");
+ die("merge order sort failed\n");
}
+#else
+ die("merge order sort unsupported, OpenSSL not linked");
+#endif
}
return 0;