2005-04-24 02:04:40 +00:00
|
|
|
#include "cache.h"
|
2005-06-29 18:30:24 +00:00
|
|
|
#include "tag.h"
|
2005-04-24 02:04:40 +00:00
|
|
|
#include "commit.h"
|
2005-06-25 05:56:58 +00:00
|
|
|
#include "tree.h"
|
|
|
|
#include "blob.h"
|
2005-06-06 15:39:40 +00:00
|
|
|
#include "epoch.h"
|
2005-04-24 02:04:40 +00:00
|
|
|
|
2005-05-31 01:46:32 +00:00
|
|
|
#define SEEN (1u << 0)
|
|
|
|
#define INTERESTING (1u << 1)
|
2005-06-18 05:54:50 +00:00
|
|
|
#define COUNTED (1u << 2)
|
2005-07-06 16:56:16 +00:00
|
|
|
#define SHOWN (1u << 3)
|
2005-05-31 01:46:32 +00:00
|
|
|
|
2005-05-26 01:29:09 +00:00
|
|
|
static const char rev_list_usage[] =
|
2005-07-27 07:04:16 +00:00
|
|
|
"git-rev-list [OPTION] commit-id <commit-id>\n"
|
2005-05-26 01:29:09 +00:00
|
|
|
" --max-count=nr\n"
|
|
|
|
" --max-age=epoch\n"
|
|
|
|
" --min-age=epoch\n"
|
2005-08-08 09:37:21 +00:00
|
|
|
" --parents\n"
|
2005-07-03 20:29:54 +00:00
|
|
|
" --bisect\n"
|
|
|
|
" --objects\n"
|
|
|
|
" --unpacked\n"
|
2005-06-01 15:42:22 +00:00
|
|
|
" --header\n"
|
2005-06-06 15:39:40 +00:00
|
|
|
" --pretty\n"
|
2005-08-08 09:37:21 +00:00
|
|
|
" --no-merges\n"
|
|
|
|
" --merge-order [ --show-breaks ]\n"
|
|
|
|
" --topo-order";
|
2005-05-26 01:29:09 +00:00
|
|
|
|
2005-07-03 20:29:54 +00:00
|
|
|
static int unpacked = 0;
|
2005-06-18 05:54:50 +00:00
|
|
|
static int bisect_list = 0;
|
2005-06-29 17:40:14 +00:00
|
|
|
static int tag_objects = 0;
|
2005-06-25 05:56:58 +00:00
|
|
|
static int tree_objects = 0;
|
|
|
|
static int blob_objects = 0;
|
2005-06-02 16:19:53 +00:00
|
|
|
static int verbose_header = 0;
|
|
|
|
static int show_parents = 0;
|
|
|
|
static int hdr_termination = 0;
|
|
|
|
static const char *prefix = "";
|
|
|
|
static unsigned long max_age = -1;
|
|
|
|
static unsigned long min_age = -1;
|
|
|
|
static int max_count = -1;
|
2005-06-05 16:02:03 +00:00
|
|
|
static enum cmit_fmt commit_format = CMIT_FMT_RAW;
|
2005-06-06 15:39:40 +00:00
|
|
|
static int merge_order = 0;
|
|
|
|
static int show_breaks = 0;
|
2005-06-20 02:29:41 +00:00
|
|
|
static int stop_traversal = 0;
|
2005-07-06 17:25:04 +00:00
|
|
|
static int topo_order = 0;
|
2005-08-08 09:37:21 +00:00
|
|
|
static int no_merges = 0;
|
2005-06-02 16:19:53 +00:00
|
|
|
|
|
|
|
static void show_commit(struct commit *commit)
|
|
|
|
{
|
2005-06-20 02:29:38 +00:00
|
|
|
commit->object.flags |= SHOWN;
|
2005-06-06 15:39:40 +00:00
|
|
|
if (show_breaks) {
|
|
|
|
prefix = "| ";
|
|
|
|
if (commit->object.flags & DISCONTINUITY) {
|
|
|
|
prefix = "^ ";
|
|
|
|
} else if (commit->object.flags & BOUNDARY) {
|
|
|
|
prefix = "= ";
|
|
|
|
}
|
|
|
|
}
|
2005-06-02 16:19:53 +00:00
|
|
|
printf("%s%s", prefix, sha1_to_hex(commit->object.sha1));
|
|
|
|
if (show_parents) {
|
|
|
|
struct commit_list *parents = commit->parents;
|
|
|
|
while (parents) {
|
|
|
|
printf(" %s", sha1_to_hex(parents->item->object.sha1));
|
|
|
|
parents = parents->next;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
putchar('\n');
|
|
|
|
if (verbose_header) {
|
2005-06-05 16:02:03 +00:00
|
|
|
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);
|
2005-07-04 23:36:48 +00:00
|
|
|
}
|
|
|
|
fflush(stdout);
|
2005-06-06 15:39:40 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int filter_commit(struct commit * commit)
|
|
|
|
{
|
2005-07-06 16:39:34 +00:00
|
|
|
if (stop_traversal && (commit->object.flags & BOUNDARY))
|
2005-06-20 02:29:41 +00:00
|
|
|
return STOP;
|
2005-06-20 02:29:38 +00:00
|
|
|
if (commit->object.flags & (UNINTERESTING|SHOWN))
|
2005-06-06 15:39:40 +00:00
|
|
|
return CONTINUE;
|
|
|
|
if (min_age != -1 && (commit->date > min_age))
|
|
|
|
return CONTINUE;
|
2005-06-20 02:29:41 +00:00
|
|
|
if (max_age != -1 && (commit->date < max_age)) {
|
2005-07-06 16:39:34 +00:00
|
|
|
stop_traversal=1;
|
|
|
|
return merge_order?CONTINUE:STOP;
|
2005-06-20 02:29:41 +00:00
|
|
|
}
|
2005-06-06 15:39:40 +00:00
|
|
|
if (max_count != -1 && !max_count--)
|
|
|
|
return STOP;
|
2005-08-08 09:37:21 +00:00
|
|
|
if (no_merges && (commit->parents && commit->parents->next))
|
|
|
|
return CONTINUE;
|
2005-06-06 15:39:40 +00:00
|
|
|
return DO;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int process_commit(struct commit * commit)
|
|
|
|
{
|
|
|
|
int action=filter_commit(commit);
|
|
|
|
|
|
|
|
if (action == STOP) {
|
|
|
|
return STOP;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (action == CONTINUE) {
|
|
|
|
return CONTINUE;
|
2005-06-02 16:19:53 +00:00
|
|
|
}
|
2005-06-06 15:39:40 +00:00
|
|
|
|
|
|
|
show_commit(commit);
|
|
|
|
|
|
|
|
return CONTINUE;
|
2005-06-02 16:19:53 +00:00
|
|
|
}
|
|
|
|
|
2005-06-26 22:26:05 +00:00
|
|
|
static struct object_list **add_object(struct object *obj, struct object_list **p, const char *name)
|
2005-06-25 05:56:58 +00:00
|
|
|
{
|
|
|
|
struct object_list *entry = xmalloc(sizeof(*entry));
|
|
|
|
entry->item = obj;
|
2005-06-29 18:30:24 +00:00
|
|
|
entry->next = *p;
|
2005-06-26 22:26:05 +00:00
|
|
|
entry->name = name;
|
2005-06-25 05:56:58 +00:00
|
|
|
*p = entry;
|
|
|
|
return &entry->next;
|
|
|
|
}
|
|
|
|
|
2005-06-26 22:26:05 +00:00
|
|
|
static struct object_list **process_blob(struct blob *blob, struct object_list **p, const char *name)
|
2005-06-25 05:56:58 +00:00
|
|
|
{
|
|
|
|
struct object *obj = &blob->object;
|
|
|
|
|
|
|
|
if (!blob_objects)
|
|
|
|
return p;
|
|
|
|
if (obj->flags & (UNINTERESTING | SEEN))
|
|
|
|
return p;
|
|
|
|
obj->flags |= SEEN;
|
2005-06-26 22:26:05 +00:00
|
|
|
return add_object(obj, p, name);
|
2005-06-25 05:56:58 +00:00
|
|
|
}
|
|
|
|
|
2005-06-26 22:26:05 +00:00
|
|
|
static struct object_list **process_tree(struct tree *tree, struct object_list **p, const char *name)
|
2005-06-25 05:56:58 +00:00
|
|
|
{
|
|
|
|
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;
|
2005-06-26 22:26:05 +00:00
|
|
|
p = add_object(obj, p, name);
|
2005-06-25 05:56:58 +00:00
|
|
|
for (entry = tree->entries ; entry ; entry = entry->next) {
|
|
|
|
if (entry->directory)
|
2005-06-26 22:26:05 +00:00
|
|
|
p = process_tree(entry->item.tree, p, entry->name);
|
2005-06-25 05:56:58 +00:00
|
|
|
else
|
2005-06-26 22:26:05 +00:00
|
|
|
p = process_blob(entry->item.blob, p, entry->name);
|
2005-06-25 05:56:58 +00:00
|
|
|
}
|
|
|
|
return p;
|
|
|
|
}
|
|
|
|
|
2005-06-29 18:30:24 +00:00
|
|
|
static struct object_list *pending_objects = NULL;
|
|
|
|
|
2005-06-02 16:19:53 +00:00
|
|
|
static void show_commit_list(struct commit_list *list)
|
|
|
|
{
|
2005-06-29 18:30:24 +00:00
|
|
|
struct object_list *objects = NULL, **p = &objects, *pending;
|
2005-06-02 16:19:53 +00:00
|
|
|
while (list) {
|
|
|
|
struct commit *commit = pop_most_recent_commit(&list, SEEN);
|
|
|
|
|
2005-06-26 22:26:05 +00:00
|
|
|
p = process_tree(commit->tree, p, "");
|
2005-06-06 15:39:40 +00:00
|
|
|
if (process_commit(commit) == STOP)
|
2005-06-02 16:19:53 +00:00
|
|
|
break;
|
|
|
|
}
|
2005-06-29 18:30:24 +00:00
|
|
|
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);
|
|
|
|
}
|
2005-06-25 05:56:58 +00:00
|
|
|
while (objects) {
|
2005-06-26 22:26:05 +00:00
|
|
|
printf("%s %s\n", sha1_to_hex(objects->item->sha1), objects->name);
|
2005-06-25 05:56:58 +00:00
|
|
|
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;
|
2005-07-10 22:09:46 +00:00
|
|
|
if (!has_sha1_file(obj->sha1))
|
|
|
|
return;
|
2005-06-25 05:56:58 +00:00
|
|
|
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;
|
|
|
|
}
|
2005-06-02 16:19:53 +00:00
|
|
|
}
|
|
|
|
|
2005-05-31 01:46:32 +00:00
|
|
|
static void mark_parents_uninteresting(struct commit *commit)
|
|
|
|
{
|
|
|
|
struct commit_list *parents = commit->parents;
|
|
|
|
|
2005-06-25 05:56:58 +00:00
|
|
|
if (tree_objects)
|
|
|
|
mark_tree_uninteresting(commit->tree);
|
2005-05-31 01:46:32 +00:00
|
|
|
while (parents) {
|
|
|
|
struct commit *commit = parents->item;
|
|
|
|
commit->object.flags |= UNINTERESTING;
|
2005-07-10 22:09:46 +00:00
|
|
|
|
[PATCH] Fix interesting git-rev-list corner case
This corner-case was triggered by a kernel commit that was not in date
order, due to a misconfigured time zone that made the commit appear three
hours older than it was.
That caused git-rev-list to traverse the commit tree in a non-obvious
order, and made it parse several of the _parents_ of the misplaced commit
before it actually parsed the commit itself. That's fine, but it meant
that the grandparents of the commit didn't get marked uninteresting,
because they had been reached through an "interesting" branch.
The reason was that "mark_parents_uninteresting()" (which is supposed to
mark all existing parents as being uninteresting - duh) didn't actually
traverse more than one level down the parent chain.
NORMALLY this is fine, since with the date-based traversal order,
grandparents won't ever even have been looked at before their parents (so
traversing the chain down isn't needed, because the next time around when
we pick out the parent we'll mark _its_ parents uninteresting), but since
we'd gotten out of order, we'd already seen the parent and thus never got
around to mark the grandparents.
Anyway, the fix is simple. Just traverse parent chains recursively.
Normally the chain won't even exist (since the parent hasn't been parsed
yet), so this is not actually going to trigger except in this strange
corner-case.
Add a comment to the simple one-liner, since this was a bit subtle, and I
had to really think things through to understand how it could happen.
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2005-07-29 22:50:30 +00:00
|
|
|
/*
|
|
|
|
* 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);
|
|
|
|
|
2005-07-10 22:09:46 +00:00
|
|
|
/*
|
|
|
|
* 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;
|
2005-05-31 01:46:32 +00:00
|
|
|
parents = parents->next;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-07-23 17:01:49 +00:00
|
|
|
static int everybody_uninteresting(struct commit_list *orig)
|
2005-05-31 01:46:32 +00:00
|
|
|
{
|
2005-07-23 17:01:49 +00:00
|
|
|
struct commit_list *list = orig;
|
2005-05-31 01:46:32 +00:00
|
|
|
while (list) {
|
|
|
|
struct commit *commit = list->item;
|
|
|
|
list = list->next;
|
|
|
|
if (commit->object.flags & UNINTERESTING)
|
|
|
|
continue;
|
|
|
|
return 0;
|
|
|
|
}
|
2005-07-23 17:01:49 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* 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;
|
|
|
|
}
|
2005-05-31 01:46:32 +00:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2005-06-18 05:54:50 +00:00
|
|
|
/*
|
|
|
|
* This is a truly stupid algorithm, but it's only
|
|
|
|
* used for bisection, and we just don't care enough.
|
|
|
|
*
|
|
|
|
* We care just barely enough to avoid recursing for
|
|
|
|
* non-merge entries.
|
|
|
|
*/
|
|
|
|
static int count_distance(struct commit_list *entry)
|
|
|
|
{
|
|
|
|
int nr = 0;
|
|
|
|
|
|
|
|
while (entry) {
|
|
|
|
struct commit *commit = entry->item;
|
|
|
|
struct commit_list *p;
|
|
|
|
|
|
|
|
if (commit->object.flags & (UNINTERESTING | COUNTED))
|
|
|
|
break;
|
|
|
|
nr++;
|
|
|
|
commit->object.flags |= COUNTED;
|
|
|
|
p = commit->parents;
|
|
|
|
entry = p;
|
|
|
|
if (p) {
|
|
|
|
p = p->next;
|
|
|
|
while (p) {
|
|
|
|
nr += count_distance(p);
|
|
|
|
p = p->next;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return nr;
|
|
|
|
}
|
|
|
|
|
2005-06-19 03:02:49 +00:00
|
|
|
static void clear_distance(struct commit_list *list)
|
2005-06-18 05:54:50 +00:00
|
|
|
{
|
|
|
|
while (list) {
|
|
|
|
struct commit *commit = list->item;
|
|
|
|
commit->object.flags &= ~COUNTED;
|
|
|
|
list = list->next;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct commit_list *find_bisection(struct commit_list *list)
|
|
|
|
{
|
|
|
|
int nr, closest;
|
|
|
|
struct commit_list *p, *best;
|
|
|
|
|
|
|
|
nr = 0;
|
|
|
|
p = list;
|
|
|
|
while (p) {
|
|
|
|
nr++;
|
|
|
|
p = p->next;
|
|
|
|
}
|
|
|
|
closest = 0;
|
|
|
|
best = list;
|
|
|
|
|
|
|
|
p = list;
|
|
|
|
while (p) {
|
|
|
|
int distance = count_distance(p);
|
|
|
|
clear_distance(list);
|
|
|
|
if (nr - distance < distance)
|
|
|
|
distance = nr - distance;
|
|
|
|
if (distance > closest) {
|
|
|
|
best = p;
|
|
|
|
closest = distance;
|
|
|
|
}
|
|
|
|
p = p->next;
|
|
|
|
}
|
|
|
|
if (best)
|
|
|
|
best->next = NULL;
|
|
|
|
return best;
|
|
|
|
}
|
|
|
|
|
2005-07-03 17:10:45 +00:00
|
|
|
static struct commit_list *limit_list(struct commit_list *list)
|
2005-06-02 16:25:44 +00:00
|
|
|
{
|
|
|
|
struct commit_list *newlist = NULL;
|
|
|
|
struct commit_list **p = &newlist;
|
2005-06-29 18:30:24 +00:00
|
|
|
while (list) {
|
2005-06-02 16:25:44 +00:00
|
|
|
struct commit *commit = pop_most_recent_commit(&list, SEEN);
|
|
|
|
struct object *obj = &commit->object;
|
|
|
|
|
2005-07-03 20:29:54 +00:00
|
|
|
if (unpacked && has_sha1_pack(obj->sha1))
|
|
|
|
obj->flags |= UNINTERESTING;
|
git-rev-list: allow arbitrary head selections, use git-rev-tree syntax
This makes git-rev-list use the same command line syntax to mark the
commits as git-rev-tree does, and instead of just allowing a start and
end commit, it allows an arbitrary list of "interesting" and "uninteresting"
commits.
For example, imagine that you had three branches (a, b and c) that you
are interested in, but you don't want to see stuff that already exists
in another persons three releases (x, y and z). You can do
git-rev-list a b c ^x ^y ^z
(order doesn't matter, btw - feel free to put the uninteresting ones
first or otherwise swithc them around), and it will show all the
commits that are reachable from a/b/c but not reachable from x/y/z.
The old syntax "git-rev-list start end" would not be written as
"git-rev-list start ^end", or "git-rev-list ^end start".
There's no limit to the number of heads you can specify (unlike
git-rev-tree, which can handle a maximum of 16 heads).
2005-06-04 21:38:28 +00:00
|
|
|
if (obj->flags & UNINTERESTING) {
|
2005-06-02 16:25:44 +00:00
|
|
|
mark_parents_uninteresting(commit);
|
|
|
|
if (everybody_uninteresting(list))
|
|
|
|
break;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
p = &commit_list_insert(commit, p)->next;
|
2005-06-29 18:30:24 +00:00
|
|
|
}
|
2005-06-18 05:54:50 +00:00
|
|
|
if (bisect_list)
|
|
|
|
newlist = find_bisection(newlist);
|
2005-06-02 16:25:44 +00:00
|
|
|
return newlist;
|
|
|
|
}
|
|
|
|
|
2005-06-29 18:30:24 +00:00
|
|
|
static void add_pending_object(struct object *obj, const char *name)
|
|
|
|
{
|
|
|
|
add_object(obj, &pending_objects, name);
|
|
|
|
}
|
|
|
|
|
2005-06-29 17:40:14 +00:00
|
|
|
static struct commit *get_commit_reference(const char *name, unsigned int flags)
|
|
|
|
{
|
|
|
|
unsigned char sha1[20];
|
2005-06-29 18:30:24 +00:00
|
|
|
struct object *object;
|
2005-06-29 17:40:14 +00:00
|
|
|
|
|
|
|
if (get_sha1(name, sha1))
|
|
|
|
usage(rev_list_usage);
|
2005-06-29 18:30:24 +00:00
|
|
|
object = parse_object(sha1);
|
|
|
|
if (!object)
|
|
|
|
die("bad object %s", name);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Tag object? Look what it points to..
|
|
|
|
*/
|
2005-07-11 06:55:56 +00:00
|
|
|
while (object->type == tag_type) {
|
2005-06-29 18:30:24 +00:00
|
|
|
struct tag *tag = (struct tag *) object;
|
|
|
|
object->flags |= flags;
|
|
|
|
if (tag_objects && !(object->flags & UNINTERESTING))
|
|
|
|
add_pending_object(object, tag->tag);
|
2005-07-11 06:55:56 +00:00
|
|
|
object = parse_object(tag->tagged->sha1);
|
2005-06-29 18:30:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 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);
|
2005-07-10 22:09:46 +00:00
|
|
|
if (flags & UNINTERESTING)
|
|
|
|
mark_parents_uninteresting(commit);
|
2005-06-29 18:30:24 +00:00
|
|
|
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)
|
2005-07-03 20:07:52 +00:00
|
|
|
return NULL;
|
2005-06-29 18:30:24 +00:00
|
|
|
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)
|
2005-07-03 20:07:52 +00:00
|
|
|
return NULL;
|
2005-06-29 18:30:24 +00:00
|
|
|
if (flags & UNINTERESTING) {
|
|
|
|
mark_blob_uninteresting(blob);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
add_pending_object(object, "");
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
die("%s is unknown object", name);
|
2005-06-29 17:40:14 +00:00
|
|
|
}
|
|
|
|
|
2005-08-04 09:31:15 +00:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2005-04-24 02:04:40 +00:00
|
|
|
int main(int argc, char **argv)
|
|
|
|
{
|
|
|
|
struct commit_list *list = NULL;
|
git-rev-list: allow arbitrary head selections, use git-rev-tree syntax
This makes git-rev-list use the same command line syntax to mark the
commits as git-rev-tree does, and instead of just allowing a start and
end commit, it allows an arbitrary list of "interesting" and "uninteresting"
commits.
For example, imagine that you had three branches (a, b and c) that you
are interested in, but you don't want to see stuff that already exists
in another persons three releases (x, y and z). You can do
git-rev-list a b c ^x ^y ^z
(order doesn't matter, btw - feel free to put the uninteresting ones
first or otherwise swithc them around), and it will show all the
commits that are reachable from a/b/c but not reachable from x/y/z.
The old syntax "git-rev-list start end" would not be written as
"git-rev-list start ^end", or "git-rev-list ^end start".
There's no limit to the number of heads you can specify (unlike
git-rev-tree, which can handle a maximum of 16 heads).
2005-06-04 21:38:28 +00:00
|
|
|
int i, limited = 0;
|
2005-04-24 02:04:40 +00:00
|
|
|
|
2005-05-06 08:00:11 +00:00
|
|
|
for (i = 1 ; i < argc; i++) {
|
git-rev-list: allow arbitrary head selections, use git-rev-tree syntax
This makes git-rev-list use the same command line syntax to mark the
commits as git-rev-tree does, and instead of just allowing a start and
end commit, it allows an arbitrary list of "interesting" and "uninteresting"
commits.
For example, imagine that you had three branches (a, b and c) that you
are interested in, but you don't want to see stuff that already exists
in another persons three releases (x, y and z). You can do
git-rev-list a b c ^x ^y ^z
(order doesn't matter, btw - feel free to put the uninteresting ones
first or otherwise swithc them around), and it will show all the
commits that are reachable from a/b/c but not reachable from x/y/z.
The old syntax "git-rev-list start end" would not be written as
"git-rev-list start ^end", or "git-rev-list ^end start".
There's no limit to the number of heads you can specify (unlike
git-rev-tree, which can handle a maximum of 16 heads).
2005-06-04 21:38:28 +00:00
|
|
|
int flags;
|
2005-05-06 08:00:11 +00:00
|
|
|
char *arg = argv[i];
|
2005-08-04 09:31:15 +00:00
|
|
|
char *dotdot;
|
git-rev-list: allow arbitrary head selections, use git-rev-tree syntax
This makes git-rev-list use the same command line syntax to mark the
commits as git-rev-tree does, and instead of just allowing a start and
end commit, it allows an arbitrary list of "interesting" and "uninteresting"
commits.
For example, imagine that you had three branches (a, b and c) that you
are interested in, but you don't want to see stuff that already exists
in another persons three releases (x, y and z). You can do
git-rev-list a b c ^x ^y ^z
(order doesn't matter, btw - feel free to put the uninteresting ones
first or otherwise swithc them around), and it will show all the
commits that are reachable from a/b/c but not reachable from x/y/z.
The old syntax "git-rev-list start end" would not be written as
"git-rev-list start ^end", or "git-rev-list ^end start".
There's no limit to the number of heads you can specify (unlike
git-rev-tree, which can handle a maximum of 16 heads).
2005-06-04 21:38:28 +00:00
|
|
|
struct commit *commit;
|
2005-05-06 08:00:11 +00:00
|
|
|
|
|
|
|
if (!strncmp(arg, "--max-count=", 12)) {
|
|
|
|
max_count = atoi(arg + 12);
|
2005-05-26 01:29:09 +00:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (!strncmp(arg, "--max-age=", 10)) {
|
2005-05-06 08:00:11 +00:00
|
|
|
max_age = atoi(arg + 10);
|
2005-05-26 01:29:09 +00:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (!strncmp(arg, "--min-age=", 10)) {
|
2005-05-06 08:00:11 +00:00
|
|
|
min_age = atoi(arg + 10);
|
2005-05-26 01:29:09 +00:00
|
|
|
continue;
|
2005-05-06 08:00:11 +00:00
|
|
|
}
|
2005-05-26 01:29:09 +00:00
|
|
|
if (!strcmp(arg, "--header")) {
|
|
|
|
verbose_header = 1;
|
|
|
|
continue;
|
|
|
|
}
|
2005-06-05 16:02:03 +00:00
|
|
|
if (!strncmp(arg, "--pretty", 8)) {
|
|
|
|
commit_format = get_commit_format(arg+8);
|
2005-06-01 15:42:22 +00:00
|
|
|
verbose_header = 1;
|
|
|
|
hdr_termination = '\n';
|
|
|
|
prefix = "commit ";
|
|
|
|
continue;
|
|
|
|
}
|
2005-08-08 09:37:21 +00:00
|
|
|
if (!strncmp(arg, "--no-merges", 11)) {
|
|
|
|
no_merges = 1;
|
|
|
|
continue;
|
|
|
|
}
|
2005-05-31 02:30:07 +00:00
|
|
|
if (!strcmp(arg, "--parents")) {
|
|
|
|
show_parents = 1;
|
|
|
|
continue;
|
|
|
|
}
|
2005-06-18 05:54:50 +00:00
|
|
|
if (!strcmp(arg, "--bisect")) {
|
|
|
|
bisect_list = 1;
|
|
|
|
continue;
|
|
|
|
}
|
2005-06-25 05:56:58 +00:00
|
|
|
if (!strcmp(arg, "--objects")) {
|
2005-06-29 17:40:14 +00:00
|
|
|
tag_objects = 1;
|
2005-06-25 05:56:58 +00:00
|
|
|
tree_objects = 1;
|
|
|
|
blob_objects = 1;
|
|
|
|
continue;
|
|
|
|
}
|
2005-07-03 20:29:54 +00:00
|
|
|
if (!strcmp(arg, "--unpacked")) {
|
|
|
|
unpacked = 1;
|
|
|
|
limited = 1;
|
|
|
|
continue;
|
|
|
|
}
|
2005-07-05 19:12:50 +00:00
|
|
|
if (!strcmp(arg, "--merge-order")) {
|
2005-06-06 15:39:40 +00:00
|
|
|
merge_order = 1;
|
|
|
|
continue;
|
|
|
|
}
|
2005-07-05 19:12:50 +00:00
|
|
|
if (!strcmp(arg, "--show-breaks")) {
|
2005-06-06 15:39:40 +00:00
|
|
|
show_breaks = 1;
|
|
|
|
continue;
|
|
|
|
}
|
2005-07-06 17:25:04 +00:00
|
|
|
if (!strcmp(arg, "--topo-order")) {
|
|
|
|
topo_order = 1;
|
2005-07-06 17:51:43 +00:00
|
|
|
limited = 1;
|
2005-07-06 17:25:04 +00:00
|
|
|
continue;
|
|
|
|
}
|
2005-05-26 01:29:09 +00:00
|
|
|
|
2005-08-04 09:31:15 +00:00
|
|
|
if (show_breaks && !merge_order)
|
|
|
|
usage(rev_list_usage);
|
|
|
|
|
git-rev-list: allow arbitrary head selections, use git-rev-tree syntax
This makes git-rev-list use the same command line syntax to mark the
commits as git-rev-tree does, and instead of just allowing a start and
end commit, it allows an arbitrary list of "interesting" and "uninteresting"
commits.
For example, imagine that you had three branches (a, b and c) that you
are interested in, but you don't want to see stuff that already exists
in another persons three releases (x, y and z). You can do
git-rev-list a b c ^x ^y ^z
(order doesn't matter, btw - feel free to put the uninteresting ones
first or otherwise swithc them around), and it will show all the
commits that are reachable from a/b/c but not reachable from x/y/z.
The old syntax "git-rev-list start end" would not be written as
"git-rev-list start ^end", or "git-rev-list ^end start".
There's no limit to the number of heads you can specify (unlike
git-rev-tree, which can handle a maximum of 16 heads).
2005-06-04 21:38:28 +00:00
|
|
|
flags = 0;
|
2005-08-04 09:31:15 +00:00
|
|
|
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 = '.';
|
|
|
|
}
|
git-rev-list: allow arbitrary head selections, use git-rev-tree syntax
This makes git-rev-list use the same command line syntax to mark the
commits as git-rev-tree does, and instead of just allowing a start and
end commit, it allows an arbitrary list of "interesting" and "uninteresting"
commits.
For example, imagine that you had three branches (a, b and c) that you
are interested in, but you don't want to see stuff that already exists
in another persons three releases (x, y and z). You can do
git-rev-list a b c ^x ^y ^z
(order doesn't matter, btw - feel free to put the uninteresting ones
first or otherwise swithc them around), and it will show all the
commits that are reachable from a/b/c but not reachable from x/y/z.
The old syntax "git-rev-list start end" would not be written as
"git-rev-list start ^end", or "git-rev-list ^end start".
There's no limit to the number of heads you can specify (unlike
git-rev-tree, which can handle a maximum of 16 heads).
2005-06-04 21:38:28 +00:00
|
|
|
if (*arg == '^') {
|
|
|
|
flags = UNINTERESTING;
|
|
|
|
arg++;
|
|
|
|
limited = 1;
|
|
|
|
}
|
2005-06-29 17:40:14 +00:00
|
|
|
commit = get_commit_reference(arg, flags);
|
2005-08-04 09:31:15 +00:00
|
|
|
handle_one_commit(commit, &list);
|
2005-05-06 08:00:11 +00:00
|
|
|
}
|
|
|
|
|
2005-06-06 15:39:40 +00:00
|
|
|
if (!merge_order) {
|
2005-07-07 00:59:13 +00:00
|
|
|
sort_by_date(&list);
|
2005-06-08 20:59:43 +00:00
|
|
|
if (limited)
|
2005-06-06 15:39:40 +00:00
|
|
|
list = limit_list(list);
|
2005-07-06 17:25:04 +00:00
|
|
|
if (topo_order)
|
|
|
|
sort_in_topological_order(&list);
|
2005-06-06 15:39:40 +00:00
|
|
|
show_commit_list(list);
|
|
|
|
} else {
|
2005-07-29 15:50:51 +00:00
|
|
|
#ifndef NO_OPENSSL
|
2005-06-06 15:39:40 +00:00
|
|
|
if (sort_list_in_merge_order(list, &process_commit)) {
|
2005-07-29 15:50:51 +00:00
|
|
|
die("merge order sort failed\n");
|
2005-06-06 15:39:40 +00:00
|
|
|
}
|
2005-07-29 15:50:51 +00:00
|
|
|
#else
|
|
|
|
die("merge order sort unsupported, OpenSSL not linked");
|
|
|
|
#endif
|
2005-06-06 15:39:40 +00:00
|
|
|
}
|
2005-05-31 01:46:32 +00:00
|
|
|
|
2005-04-24 02:04:40 +00:00
|
|
|
return 0;
|
|
|
|
}
|