X-Git-Url: https://git.octo.it/?a=blobdiff_plain;f=rev-list.c;h=fdb531caf6db4944f0612258697670eb00bc55ce;hb=49ce3d0c4e732bbabb7a2bda1d89d80eeb76d5b6;hp=897a0e7ad84b8e42e498770717d9ca05cca19e63;hpb=51b1e1713b1ed8e962e994cd0850ea439ad8c3de;p=git.git diff --git a/rev-list.c b/rev-list.c index 897a0e7a..fdb531ca 100644 --- a/rev-list.c +++ b/rev-list.c @@ -1,22 +1,32 @@ #include "cache.h" +#include "tag.h" #include "commit.h" +#include "tree.h" +#include "blob.h" #include "epoch.h" #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 \n" " --max-count=nr\n" " --max-age=epoch\n" " --min-age=epoch\n" + " --bisect\n" + " --objects\n" + " --unpacked\n" " --header\n" " --pretty\n" " --merge-order [ --show-breaks ]"; +static int unpacked = 0; static int bisect_list = 0; +static int tag_objects = 0; +static int tree_objects = 0; +static int blob_objects = 0; static int verbose_header = 0; static int show_parents = 0; static int hdr_termination = 0; @@ -27,6 +37,8 @@ static int max_count = -1; static enum cmit_fmt commit_format = CMIT_FMT_RAW; static int merge_order = 0; static int show_breaks = 0; +static int stop_traversal = 0; +static int topo_order = 0; static void show_commit(struct commit *commit) { @@ -52,17 +64,22 @@ static void show_commit(struct commit *commit) 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 (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)) - return STOP; + if (max_age != -1 && (commit->date < max_age)) { + stop_traversal=1; + return merge_order?CONTINUE:STOP; + } if (max_count != -1 && !max_count--) return STOP; return DO; @@ -85,23 +102,141 @@ static int process_commit(struct commit * commit) return CONTINUE; } +static struct object_list **add_object(struct object *obj, struct object_list **p, const char *name) +{ + struct object_list *entry = xmalloc(sizeof(*entry)); + entry->item = obj; + entry->next = *p; + entry->name = name; + *p = entry; + return &entry->next; +} + +static struct object_list **process_blob(struct blob *blob, struct object_list **p, const char *name) +{ + struct object *obj = &blob->object; + + if (!blob_objects) + return p; + if (obj->flags & (UNINTERESTING | SEEN)) + return p; + obj->flags |= SEEN; + return add_object(obj, p, name); +} + +static struct object_list **process_tree(struct tree *tree, struct object_list **p, const char *name) +{ + struct object *obj = &tree->object; + struct tree_entry_list *entry; + + if (!tree_objects) + return p; + if (obj->flags & (UNINTERESTING | SEEN)) + return p; + if (parse_tree(tree) < 0) + die("bad tree object %s", sha1_to_hex(obj->sha1)); + obj->flags |= SEEN; + p = add_object(obj, p, name); + for (entry = tree->entries ; entry ; entry = entry->next) { + if (entry->directory) + p = process_tree(entry->item.tree, p, entry->name); + else + p = process_blob(entry->item.blob, p, entry->name); + } + return p; +} + +static struct object_list *pending_objects = NULL; + static void show_commit_list(struct commit_list *list) { + struct object_list *objects = NULL, **p = &objects, *pending; while (list) { struct commit *commit = pop_most_recent_commit(&list, SEEN); + p = process_tree(commit->tree, p, ""); if (process_commit(commit) == STOP) break; } + for (pending = pending_objects; pending; pending = pending->next) { + struct object *obj = pending->item; + const char *name = pending->name; + if (obj->flags & (UNINTERESTING | SEEN)) + continue; + if (obj->type == tag_type) { + obj->flags |= SEEN; + p = add_object(obj, p, name); + continue; + } + if (obj->type == tree_type) { + p = process_tree((struct tree *)obj, p, name); + continue; + } + if (obj->type == blob_type) { + p = process_blob((struct blob *)obj, p, name); + continue; + } + die("unknown pending object %s (%s)", sha1_to_hex(obj->sha1), name); + } + while (objects) { + printf("%s %s\n", sha1_to_hex(objects->item->sha1), objects->name); + objects = objects->next; + } +} + +static void mark_blob_uninteresting(struct blob *blob) +{ + if (!blob_objects) + return; + if (blob->object.flags & UNINTERESTING) + return; + blob->object.flags |= UNINTERESTING; +} + +static void mark_tree_uninteresting(struct tree *tree) +{ + struct object *obj = &tree->object; + struct tree_entry_list *entry; + + if (!tree_objects) + return; + 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 (entry) { + if (entry->directory) + mark_tree_uninteresting(entry->item.tree); + else + mark_blob_uninteresting(entry->item.blob); + entry = entry->next; + } } static void mark_parents_uninteresting(struct commit *commit) { struct commit_list *parents = commit->parents; + if (tree_objects) + mark_tree_uninteresting(commit->tree); while (parents) { struct commit *commit = parents->item; commit->object.flags |= UNINTERESTING; + + /* + * 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; } } @@ -190,14 +325,16 @@ static struct commit_list *find_bisection(struct commit_list *list) return best; } -struct commit_list *limit_list(struct commit_list *list) +static struct commit_list *limit_list(struct commit_list *list) { struct commit_list *newlist = NULL; struct commit_list **p = &newlist; - do { + while (list) { 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)) @@ -205,25 +342,85 @@ struct commit_list *limit_list(struct commit_list *list) continue; } p = &commit_list_insert(commit, p)->next; - } while (list); + } if (bisect_list) newlist = find_bisection(newlist); return newlist; } -static enum cmit_fmt get_commit_format(const char *arg) +static void add_pending_object(struct object *obj, const char *name) { - if (!*arg) - return CMIT_FMT_DEFAULT; - if (!strcmp(arg, "=raw")) - return CMIT_FMT_RAW; - if (!strcmp(arg, "=medium")) - return CMIT_FMT_MEDIUM; - if (!strcmp(arg, "=short")) - return CMIT_FMT_SHORT; - usage(rev_list_usage); -} + add_object(obj, &pending_objects, name); +} + +static struct commit *get_commit_reference(const char *name, unsigned int flags) +{ + unsigned char sha1[20]; + struct object *object; + + if (get_sha1(name, sha1)) + usage(rev_list_usage); + object = parse_object(sha1); + if (!object) + die("bad object %s", name); + + /* + * Tag object? Look what it points to.. + */ + 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 = parse_object(tag->tagged->sha1); + } + + /* + * Commit object? Just return it, we'll do all the complex + * reachability crud. + */ + if (object->type == commit_type) { + struct commit *commit = (struct commit *)object; + object->flags |= flags; + if (parse_commit(commit) < 0) + die("unable to parse commit %s", name); + if (flags & UNINTERESTING) + mark_parents_uninteresting(commit); + return commit; + } + + /* + * Tree object? Either mark it uniniteresting, or add it + * to the list of objects to look at later.. + */ + if (object->type == tree_type) { + struct tree *tree = (struct tree *)object; + if (!tree_objects) + return NULL; + if (flags & UNINTERESTING) { + mark_tree_uninteresting(tree); + return NULL; + } + add_pending_object(object, ""); + return NULL; + } + /* + * Blob object? You know the drill by now.. + */ + if (object->type == blob_type) { + struct blob *blob = (struct blob *)object; + if (!blob_objects) + return NULL; + if (flags & UNINTERESTING) { + mark_blob_uninteresting(blob); + return NULL; + } + add_pending_object(object, ""); + return NULL; + } + die("%s is unknown object", name); +} int main(int argc, char **argv) { @@ -233,7 +430,6 @@ int main(int argc, char **argv) for (i = 1 ; i < argc; i++) { int flags; char *arg = argv[i]; - unsigned char sha1[20]; struct commit *commit; if (!strncmp(arg, "--max-count=", 12)) { @@ -267,14 +463,30 @@ int main(int argc, char **argv) bisect_list = 1; continue; } - if (!strncmp(arg, "--merge-order", 13)) { + if (!strcmp(arg, "--objects")) { + tag_objects = 1; + tree_objects = 1; + blob_objects = 1; + continue; + } + 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; + } flags = 0; if (*arg == '^') { @@ -282,21 +494,23 @@ int main(int argc, char **argv) arg++; limited = 1; } - if (get_sha1(arg, sha1) || (show_breaks && !merge_order)) + if (show_breaks && !merge_order) usage(rev_list_usage); - commit = lookup_commit_reference(sha1); - if (!commit || parse_commit(commit) < 0) - die("bad commit object %s", arg); - commit->object.flags |= flags; + commit = get_commit_reference(arg, flags); + if (!commit) + continue; + if (commit->object.flags & SEEN) + continue; + commit->object.flags |= SEEN; commit_list_insert(commit, &list); } - if (!list) - usage(rev_list_usage); - 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 { if (sort_list_in_merge_order(list, &process_commit)) {