[thirdparty/git.git] / rev-list.c

#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		(1u << 3)

static const char rev_list_usage[] =
	"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"
		      "  --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 blob_objects = 0;
static int verbose_header = 0;
static int show_parents = 0;
static int hdr_termination = 0;
static const char *commit_prefix = "";
static unsigned long max_age = -1;
static unsigned long min_age = -1;
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 int no_merges = 0;

static void show_commit(struct commit *commit)
{
	commit->object.flags |= SHOWN;
	if (show_breaks) {
		commit_prefix = "| ";
		if (commit->object.flags & DISCONTINUITY) {
			commit_prefix = "^ ";     
		} else if (commit->object.flags & BOUNDARY) {
			commit_prefix = "= ";
		} 
        }        		
	printf("%s%s", commit_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;
		}
	}
	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 (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)) {
		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;
}

static int process_commit(struct commit * commit)
{
	int action=filter_commit(commit);

	if (action == STOP) {
		return STOP;
	}

	if (action == CONTINUE) {
		return CONTINUE;
	}

	show_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);
	entry = tree->entries;
	tree->entries = NULL;
	while (entry) {
		struct tree_entry_list *next = entry->next;
		if (entry->directory)
			p = process_tree(entry->item.tree, p, entry->name);
		else
			p = process_blob(entry->item.blob, p, entry->name);
		free(entry);
		entry = next;
	}
	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;
	tree->entries = NULL;
	while (entry) {
		struct tree_entry_list *next = entry->next;
		if (entry->directory)
			mark_tree_uninteresting(entry->item.tree);
		else
			mark_blob_uninteresting(entry->item.blob);
		free(entry);
		entry = next;
	}
}

static void mark_parents_uninteresting(struct commit *commit)
{
	struct commit_list *parents = commit->parents;

	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 *orig)
{
	struct commit_list *list = orig;
	while (list) {
		struct commit *commit = list->item;
		list = list->next;
		if (commit->object.flags & UNINTERESTING)
			continue;
		return 0;
	}
	return 1;
}

/*
 * 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;
}

static void clear_distance(struct commit_list *list)
{
	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;
}

static void mark_edges_uninteresting(struct commit_list *list)
{
	for ( ; list; list = list->next) {
		struct commit_list *parents = list->item->parents;

		for ( ; parents; parents = parents->next) {
			struct commit *commit = parents->item;
			if (commit->object.flags & UNINTERESTING)
				mark_tree_uninteresting(commit->tree);
		}
	}
}

static struct commit_list *limit_list(struct commit_list *list)
{
	struct commit_list *newlist = NULL;
	struct commit_list **p = &newlist;
	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))
				break;
			continue;
		}
		p = &commit_list_insert(commit, p)->next;
	}
	if (tree_objects)
		mark_edges_uninteresting(newlist);
	if (bisect_list)
		newlist = find_bisection(newlist);
	return newlist;
}

static void add_pending_object(struct object *obj, const char *name)
{
	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);
		if (!object)
			die("bad object %s", sha1_to_hex(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);
}

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;
	int i, limited = 0;

	setup_git_directory();
	for (i = 1 ; i < argc; i++) {
		int flags;
		char *arg = argv[i];
		char *dotdot;
		struct commit *commit;

		if (!strncmp(arg, "--max-count=", 12)) {
			max_count = atoi(arg + 12);
			continue;
		}
		if (!strncmp(arg, "--max-age=", 10)) {
			max_age = atoi(arg + 10);
			continue;
		}
		if (!strncmp(arg, "--min-age=", 10)) {
			min_age = atoi(arg + 10);
			continue;
		}
		if (!strcmp(arg, "--header")) {
			verbose_header = 1;
			continue;
		}
		if (!strncmp(arg, "--pretty", 8)) {
			commit_format = get_commit_format(arg+8);
			verbose_header = 1;
			hdr_termination = '\n';
			if (commit_format == CMIT_FMT_ONELINE)
				commit_prefix = "";
			else
				commit_prefix = "commit ";
			continue;
		}
		if (!strncmp(arg, "--no-merges", 11)) {
			no_merges = 1;
			continue;
		}
		if (!strcmp(arg, "--parents")) {
			show_parents = 1;
			continue;
		}
		if (!strcmp(arg, "--bisect")) {
			bisect_list = 1;
			continue;
		}
		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 (!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;
		}
		commit = get_commit_reference(arg, flags);
		handle_one_commit(commit, &list);
	}

	save_commit_buffer = verbose_header;
	track_object_refs = 0;

	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");
		}
#else
		die("merge order sort unsupported, OpenSSL not linked");
#endif
	}

	return 0;
}
Commit	Line	Data
64745109	1	#include "cache.h"
36f8d174	2	#include "tag.h"
64745109	3	#include "commit.h"
9de48752 LT	4	#include "tree.h"
9de48752 LT	5	#include "blob.h"
a3437b8c	6	#include "epoch.h"
64745109	7
8906300f LT	8	#define SEEN (1u << 0)
8906300f LT	9	#define INTERESTING (1u << 1)
8b3a1e05	10	#define COUNTED (1u << 2)
bce62866	11	#define SHOWN (1u << 3)
8906300f	12
a6f68d47	13	static const char rev_list_usage[] =
54c6870e	14	"git-rev-list [OPTION] commit-id <commit-id>\n"
a6f68d47 LT	15	" --max-count=nr\n"
	16	" --max-age=epoch\n"
	17	" --min-age=epoch\n"
76cd8eb6	18	" --parents\n"
12d2a187 LT	19	" --bisect\n"
	20	" --objects\n"
	21	" --unpacked\n"
9d97aa64	22	" --header\n"
a3437b8c	23	" --pretty\n"
76cd8eb6 JS	24	" --no-merges\n"
	25	" --merge-order [ --show-breaks ]\n"
	26	" --topo-order";
a6f68d47	27
12d2a187	28	static int unpacked = 0;
8b3a1e05	29	static int bisect_list = 0;
3c90f03d	30	static int tag_objects = 0;
9de48752 LT	31	static int tree_objects = 0;
9de48752 LT	32	static int blob_objects = 0;
81f2bb1f LT	33	static int verbose_header = 0;
81f2bb1f LT	34	static int show_parents = 0;
81f2bb1f	35	static int hdr_termination = 0;
d998a089	36	static const char *commit_prefix = "";
81f2bb1f LT	37	static unsigned long max_age = -1;
	38	static unsigned long min_age = -1;
	39	static int max_count = -1;
000182ea	40	static enum cmit_fmt commit_format = CMIT_FMT_RAW;
a3437b8c JS	41	static int merge_order = 0;
a3437b8c JS	42	static int show_breaks = 0;
5e749e25	43	static int stop_traversal = 0;
d2d02a49	44	static int topo_order = 0;
76cd8eb6	45	static int no_merges = 0;
81f2bb1f LT	46
	47	static void show_commit(struct commit *commit)
	48	{
51b1e171	49	commit->object.flags \|= SHOWN;
a3437b8c	50	if (show_breaks) {
d998a089	51	commit_prefix = "\| ";
a3437b8c	52	if (commit->object.flags & DISCONTINUITY) {
d998a089	53	commit_prefix = "^ ";
a3437b8c	54	} else if (commit->object.flags & BOUNDARY) {
d998a089	55	commit_prefix = "= ";
a3437b8c JS	56	}
a3437b8c JS	57	}
d998a089	58	printf("%s%s", commit_prefix, sha1_to_hex(commit->object.sha1));
81f2bb1f LT	59	if (show_parents) {
	60	struct commit_list *parents = commit->parents;
	61	while (parents) {
	62	printf(" %s", sha1_to_hex(parents->item->object.sha1));
	63	parents = parents->next;
	64	}
	65	}
d87449c5 JH	66	if (commit_format == CMIT_FMT_ONELINE)
	67	putchar(' ');
	68	else
	69	putchar('\n');
	70
81f2bb1f	71	if (verbose_header) {
000182ea LT	72	static char pretty_header[16384];
	73	pretty_print_commit(commit_format, commit->buffer, ~0, pretty_header, sizeof(pretty_header));
	74	printf("%s%c", pretty_header, hdr_termination);
7620d39f LT	75	}
7620d39f LT	76	fflush(stdout);
a3437b8c JS	77	}
	78
	79	static int filter_commit(struct commit * commit)
	80	{
d2775a81	81	if (stop_traversal && (commit->object.flags & BOUNDARY))
5e749e25	82	return STOP;
51b1e171	83	if (commit->object.flags & (UNINTERESTING\|SHOWN))
a3437b8c JS	84	return CONTINUE;
	85	if (min_age != -1 && (commit->date > min_age))
	86	return CONTINUE;
5e749e25	87	if (max_age != -1 && (commit->date < max_age)) {
d2775a81 JS	88	stop_traversal=1;
d2775a81 JS	89	return merge_order?CONTINUE:STOP;
5e749e25	90	}
a3437b8c JS	91	if (max_count != -1 && !max_count--)
a3437b8c JS	92	return STOP;
76cd8eb6 JS	93	if (no_merges && (commit->parents && commit->parents->next))
76cd8eb6 JS	94	return CONTINUE;
a3437b8c JS	95	return DO;
	96	}
	97
	98	static int process_commit(struct commit * commit)
	99	{
	100	int action=filter_commit(commit);
	101
	102	if (action == STOP) {
	103	return STOP;
	104	}
	105
	106	if (action == CONTINUE) {
	107	return CONTINUE;
81f2bb1f	108	}
a3437b8c JS	109
	110	show_commit(commit);
	111
	112	return CONTINUE;
81f2bb1f LT	113	}
81f2bb1f LT	114
9ce43d1c	115	static struct object_list *add_object(struct object obj, struct object_list *p, const char name)
9de48752 LT	116	{
	117	struct object_list entry = xmalloc(sizeof(entry));
	118	entry->item = obj;
36f8d174	119	entry->next = *p;
9ce43d1c	120	entry->name = name;
9de48752 LT	121	*p = entry;
	122	return &entry->next;
	123	}
	124
9ce43d1c	125	static struct object_list *process_blob(struct blob blob, struct object_list *p, const char name)
9de48752 LT	126	{
	127	struct object *obj = &blob->object;
	128
	129	if (!blob_objects)
	130	return p;
	131	if (obj->flags & (UNINTERESTING \| SEEN))
	132	return p;
	133	obj->flags \|= SEEN;
9ce43d1c	134	return add_object(obj, p, name);
9de48752 LT	135	}
9de48752 LT	136
9ce43d1c	137	static struct object_list *process_tree(struct tree tree, struct object_list *p, const char name)
9de48752 LT	138	{
	139	struct object *obj = &tree->object;
	140	struct tree_entry_list *entry;
	141
	142	if (!tree_objects)
	143	return p;
	144	if (obj->flags & (UNINTERESTING \| SEEN))
	145	return p;
	146	if (parse_tree(tree) < 0)
	147	die("bad tree object %s", sha1_to_hex(obj->sha1));
	148	obj->flags \|= SEEN;
9ce43d1c	149	p = add_object(obj, p, name);
b0d8923e LT	150	entry = tree->entries;
	151	tree->entries = NULL;
	152	while (entry) {
	153	struct tree_entry_list *next = entry->next;
9de48752	154	if (entry->directory)
9ce43d1c	155	p = process_tree(entry->item.tree, p, entry->name);
9de48752	156	else
9ce43d1c	157	p = process_blob(entry->item.blob, p, entry->name);
b0d8923e LT	158	free(entry);
b0d8923e LT	159	entry = next;
9de48752 LT	160	}
	161	return p;
	162	}
	163
36f8d174 LT	164	static struct object_list *pending_objects = NULL;
36f8d174 LT	165
81f2bb1f LT	166	static void show_commit_list(struct commit_list *list)
81f2bb1f LT	167	{
36f8d174	168	struct object_list objects = NULL, p = &objects, pending;
81f2bb1f LT	169	while (list) {
	170	struct commit *commit = pop_most_recent_commit(&list, SEEN);
	171
9ce43d1c	172	p = process_tree(commit->tree, p, "");
a3437b8c	173	if (process_commit(commit) == STOP)
81f2bb1f	174	break;
81f2bb1f	175	}
36f8d174 LT	176	for (pending = pending_objects; pending; pending = pending->next) {
	177	struct object *obj = pending->item;
	178	const char *name = pending->name;
	179	if (obj->flags & (UNINTERESTING \| SEEN))
	180	continue;
	181	if (obj->type == tag_type) {
	182	obj->flags \|= SEEN;
	183	p = add_object(obj, p, name);
	184	continue;
	185	}
	186	if (obj->type == tree_type) {
	187	p = process_tree((struct tree *)obj, p, name);
	188	continue;
	189	}
	190	if (obj->type == blob_type) {
	191	p = process_blob((struct blob *)obj, p, name);
	192	continue;
	193	}
	194	die("unknown pending object %s (%s)", sha1_to_hex(obj->sha1), name);
	195	}
9de48752	196	while (objects) {
9ce43d1c	197	printf("%s %s\n", sha1_to_hex(objects->item->sha1), objects->name);
9de48752 LT	198	objects = objects->next;
	199	}
	200	}
	201
	202	static void mark_blob_uninteresting(struct blob *blob)
	203	{
	204	if (!blob_objects)
	205	return;
	206	if (blob->object.flags & UNINTERESTING)
	207	return;
	208	blob->object.flags \|= UNINTERESTING;
	209	}
	210
	211	static void mark_tree_uninteresting(struct tree *tree)
	212	{
	213	struct object *obj = &tree->object;
	214	struct tree_entry_list *entry;
	215
	216	if (!tree_objects)
	217	return;
	218	if (obj->flags & UNINTERESTING)
	219	return;
	220	obj->flags \|= UNINTERESTING;
454fbbcd LT	221	if (!has_sha1_file(obj->sha1))
454fbbcd LT	222	return;
9de48752 LT	223	if (parse_tree(tree) < 0)
	224	die("bad tree %s", sha1_to_hex(obj->sha1));
	225	entry = tree->entries;
b0d8923e	226	tree->entries = NULL;
9de48752	227	while (entry) {
b0d8923e	228	struct tree_entry_list *next = entry->next;
9de48752 LT	229	if (entry->directory)
	230	mark_tree_uninteresting(entry->item.tree);
	231	else
	232	mark_blob_uninteresting(entry->item.blob);
b0d8923e LT	233	free(entry);
b0d8923e LT	234	entry = next;
9de48752	235	}
81f2bb1f LT	236	}
81f2bb1f LT	237
8906300f LT	238	static void mark_parents_uninteresting(struct commit *commit)
	239	{
	240	struct commit_list *parents = commit->parents;
	241
	242	while (parents) {
	243	struct commit *commit = parents->item;
	244	commit->object.flags \|= UNINTERESTING;
454fbbcd	245
6c3b84c8 LT	246	/*
	247	* Normally we haven't parsed the parent
	248	* yet, so we won't have a parent of a parent
	249	* here. However, it may turn out that we've
	250	* reached this commit some other way (where it
	251	* wasn't uninteresting), in which case we need
	252	* to mark its parents recursively too..
	253	*/
	254	if (commit->parents)
	255	mark_parents_uninteresting(commit);
	256
454fbbcd LT	257	/*
	258	* A missing commit is ok iff its parent is marked
	259	* uninteresting.
	260	*
	261	* We just mark such a thing parsed, so that when
	262	* it is popped next time around, we won't be trying
	263	* to parse it and get an error.
	264	*/
	265	if (!has_sha1_file(commit->object.sha1))
	266	commit->object.parsed = 1;
8906300f LT	267	parents = parents->next;
	268	}
	269	}
	270
4311d328	271	static int everybody_uninteresting(struct commit_list *orig)
8906300f	272	{
4311d328	273	struct commit_list *list = orig;
8906300f LT	274	while (list) {
	275	struct commit *commit = list->item;
	276	list = list->next;
	277	if (commit->object.flags & UNINTERESTING)
	278	continue;
	279	return 0;
	280	}
	281	return 1;
	282	}
	283
8b3a1e05 LT	284	/*
	285	* This is a truly stupid algorithm, but it's only
	286	* used for bisection, and we just don't care enough.
	287	*
	288	* We care just barely enough to avoid recursing for
	289	* non-merge entries.
	290	*/
	291	static int count_distance(struct commit_list *entry)
	292	{
	293	int nr = 0;
	294
	295	while (entry) {
	296	struct commit *commit = entry->item;
	297	struct commit_list *p;
	298
	299	if (commit->object.flags & (UNINTERESTING \| COUNTED))
	300	break;
	301	nr++;
	302	commit->object.flags \|= COUNTED;
	303	p = commit->parents;
	304	entry = p;
	305	if (p) {
	306	p = p->next;
	307	while (p) {
	308	nr += count_distance(p);
	309	p = p->next;
	310	}
	311	}
	312	}
	313	return nr;
	314	}
	315
3d958064	316	static void clear_distance(struct commit_list *list)
8b3a1e05 LT	317	{
	318	while (list) {
	319	struct commit *commit = list->item;
	320	commit->object.flags &= ~COUNTED;
	321	list = list->next;
	322	}
	323	}
	324
	325	static struct commit_list find_bisection(struct commit_list list)
	326	{
	327	int nr, closest;
	328	struct commit_list p, best;
	329
	330	nr = 0;
	331	p = list;
	332	while (p) {
	333	nr++;
	334	p = p->next;
	335	}
	336	closest = 0;
	337	best = list;
	338
	339	p = list;
	340	while (p) {
	341	int distance = count_distance(p);
	342	clear_distance(list);
	343	if (nr - distance < distance)
	344	distance = nr - distance;
	345	if (distance > closest) {
	346	best = p;
	347	closest = distance;
	348	}
	349	p = p->next;
	350	}
	351	if (best)
	352	best->next = NULL;
	353	return best;
	354	}
	355
5bdbaaa4 LT	356	static void mark_edges_uninteresting(struct commit_list *list)
	357	{
	358	for ( ; list; list = list->next) {
	359	struct commit_list *parents = list->item->parents;
	360
	361	for ( ; parents; parents = parents->next) {
	362	struct commit *commit = parents->item;
	363	if (commit->object.flags & UNINTERESTING)
	364	mark_tree_uninteresting(commit->tree);
	365	}
	366	}
	367	}
	368
6da4016a	369	static struct commit_list limit_list(struct commit_list list)
3b42a63c LT	370	{
	371	struct commit_list *newlist = NULL;
	372	struct commit_list **p = &newlist;
36f8d174	373	while (list) {
3b42a63c LT	374	struct commit *commit = pop_most_recent_commit(&list, SEEN);
	375	struct object *obj = &commit->object;
	376
12d2a187 LT	377	if (unpacked && has_sha1_pack(obj->sha1))
12d2a187 LT	378	obj->flags \|= UNINTERESTING;
337cb3fb	379	if (obj->flags & UNINTERESTING) {
3b42a63c LT	380	mark_parents_uninteresting(commit);
	381	if (everybody_uninteresting(list))
	382	break;
	383	continue;
	384	}
	385	p = &commit_list_insert(commit, p)->next;
36f8d174	386	}
5bdbaaa4 LT	387	if (tree_objects)
5bdbaaa4 LT	388	mark_edges_uninteresting(newlist);
8b3a1e05 LT	389	if (bisect_list)
8b3a1e05 LT	390	newlist = find_bisection(newlist);
3b42a63c LT	391	return newlist;
	392	}
	393
36f8d174 LT	394	static void add_pending_object(struct object obj, const char name)
	395	{
	396	add_object(obj, &pending_objects, name);
	397	}
	398
3c90f03d LT	399	static struct commit get_commit_reference(const char name, unsigned int flags)
	400	{
	401	unsigned char sha1[20];
36f8d174	402	struct object *object;
3c90f03d LT	403
	404	if (get_sha1(name, sha1))
	405	usage(rev_list_usage);
36f8d174 LT	406	object = parse_object(sha1);
	407	if (!object)
	408	die("bad object %s", name);
	409
	410	/*
	411	* Tag object? Look what it points to..
	412	*/
013aab82	413	while (object->type == tag_type) {
36f8d174 LT	414	struct tag tag = (struct tag ) object;
	415	object->flags \|= flags;
	416	if (tag_objects && !(object->flags & UNINTERESTING))
	417	add_pending_object(object, tag->tag);
013aab82	418	object = parse_object(tag->tagged->sha1);
7f1335c7 SV	419	if (!object)
7f1335c7 SV	420	die("bad object %s", sha1_to_hex(tag->tagged->sha1));
36f8d174 LT	421	}
	422
	423	/*
	424	* Commit object? Just return it, we'll do all the complex
	425	* reachability crud.
	426	*/
	427	if (object->type == commit_type) {
	428	struct commit commit = (struct commit )object;
	429	object->flags \|= flags;
	430	if (parse_commit(commit) < 0)
	431	die("unable to parse commit %s", name);
454fbbcd LT	432	if (flags & UNINTERESTING)
454fbbcd LT	433	mark_parents_uninteresting(commit);
36f8d174 LT	434	return commit;
	435	}
	436
	437	/*
	438	* Tree object? Either mark it uniniteresting, or add it
	439	* to the list of objects to look at later..
	440	*/
	441	if (object->type == tree_type) {
	442	struct tree tree = (struct tree )object;
	443	if (!tree_objects)
960bba0d	444	return NULL;
36f8d174 LT	445	if (flags & UNINTERESTING) {
	446	mark_tree_uninteresting(tree);
	447	return NULL;
	448	}
	449	add_pending_object(object, "");
	450	return NULL;
	451	}
	452
	453	/*
	454	* Blob object? You know the drill by now..
	455	*/
	456	if (object->type == blob_type) {
	457	struct blob blob = (struct blob )object;
	458	if (!blob_objects)
960bba0d	459	return NULL;
36f8d174 LT	460	if (flags & UNINTERESTING) {
	461	mark_blob_uninteresting(blob);
	462	return NULL;
	463	}
	464	add_pending_object(object, "");
	465	return NULL;
	466	}
	467	die("%s is unknown object", name);
3c90f03d LT	468	}
3c90f03d LT	469
1215879c JH	470	static void handle_one_commit(struct commit com, struct commit_list *lst)
	471	{
	472	if (!com \|\| com->object.flags & SEEN)
	473	return;
	474	com->object.flags \|= SEEN;
	475	commit_list_insert(com, lst);
	476	}
	477
	478
64745109 LT	479	int main(int argc, char **argv)
64745109 LT	480	{
64745109	481	struct commit_list *list = NULL;
337cb3fb	482	int i, limited = 0;
64745109	483
d998a089	484	setup_git_directory();
fcfda02b	485	for (i = 1 ; i < argc; i++) {
337cb3fb	486	int flags;
fcfda02b	487	char *arg = argv[i];
1215879c	488	char *dotdot;
337cb3fb	489	struct commit *commit;
fcfda02b KS	490
	491	if (!strncmp(arg, "--max-count=", 12)) {
	492	max_count = atoi(arg + 12);
a6f68d47 LT	493	continue;
	494	}
	495	if (!strncmp(arg, "--max-age=", 10)) {
fcfda02b	496	max_age = atoi(arg + 10);
a6f68d47 LT	497	continue;
	498	}
	499	if (!strncmp(arg, "--min-age=", 10)) {
fcfda02b	500	min_age = atoi(arg + 10);
a6f68d47	501	continue;
fcfda02b	502	}
a6f68d47 LT	503	if (!strcmp(arg, "--header")) {
	504	verbose_header = 1;
	505	continue;
	506	}
000182ea LT	507	if (!strncmp(arg, "--pretty", 8)) {
000182ea LT	508	commit_format = get_commit_format(arg+8);
9d97aa64	509	verbose_header = 1;
9d97aa64	510	hdr_termination = '\n';
d87449c5	511	if (commit_format == CMIT_FMT_ONELINE)
d998a089	512	commit_prefix = "";
d87449c5	513	else
d998a089	514	commit_prefix = "commit ";
9d97aa64 LT	515	continue;
9d97aa64 LT	516	}
76cd8eb6 JS	517	if (!strncmp(arg, "--no-merges", 11)) {
	518	no_merges = 1;
	519	continue;
	520	}
97658004 LT	521	if (!strcmp(arg, "--parents")) {
	522	show_parents = 1;
	523	continue;
	524	}
8b3a1e05 LT	525	if (!strcmp(arg, "--bisect")) {
	526	bisect_list = 1;
	527	continue;
	528	}
9de48752	529	if (!strcmp(arg, "--objects")) {
3c90f03d	530	tag_objects = 1;
9de48752 LT	531	tree_objects = 1;
	532	blob_objects = 1;
	533	continue;
	534	}
12d2a187 LT	535	if (!strcmp(arg, "--unpacked")) {
	536	unpacked = 1;
	537	limited = 1;
	538	continue;
	539	}
12ba7eaf	540	if (!strcmp(arg, "--merge-order")) {
a3437b8c JS	541	merge_order = 1;
	542	continue;
	543	}
12ba7eaf	544	if (!strcmp(arg, "--show-breaks")) {
a3437b8c JS	545	show_breaks = 1;
	546	continue;
	547	}
d2d02a49 LT	548	if (!strcmp(arg, "--topo-order")) {
d2d02a49 LT	549	topo_order = 1;
e6c3505b	550	limited = 1;
d2d02a49 LT	551	continue;
d2d02a49 LT	552	}
a6f68d47	553
1215879c JH	554	if (show_breaks && !merge_order)
	555	usage(rev_list_usage);
	556
337cb3fb	557	flags = 0;
1215879c JH	558	dotdot = strstr(arg, "..");
	559	if (dotdot) {
	560	char *next = dotdot + 2;
	561	struct commit *exclude = NULL;
	562	struct commit *include = NULL;
	563	*dotdot = 0;
	564	exclude = get_commit_reference(arg, UNINTERESTING);
	565	include = get_commit_reference(next, 0);
	566	if (exclude && include) {
	567	limited = 1;
	568	handle_one_commit(exclude, &list);
	569	handle_one_commit(include, &list);
	570	continue;
	571	}
	572	*next = '.';
	573	}
337cb3fb LT	574	if (*arg == '^') {
	575	flags = UNINTERESTING;
	576	arg++;
	577	limited = 1;
	578	}
3c90f03d	579	commit = get_commit_reference(arg, flags);
1215879c	580	handle_one_commit(commit, &list);
fcfda02b KS	581	}
fcfda02b KS	582
60ab26de	583	save_commit_buffer = verbose_header;
8805ccac	584	track_object_refs = 0;
60ab26de	585
a3437b8c	586	if (!merge_order) {
a7336ae5	587	sort_by_date(&list);
17ebe977	588	if (limited)
a3437b8c	589	list = limit_list(list);
d2d02a49 LT	590	if (topo_order)
d2d02a49 LT	591	sort_in_topological_order(&list);
a3437b8c	592	show_commit_list(list);
a3437b8c	593	} else {
dd53c7ab	594	#ifndef NO_OPENSSL
a3437b8c	595	if (sort_list_in_merge_order(list, &process_commit)) {
dd53c7ab	596	die("merge order sort failed\n");
a3437b8c	597	}
dd53c7ab PB	598	#else
	599	die("merge order sort unsupported, OpenSSL not linked");
	600	#endif
a3437b8c	601	}
8906300f	602
64745109 LT	603	return 0;
64745109 LT	604	}