[thirdparty/git.git] / pack-objects.c

#include <ctype.h>
#include "cache.h"
#include "object.h"
#include "delta.h"
#include "csum-file.h"

static const char pack_usage[] = "git-pack-objects [--window=N] [--depth=N] base-name < object-list";

enum object_type {
	OBJ_NONE,
	OBJ_COMMIT,
	OBJ_TREE,
	OBJ_BLOB,
	OBJ_DELTA
};

struct object_entry {
	unsigned char sha1[20];
	unsigned long size;
	unsigned long offset;
	unsigned int depth;
	unsigned int hash;
	enum object_type type;
	unsigned long delta_size;
	struct object_entry *delta;
};

static struct object_entry **sorted_by_sha, **sorted_by_type;
static struct object_entry *objects = NULL;
static int nr_objects = 0, nr_alloc = 0;
static const char *base_name;
static unsigned char pack_file_sha1[20];

static void *delta_against(void *buf, unsigned long size, struct object_entry *entry)
{
	unsigned long othersize, delta_size;
	char type[10];
	void *otherbuf = read_sha1_file(entry->delta->sha1, type, &othersize);
	void *delta_buf;

	if (!otherbuf)
		die("unable to read %s", sha1_to_hex(entry->delta->sha1));
        delta_buf = diff_delta(otherbuf, othersize,
			       buf, size, &delta_size, ~0UL);
        if (!delta_buf || delta_size != entry->delta_size)
        	die("delta size changed");
        free(buf);
        free(otherbuf);
	return delta_buf;
}

static unsigned long write_object(struct sha1file *f, struct object_entry *entry)
{
	unsigned long size;
	char type[10];
	void *buf = read_sha1_file(entry->sha1, type, &size);
	char header[25];
	unsigned hdrlen, datalen;

	if (!buf)
		die("unable to read %s", sha1_to_hex(entry->sha1));
	if (size != entry->size)
		die("object %s size inconsistency (%lu vs %lu)", sha1_to_hex(entry->sha1), size, entry->size);

	/*
	 * The object header is a byte of 'type' followed by four bytes of
	 * length, except for deltas that has the 20 bytes of delta sha
	 * instead.
	 */
	header[0] = ".CTB"[entry->type];
	hdrlen = 5;
	if (entry->delta) {
		header[0] = 'D';
		memcpy(header+5, entry->delta, 20);
		buf = delta_against(buf, size, entry);
		size = entry->delta_size;
		hdrlen = 25;
	}
	datalen = htonl(size);
	memcpy(header+1, &datalen, 4);
	sha1write(f, header, hdrlen);
	datalen = sha1write_compressed(f, buf, size);
	free(buf);
	return hdrlen + datalen;
}

static void write_pack_file(void)
{
	int i;
	struct sha1file *f = sha1create("%s.%s", base_name, "pack");
	unsigned long offset = 0;
	unsigned long mb;

	for (i = 0; i < nr_objects; i++) {
		struct object_entry *entry = objects + i;
		entry->offset = offset;
		offset += write_object(f, entry);
	}
	sha1close(f, pack_file_sha1, 1);
	mb = offset >> 20;
	offset &= 0xfffff;
}

static void write_index_file(void)
{
	int i;
	struct sha1file *f = sha1create("%s.%s", base_name, "idx");
	struct object_entry **list = sorted_by_sha;
	struct object_entry **last = list + nr_objects;
	unsigned int array[256];

	/*
	 * Write the first-level table (the list is sorted,
	 * but we use a 256-entry lookup to be able to avoid
	 * having to do eight extra binary search iterations).
	 */
	for (i = 0; i < 256; i++) {
		struct object_entry **next = list;
		while (next < last) {
			struct object_entry *entry = *next;
			if (entry->sha1[0] != i)
				break;
			next++;
		}
		array[i] = htonl(next - sorted_by_sha);
		list = next;
	}
	sha1write(f, array, 256 * sizeof(int));

	/*
	 * Write the actual SHA1 entries..
	 */
	list = sorted_by_sha;
	for (i = 0; i < nr_objects; i++) {
		struct object_entry *entry = *list++;
		unsigned int offset = htonl(entry->offset);
		sha1write(f, &offset, 4);
		sha1write(f, entry->sha1, 20);
	}
	sha1write(f, pack_file_sha1, 20);
	sha1close(f, NULL, 1);
}

static void add_object_entry(unsigned char *sha1, unsigned int hash)
{
	unsigned int idx = nr_objects;
	struct object_entry *entry;

	if (idx >= nr_alloc) {
		unsigned int needed = (idx + 1024) * 3 / 2;
		objects = xrealloc(objects, needed * sizeof(*entry));
		nr_alloc = needed;
	}
	entry = objects + idx;
	memset(entry, 0, sizeof(*entry));
	memcpy(entry->sha1, sha1, 20);
	entry->hash = hash;
	nr_objects = idx+1;
}

static void check_object(struct object_entry *entry)
{
	char buffer[128];
	char type[10];
	unsigned long mapsize;
	z_stream stream;
	void *map;

	map = map_sha1_file(entry->sha1, &mapsize);
	if (!map)
		die("unable to map %s", sha1_to_hex(entry->sha1));
	if (unpack_sha1_header(&stream, map, mapsize, buffer, sizeof(buffer)) < 0)
		die("unable to unpack %s header", sha1_to_hex(entry->sha1));
	munmap(map, mapsize);
	if (parse_sha1_header(buffer, type, &entry->size) < 0)
		die("unable to parse %s header", sha1_to_hex(entry->sha1));
	if (!strcmp(type, "commit")) {
		entry->type = OBJ_COMMIT;
	} else if (!strcmp(type, "tree")) {
		entry->type = OBJ_TREE;
	} else if (!strcmp(type, "blob")) {
		entry->type = OBJ_BLOB;
	} else
		die("unable to pack object %s of type %s", sha1_to_hex(entry->sha1), type);
}

static void get_object_details(void)
{
	int i;
	struct object_entry *entry = objects;

	for (i = 0; i < nr_objects; i++)
		check_object(entry++);
}

typedef int (*entry_sort_t)(const struct object_entry *, const struct object_entry *);

static entry_sort_t current_sort;

static int sort_comparator(const void *_a, const void *_b)
{
	struct object_entry *a = *(struct object_entry **)_a;
	struct object_entry *b = *(struct object_entry **)_b;
	return current_sort(a,b);
}

static struct object_entry **create_sorted_list(entry_sort_t sort)
{
	struct object_entry **list = xmalloc(nr_objects * sizeof(struct object_entry *));
	int i;

	for (i = 0; i < nr_objects; i++)
		list[i] = objects + i;
	current_sort = sort;
	qsort(list, nr_objects, sizeof(struct object_entry *), sort_comparator);
	return list;
}

static int sha1_sort(const struct object_entry *a, const struct object_entry *b)
{
	return memcmp(a->sha1, b->sha1, 20);
}

static int type_size_sort(const struct object_entry *a, const struct object_entry *b)
{
	if (a->type < b->type)
		return -1;
	if (a->type > b->type)
		return 1;
	if (a->hash < b->hash)
		return -1;
	if (a->hash > b->hash)
		return 1;
	if (a->size < b->size)
		return -1;
	if (a->size > b->size)
		return 1;
	return a < b ? -1 : (a > b);
}

struct unpacked {
	struct object_entry *entry;
	void *data;
};

/*
 * We search for deltas _backwards_ in a list sorted by type and
 * by size, so that we see progressively smaller and smaller files.
 * That's because we prefer deltas to be from the bigger file
 * to the smaller - deletes are potentially cheaper, but perhaps
 * more importantly, the bigger file is likely the more recent
 * one.
 */
static int try_delta(struct unpacked *cur, struct unpacked *old, unsigned max_depth)
{
	struct object_entry *cur_entry = cur->entry;
	struct object_entry *old_entry = old->entry;
	unsigned long size, oldsize, delta_size, sizediff;
	long max_size;
	void *delta_buf;

	/* Don't bother doing diffs between different types */
	if (cur_entry->type != old_entry->type)
		return -1;

	size = cur_entry->size;
	if (size < 50)
		return -1;
	oldsize = old_entry->size;
	sizediff = oldsize > size ? oldsize - size : size - oldsize;
	if (sizediff > size / 8)
		return -1;
	if (old_entry->depth >= max_depth)
		return 0;

	/*
	 * NOTE!
	 *
	 * We always delta from the bigger to the smaller, since that's
	 * more space-efficient (deletes don't have to say _what_ they
	 * delete).
	 */
	max_size = size / 2 - 20;
	if (cur_entry->delta)
		max_size = cur_entry->delta_size-1;
	if (sizediff >= max_size)
		return -1;
	delta_buf = diff_delta(old->data, oldsize,
			       cur->data, size, &delta_size, max_size);
	if (!delta_buf)
		return 0;
	cur_entry->delta = old_entry;
	cur_entry->delta_size = delta_size;
	cur_entry->depth = old_entry->depth + 1;
	free(delta_buf);
	return 0;
}

static void find_deltas(struct object_entry **list, int window, int depth)
{
	int i, idx;
	unsigned int array_size = window * sizeof(struct unpacked);
	struct unpacked *array = xmalloc(array_size);

	memset(array, 0, array_size);
	i = nr_objects;
	idx = 0;
	while (--i >= 0) {
		struct object_entry *entry = list[i];
		struct unpacked *n = array + idx;
		unsigned long size;
		char type[10];
		int j;

		free(n->data);
		n->entry = entry;
		n->data = read_sha1_file(entry->sha1, type, &size);
		if (size != entry->size)
			die("object %s inconsistent object length (%lu vs %lu)", sha1_to_hex(entry->sha1), size, entry->size);
		j = window;
		while (--j > 0) {
			unsigned int other_idx = idx + j;
			struct unpacked *m;
			if (other_idx >= window)
				other_idx -= window;
			m = array + other_idx;
			if (!m->entry)
				break;
			if (try_delta(n, m, depth) < 0)
				break;
		}
		idx++;
		if (idx >= window)
			idx = 0;
	}
}

int main(int argc, char **argv)
{
	char line[PATH_MAX + 20];
	int window = 10, depth = 10;
	int i;

	for (i = 1; i < argc; i++) {
		const char *arg = argv[i];

		if (*arg == '-') {
			if (!strncmp("--window=", arg, 9)) {
				char *end;
				window = strtoul(arg+9, &end, 0);
				if (!arg[9] || *end)
					usage(pack_usage);
				continue;
			}
			if (!strncmp("--depth=", arg, 8)) {
				char *end;
				depth = strtoul(arg+8, &end, 0);
				if (!arg[8] || *end)
					usage(pack_usage);
				continue;
			}
			usage(pack_usage);
		}
		if (base_name)
			usage(pack_usage);
		base_name = arg;
	}

	if (!base_name)
		usage(pack_usage);

	while (fgets(line, sizeof(line), stdin) != NULL) {
		unsigned int hash;
		char *p;
		unsigned char sha1[20];

		if (get_sha1_hex(line, sha1))
			die("expected sha1, got garbage");
		hash = 0;
		p = line+40;
		while (*p) {
			unsigned char c = *p++;
			if (isspace(c))
				continue;
			hash = hash * 11 + c;
		}
		add_object_entry(sha1, hash);
	}
	get_object_details();

	printf("Packing %d objects\n", nr_objects);

	sorted_by_sha = create_sorted_list(sha1_sort);
	sorted_by_type = create_sorted_list(type_size_sort);
	if (window && depth)
		find_deltas(sorted_by_type, window+1, depth);

	write_pack_file();
	write_index_file();
	return 0;
}
Commit	Line	Data
27225f2e	1	#include <ctype.h>
c323ac7d LT	2	#include "cache.h"
	3	#include "object.h"
	4	#include "delta.h"
c38138cd	5	#include "csum-file.h"
c323ac7d	6
d116a45a	7	static const char pack_usage[] = "git-pack-objects [--window=N] [--depth=N] base-name < object-list";
c323ac7d LT	8
	9	enum object_type {
	10	OBJ_NONE,
	11	OBJ_COMMIT,
	12	OBJ_TREE,
	13	OBJ_BLOB,
c4584ae3	14	OBJ_DELTA
c323ac7d LT	15	};
	16
	17	struct object_entry {
	18	unsigned char sha1[20];
	19	unsigned long size;
	20	unsigned long offset;
	21	unsigned int depth;
27225f2e	22	unsigned int hash;
c323ac7d LT	23	enum object_type type;
	24	unsigned long delta_size;
	25	struct object_entry *delta;
	26	};
	27
	28	static struct object_entry sorted_by_sha, sorted_by_type;
	29	static struct object_entry *objects = NULL;
	30	static int nr_objects = 0, nr_alloc = 0;
c323ac7d	31	static const char *base_name;
e1808845	32	static unsigned char pack_file_sha1[20];
c323ac7d	33
c323ac7d LT	34	static void delta_against(void buf, unsigned long size, struct object_entry *entry)
	35	{
	36	unsigned long othersize, delta_size;
	37	char type[10];
	38	void *otherbuf = read_sha1_file(entry->delta->sha1, type, &othersize);
	39	void *delta_buf;
	40
	41	if (!otherbuf)
	42	die("unable to read %s", sha1_to_hex(entry->delta->sha1));
8ee378a0 JH	43	delta_buf = diff_delta(otherbuf, othersize,
8ee378a0 JH	44	buf, size, &delta_size, ~0UL);
75c42d8c	45	if (!delta_buf \|\| delta_size != entry->delta_size)
c323ac7d LT	46	die("delta size changed");
	47	free(buf);
	48	free(otherbuf);
	49	return delta_buf;
	50	}
	51
c38138cd	52	static unsigned long write_object(struct sha1file f, struct object_entry entry)
c323ac7d LT	53	{
	54	unsigned long size;
	55	char type[10];
	56	void *buf = read_sha1_file(entry->sha1, type, &size);
c4fb06c0	57	char header[25];
c323ac7d LT	58	unsigned hdrlen, datalen;
	59
	60	if (!buf)
	61	die("unable to read %s", sha1_to_hex(entry->sha1));
	62	if (size != entry->size)
	63	die("object %s size inconsistency (%lu vs %lu)", sha1_to_hex(entry->sha1), size, entry->size);
	64
	65	/*
	66	* The object header is a byte of 'type' followed by four bytes of
	67	* length, except for deltas that has the 20 bytes of delta sha
	68	* instead.
	69	*/
	70	header[0] = ".CTB"[entry->type];
c323ac7d LT	71	hdrlen = 5;
c323ac7d LT	72	if (entry->delta) {
d38c3721	73	header[0] = 'D';
c4fb06c0	74	memcpy(header+5, entry->delta, 20);
c323ac7d LT	75	buf = delta_against(buf, size, entry);
c323ac7d LT	76	size = entry->delta_size;
c4fb06c0	77	hdrlen = 25;
c323ac7d	78	}
c4fb06c0 LT	79	datalen = htonl(size);
c4fb06c0 LT	80	memcpy(header+1, &datalen, 4);
c38138cd LT	81	sha1write(f, header, hdrlen);
c38138cd LT	82	datalen = sha1write_compressed(f, buf, size);
c323ac7d LT	83	free(buf);
	84	return hdrlen + datalen;
	85	}
	86
	87	static void write_pack_file(void)
	88	{
	89	int i;
c38138cd	90	struct sha1file *f = sha1create("%s.%s", base_name, "pack");
c323ac7d LT	91	unsigned long offset = 0;
	92	unsigned long mb;
	93
	94	for (i = 0; i < nr_objects; i++) {
	95	struct object_entry *entry = objects + i;
	96	entry->offset = offset;
	97	offset += write_object(f, entry);
	98	}
e1808845	99	sha1close(f, pack_file_sha1, 1);
c323ac7d LT	100	mb = offset >> 20;
	101	offset &= 0xfffff;
	102	}
	103
	104	static void write_index_file(void)
	105	{
	106	int i;
c38138cd	107	struct sha1file *f = sha1create("%s.%s", base_name, "idx");
c323ac7d LT	108	struct object_entry **list = sorted_by_sha;
	109	struct object_entry **last = list + nr_objects;
	110	unsigned int array[256];
	111
	112	/*
	113	* Write the first-level table (the list is sorted,
	114	* but we use a 256-entry lookup to be able to avoid
e1808845	115	* having to do eight extra binary search iterations).
c323ac7d LT	116	*/
	117	for (i = 0; i < 256; i++) {
	118	struct object_entry **next = list;
	119	while (next < last) {
	120	struct object_entry entry = next;
	121	if (entry->sha1[0] != i)
	122	break;
	123	next++;
	124	}
	125	array[i] = htonl(next - sorted_by_sha);
	126	list = next;
	127	}
c38138cd	128	sha1write(f, array, 256 * sizeof(int));
c323ac7d LT	129
	130	/*
	131	* Write the actual SHA1 entries..
	132	*/
	133	list = sorted_by_sha;
49397104	134	for (i = 0; i < nr_objects; i++) {
c323ac7d LT	135	struct object_entry entry = list++;
c323ac7d LT	136	unsigned int offset = htonl(entry->offset);
c38138cd LT	137	sha1write(f, &offset, 4);
c38138cd LT	138	sha1write(f, entry->sha1, 20);
c323ac7d	139	}
e1808845 LT	140	sha1write(f, pack_file_sha1, 20);
e1808845 LT	141	sha1close(f, NULL, 1);
c323ac7d LT	142	}
c323ac7d LT	143
27225f2e	144	static void add_object_entry(unsigned char *sha1, unsigned int hash)
c323ac7d LT	145	{
	146	unsigned int idx = nr_objects;
	147	struct object_entry *entry;
	148
	149	if (idx >= nr_alloc) {
	150	unsigned int needed = (idx + 1024) * 3 / 2;
	151	objects = xrealloc(objects, needed * sizeof(*entry));
	152	nr_alloc = needed;
	153	}
	154	entry = objects + idx;
	155	memset(entry, 0, sizeof(*entry));
	156	memcpy(entry->sha1, sha1, 20);
27225f2e	157	entry->hash = hash;
c323ac7d LT	158	nr_objects = idx+1;
	159	}
	160
	161	static void check_object(struct object_entry *entry)
	162	{
	163	char buffer[128];
	164	char type[10];
	165	unsigned long mapsize;
	166	z_stream stream;
	167	void *map;
	168
	169	map = map_sha1_file(entry->sha1, &mapsize);
	170	if (!map)
	171	die("unable to map %s", sha1_to_hex(entry->sha1));
	172	if (unpack_sha1_header(&stream, map, mapsize, buffer, sizeof(buffer)) < 0)
	173	die("unable to unpack %s header", sha1_to_hex(entry->sha1));
	174	munmap(map, mapsize);
	175	if (parse_sha1_header(buffer, type, &entry->size) < 0)
	176	die("unable to parse %s header", sha1_to_hex(entry->sha1));
	177	if (!strcmp(type, "commit")) {
	178	entry->type = OBJ_COMMIT;
	179	} else if (!strcmp(type, "tree")) {
	180	entry->type = OBJ_TREE;
	181	} else if (!strcmp(type, "blob")) {
	182	entry->type = OBJ_BLOB;
	183	} else
	184	die("unable to pack object %s of type %s", sha1_to_hex(entry->sha1), type);
	185	}
	186
	187	static void get_object_details(void)
	188	{
	189	int i;
	190	struct object_entry *entry = objects;
	191
	192	for (i = 0; i < nr_objects; i++)
	193	check_object(entry++);
	194	}
	195
	196	typedef int (entry_sort_t)(const struct object_entry , const struct object_entry *);
	197
	198	static entry_sort_t current_sort;
	199
	200	static int sort_comparator(const void _a, const void _b)
	201	{
	202	struct object_entry a = (struct object_entry **)_a;
	203	struct object_entry b = (struct object_entry **)_b;
	204	return current_sort(a,b);
	205	}
	206
	207	static struct object_entry **create_sorted_list(entry_sort_t sort)
	208	{
	209	struct object_entry *list = xmalloc(nr_objects sizeof(struct object_entry *));
	210	int i;
	211
	212	for (i = 0; i < nr_objects; i++)
	213	list[i] = objects + i;
	214	current_sort = sort;
	215	qsort(list, nr_objects, sizeof(struct object_entry *), sort_comparator);
	216	return list;
	217	}
	218
	219	static int sha1_sort(const struct object_entry a, const struct object_entry b)
	220	{
	221	return memcmp(a->sha1, b->sha1, 20);
222	}
223
224	static int type_size_sort(const struct object_entry a, const struct object_entry b)
225	{
226	if (a->type < b->type)
227	return -1;
228	if (a->type > b->type)
229	return 1;
27225f2e LT	230	if (a->hash < b->hash)
	231	return -1;
	232	if (a->hash > b->hash)
	233	return 1;
c323ac7d LT	234	if (a->size < b->size)
	235	return -1;
	236	if (a->size > b->size)
	237	return 1;
	238	return a < b ? -1 : (a > b);
	239	}
	240
	241	struct unpacked {
	242	struct object_entry *entry;
	243	void *data;
	244	};
	245
	246	/*
521a4f4c LT	247	* We search for deltas _backwards_ in a list sorted by type and
	248	* by size, so that we see progressively smaller and smaller files.
	249	* That's because we prefer deltas to be from the bigger file
	250	* to the smaller - deletes are potentially cheaper, but perhaps
	251	* more importantly, the bigger file is likely the more recent
	252	* one.
c323ac7d	253	*/
d116a45a	254	static int try_delta(struct unpacked cur, struct unpacked old, unsigned max_depth)
c323ac7d LT	255	{
	256	struct object_entry *cur_entry = cur->entry;
	257	struct object_entry *old_entry = old->entry;
521a4f4c	258	unsigned long size, oldsize, delta_size, sizediff;
75c42d8c	259	long max_size;
c323ac7d LT	260	void *delta_buf;
	261
	262	/* Don't bother doing diffs between different types */
	263	if (cur_entry->type != old_entry->type)
	264	return -1;
	265
c323ac7d	266	size = cur_entry->size;
75c42d8c LT	267	if (size < 50)
75c42d8c LT	268	return -1;
c323ac7d	269	oldsize = old_entry->size;
521a4f4c LT	270	sizediff = oldsize > size ? oldsize - size : size - oldsize;
521a4f4c LT	271	if (sizediff > size / 8)
c323ac7d	272	return -1;
d116a45a LT	273	if (old_entry->depth >= max_depth)
d116a45a LT	274	return 0;
c323ac7d LT	275
	276	/*
	277	* NOTE!
	278	*
	279	* We always delta from the bigger to the smaller, since that's
	280	* more space-efficient (deletes don't have to say _what_ they
	281	* delete).
	282	*/
75c42d8c LT	283	max_size = size / 2 - 20;
	284	if (cur_entry->delta)
	285	max_size = cur_entry->delta_size-1;
27225f2e LT	286	if (sizediff >= max_size)
27225f2e LT	287	return -1;
8ee378a0 JH	288	delta_buf = diff_delta(old->data, oldsize,
8ee378a0 JH	289	cur->data, size, &delta_size, max_size);
c323ac7d	290	if (!delta_buf)
75c42d8c LT	291	return 0;
	292	cur_entry->delta = old_entry;
	293	cur_entry->delta_size = delta_size;
d116a45a	294	cur_entry->depth = old_entry->depth + 1;
c323ac7d	295	free(delta_buf);
eb41ab11	296	return 0;
c323ac7d LT	297	}
c323ac7d LT	298
d116a45a	299	static void find_deltas(struct object_entry **list, int window, int depth)
c323ac7d	300	{
521a4f4c	301	int i, idx;
c323ac7d LT	302	unsigned int array_size = window * sizeof(struct unpacked);
	303	struct unpacked *array = xmalloc(array_size);
	304
	305	memset(array, 0, array_size);
521a4f4c LT	306	i = nr_objects;
	307	idx = 0;
	308	while (--i >= 0) {
c323ac7d LT	309	struct object_entry *entry = list[i];
	310	struct unpacked *n = array + idx;
	311	unsigned long size;
	312	char type[10];
	313	int j;
	314
	315	free(n->data);
	316	n->entry = entry;
	317	n->data = read_sha1_file(entry->sha1, type, &size);
	318	if (size != entry->size)
	319	die("object %s inconsistent object length (%lu vs %lu)", sha1_to_hex(entry->sha1), size, entry->size);
78817c15 LT	320	j = window;
	321	while (--j > 0) {
	322	unsigned int other_idx = idx + j;
c323ac7d	323	struct unpacked *m;
78817c15 LT	324	if (other_idx >= window)
78817c15 LT	325	other_idx -= window;
c323ac7d LT	326	m = array + other_idx;
	327	if (!m->entry)
	328	break;
d116a45a	329	if (try_delta(n, m, depth) < 0)
c323ac7d LT	330	break;
c323ac7d LT	331	}
521a4f4c LT	332	idx++;
	333	if (idx >= window)
	334	idx = 0;
c323ac7d LT	335	}
	336	}
	337
	338	int main(int argc, char **argv)
	339	{
27225f2e	340	char line[PATH_MAX + 20];
d116a45a	341	int window = 10, depth = 10;
c323ac7d LT	342	int i;
	343
	344	for (i = 1; i < argc; i++) {
	345	const char *arg = argv[i];
	346
	347	if (*arg == '-') {
	348	if (!strncmp("--window=", arg, 9)) {
	349	char *end;
f846bbff	350	window = strtoul(arg+9, &end, 0);
c323ac7d LT	351	if (!arg[9] \|\| *end)
	352	usage(pack_usage);
	353	continue;
	354	}
d116a45a LT	355	if (!strncmp("--depth=", arg, 8)) {
	356	char *end;
	357	depth = strtoul(arg+8, &end, 0);
	358	if (!arg[8] \|\| *end)
	359	usage(pack_usage);
	360	continue;
	361	}
c323ac7d LT	362	usage(pack_usage);
	363	}
	364	if (base_name)
	365	usage(pack_usage);
	366	base_name = arg;
	367	}
	368
	369	if (!base_name)
	370	usage(pack_usage);
	371
	372	while (fgets(line, sizeof(line), stdin) != NULL) {
27225f2e LT	373	unsigned int hash;
27225f2e LT	374	char *p;
c323ac7d	375	unsigned char sha1[20];
27225f2e	376
c323ac7d LT	377	if (get_sha1_hex(line, sha1))
c323ac7d LT	378	die("expected sha1, got garbage");
27225f2e LT	379	hash = 0;
	380	p = line+40;
	381	while (*p) {
	382	unsigned char c = *p++;
	383	if (isspace(c))
	384	continue;
	385	hash = hash * 11 + c;
	386	}
	387	add_object_entry(sha1, hash);
c323ac7d LT	388	}
	389	get_object_details();
	390
	391	printf("Packing %d objects\n", nr_objects);
	392
	393	sorted_by_sha = create_sorted_list(sha1_sort);
	394	sorted_by_type = create_sorted_list(type_size_sort);
d116a45a LT	395	if (window && depth)
d116a45a LT	396	find_deltas(sorted_by_type, window+1, depth);
c323ac7d LT	397
	398	write_pack_file();
	399	write_index_file();
	400	return 0;
	401	}