[thirdparty/git.git] / builtin / cat-file.c

/*
 * GIT - The information manager from hell
 *
 * Copyright (C) Linus Torvalds, 2005
 */
#include "cache.h"
#include "exec_cmd.h"
#include "tag.h"
#include "tree.h"
#include "builtin.h"
#include "parse-options.h"
#include "diff.h"
#include "userdiff.h"
#include "streaming.h"

static int cat_one_file(int opt, const char *exp_type, const char *obj_name)
{
	unsigned char sha1[20];
	enum object_type type;
	char *buf;
	unsigned long size;
	struct object_context obj_context;

	if (get_sha1_with_context(obj_name, 0, sha1, &obj_context))
		die("Not a valid object name %s", obj_name);

	buf = NULL;
	switch (opt) {
	case 't':
		type = sha1_object_info(sha1, NULL);
		if (type > 0) {
			printf("%s\n", typename(type));
			return 0;
		}
		break;

	case 's':
		type = sha1_object_info(sha1, &size);
		if (type > 0) {
			printf("%lu\n", size);
			return 0;
		}
		break;

	case 'e':
		return !has_sha1_file(sha1);

	case 'c':
		if (!obj_context.path[0])
			die("git cat-file --textconv %s: <object> must be <sha1:path>",
			    obj_name);

		if (textconv_object(obj_context.path, obj_context.mode, sha1, 1, &buf, &size))
			break;

	case 'p':
		type = sha1_object_info(sha1, NULL);
		if (type < 0)
			die("Not a valid object name %s", obj_name);

		/* custom pretty-print here */
		if (type == OBJ_TREE) {
			const char *ls_args[3] = { NULL };
			ls_args[0] =  "ls-tree";
			ls_args[1] =  obj_name;
			return cmd_ls_tree(2, ls_args, NULL);
		}

		if (type == OBJ_BLOB)
			return stream_blob_to_fd(1, sha1, NULL, 0);
		buf = read_sha1_file(sha1, &type, &size);
		if (!buf)
			die("Cannot read object %s", obj_name);

		/* otherwise just spit out the data */
		break;

	case 0:
		if (type_from_string(exp_type) == OBJ_BLOB) {
			unsigned char blob_sha1[20];
			if (sha1_object_info(sha1, NULL) == OBJ_TAG) {
				enum object_type type;
				unsigned long size;
				char *buffer = read_sha1_file(sha1, &type, &size);
				if (memcmp(buffer, "object ", 7) ||
				    get_sha1_hex(buffer + 7, blob_sha1))
					die("%s not a valid tag", sha1_to_hex(sha1));
				free(buffer);
			} else
				hashcpy(blob_sha1, sha1);

			if (sha1_object_info(blob_sha1, NULL) == OBJ_BLOB)
				return stream_blob_to_fd(1, blob_sha1, NULL, 0);
			/*
			 * we attempted to dereference a tag to a blob
			 * and failed; there may be new dereference
			 * mechanisms this code is not aware of.
			 * fall-back to the usual case.
			 */
		}
		buf = read_object_with_reference(sha1, exp_type, &size, NULL);
		break;

	default:
		die("git cat-file: unknown option: %s", exp_type);
	}

	if (!buf)
		die("git cat-file %s: bad file", obj_name);

	write_or_die(1, buf, size);
	return 0;
}

struct expand_data {
	unsigned char sha1[20];
	enum object_type type;
	unsigned long size;
	unsigned long disk_size;
	const char *rest;

	/*
	 * If mark_query is true, we do not expand anything, but rather
	 * just mark the object_info with items we wish to query.
	 */
	int mark_query;

	/*
	 * Whether to split the input on whitespace before feeding it to
	 * get_sha1; this is decided during the mark_query phase based on
	 * whether we have a %(rest) token in our format.
	 */
	int split_on_whitespace;

	/*
	 * After a mark_query run, this object_info is set up to be
	 * passed to sha1_object_info_extended. It will point to the data
	 * elements above, so you can retrieve the response from there.
	 */
	struct object_info info;
};

static int is_atom(const char *atom, const char *s, int slen)
{
	int alen = strlen(atom);
	return alen == slen && !memcmp(atom, s, alen);
}

static void expand_atom(struct strbuf *sb, const char *atom, int len,
			void *vdata)
{
	struct expand_data *data = vdata;

	if (is_atom("objectname", atom, len)) {
		if (!data->mark_query)
			strbuf_addstr(sb, sha1_to_hex(data->sha1));
	} else if (is_atom("objecttype", atom, len)) {
		if (data->mark_query)
			data->info.typep = &data->type;
		else
			strbuf_addstr(sb, typename(data->type));
	} else if (is_atom("objectsize", atom, len)) {
		if (data->mark_query)
			data->info.sizep = &data->size;
		else
			strbuf_addf(sb, "%lu", data->size);
	} else if (is_atom("objectsize:disk", atom, len)) {
		if (data->mark_query)
			data->info.disk_sizep = &data->disk_size;
		else
			strbuf_addf(sb, "%lu", data->disk_size);
	} else if (is_atom("rest", atom, len)) {
		if (data->mark_query)
			data->split_on_whitespace = 1;
		else if (data->rest)
			strbuf_addstr(sb, data->rest);
	} else
		die("unknown format element: %.*s", len, atom);
}

static size_t expand_format(struct strbuf *sb, const char *start, void *data)
{
	const char *end;

	if (*start != '(')
		return 0;
	end = strchr(start + 1, ')');
	if (!end)
		die("format element '%s' does not end in ')'", start);

	expand_atom(sb, start + 1, end - start - 1, data);

	return end - start + 1;
}

static void print_object_or_die(int fd, const unsigned char *sha1,
				enum object_type type, unsigned long size)
{
	if (type == OBJ_BLOB) {
		if (stream_blob_to_fd(fd, sha1, NULL, 0) < 0)
			die("unable to stream %s to stdout", sha1_to_hex(sha1));
	}
	else {
		enum object_type rtype;
		unsigned long rsize;
		void *contents;

		contents = read_sha1_file(sha1, &rtype, &rsize);
		if (!contents)
			die("object %s disappeared", sha1_to_hex(sha1));
		if (rtype != type)
			die("object %s changed type!?", sha1_to_hex(sha1));
		if (rsize != size)
			die("object %s change size!?", sha1_to_hex(sha1));

		write_or_die(fd, contents, size);
		free(contents);
	}
}

struct batch_options {
	int enabled;
	int print_contents;
	const char *format;
};

static int batch_one_object(const char *obj_name, struct batch_options *opt,
			    struct expand_data *data)
{
	struct strbuf buf = STRBUF_INIT;

	if (!obj_name)
	   return 1;

	if (get_sha1(obj_name, data->sha1)) {
		printf("%s missing\n", obj_name);
		fflush(stdout);
		return 0;
	}

	if (sha1_object_info_extended(data->sha1, &data->info) < 0) {
		printf("%s missing\n", obj_name);
		fflush(stdout);
		return 0;
	}

	strbuf_expand(&buf, opt->format, expand_format, data);
	strbuf_addch(&buf, '\n');
	write_or_die(1, buf.buf, buf.len);
	strbuf_release(&buf);

	if (opt->print_contents) {
		print_object_or_die(1, data->sha1, data->type, data->size);
		write_or_die(1, "\n", 1);
	}
	return 0;
}

static int batch_objects(struct batch_options *opt)
{
	struct strbuf buf = STRBUF_INIT;
	struct expand_data data;

	if (!opt->format)
		opt->format = "%(objectname) %(objecttype) %(objectsize)";

	/*
	 * Expand once with our special mark_query flag, which will prime the
	 * object_info to be handed to sha1_object_info_extended for each
	 * object.
	 */
	memset(&data, 0, sizeof(data));
	data.mark_query = 1;
	strbuf_expand(&buf, opt->format, expand_format, &data);
	data.mark_query = 0;

	/*
	 * We are going to call get_sha1 on a potentially very large number of
	 * objects. In most large cases, these will be actual object sha1s. The
	 * cost to double-check that each one is not also a ref (just so we can
	 * warn) ends up dwarfing the actual cost of the object lookups
	 * themselves. We can work around it by just turning off the warning.
	 */
	warn_on_object_refname_ambiguity = 0;

	while (strbuf_getline(&buf, stdin, '\n') != EOF) {
		int error;

		if (data.split_on_whitespace) {
			/*
			 * Split at first whitespace, tying off the beginning
			 * of the string and saving the remainder (or NULL) in
			 * data.rest.
			 */
			char *p = strpbrk(buf.buf, " \t");
			if (p) {
				while (*p && strchr(" \t", *p))
					*p++ = '\0';
			}
			data.rest = p;
		}

		error = batch_one_object(buf.buf, opt, &data);
		if (error)
			return error;
	}

	return 0;
}

static const char * const cat_file_usage[] = {
	N_("git cat-file (-t|-s|-e|-p|<type>|--textconv) <object>"),
	N_("git cat-file (--batch|--batch-check) < <list_of_objects>"),
	NULL
};

static int git_cat_file_config(const char *var, const char *value, void *cb)
{
	if (userdiff_config(var, value) < 0)
		return -1;

	return git_default_config(var, value, cb);
}

static int batch_option_callback(const struct option *opt,
				 const char *arg,
				 int unset)
{
	struct batch_options *bo = opt->value;

	if (unset) {
		memset(bo, 0, sizeof(*bo));
		return 0;
	}

	bo->enabled = 1;
	bo->print_contents = !strcmp(opt->long_name, "batch");
	bo->format = arg;

	return 0;
}

int cmd_cat_file(int argc, const char **argv, const char *prefix)
{
	int opt = 0;
	const char *exp_type = NULL, *obj_name = NULL;
	struct batch_options batch = {0};

	const struct option options[] = {
		OPT_GROUP(N_("<type> can be one of: blob, tree, commit, tag")),
		OPT_SET_INT('t', NULL, &opt, N_("show object type"), 't'),
		OPT_SET_INT('s', NULL, &opt, N_("show object size"), 's'),
		OPT_SET_INT('e', NULL, &opt,
			    N_("exit with zero when there's no error"), 'e'),
		OPT_SET_INT('p', NULL, &opt, N_("pretty-print object's content"), 'p'),
		OPT_SET_INT(0, "textconv", &opt,
			    N_("for blob objects, run textconv on object's content"), 'c'),
		{ OPTION_CALLBACK, 0, "batch", &batch, "format",
			N_("show info and content of objects fed from the standard input"),
			PARSE_OPT_OPTARG, batch_option_callback },
		{ OPTION_CALLBACK, 0, "batch-check", &batch, "format",
			N_("show info about objects fed from the standard input"),
			PARSE_OPT_OPTARG, batch_option_callback },
		OPT_END()
	};

	git_config(git_cat_file_config, NULL);

	if (argc != 3 && argc != 2)
		usage_with_options(cat_file_usage, options);

	argc = parse_options(argc, argv, prefix, options, cat_file_usage, 0);

	if (opt) {
		if (argc == 1)
			obj_name = argv[0];
		else
			usage_with_options(cat_file_usage, options);
	}
	if (!opt && !batch.enabled) {
		if (argc == 2) {
			exp_type = argv[0];
			obj_name = argv[1];
		} else
			usage_with_options(cat_file_usage, options);
	}
	if (batch.enabled && (opt || argc)) {
		usage_with_options(cat_file_usage, options);
	}

	if (batch.enabled)
		return batch_objects(&batch);

	return cat_one_file(opt, exp_type, obj_name);
}
Commit	Line	Data
8bc9a0c7 LT	1	/*
	2	* GIT - The information manager from hell
	3	*
	4	* Copyright (C) Linus Torvalds, 2005
	5	*/
e83c5163	6	#include "cache.h"
a0f15fa5	7	#include "exec_cmd.h"
8e440259 PE	8	#include "tag.h"
8e440259 PE	9	#include "tree.h"
f81daefe	10	#include "builtin.h"
15d8e565	11	#include "parse-options.h"
e5fba602 CP	12	#include "diff.h"
e5fba602 CP	13	#include "userdiff.h"
00c8fd49	14	#include "streaming.h"
15d8e565	15
9cf71b17	16	static int cat_one_file(int opt, const char exp_type, const char obj_name)
e83c5163 LT	17	{
e83c5163 LT	18	unsigned char sha1[20];
21666f1a	19	enum object_type type;
e5fba602	20	char *buf;
e83c5163	21	unsigned long size;
e5fba602	22	struct object_context obj_context;
2b6854c8	23
33bd598c	24	if (get_sha1_with_context(obj_name, 0, sha1, &obj_context))
2b6854c8	25	die("Not a valid object name %s", obj_name);
7950571a	26
7950571a PA	27	buf = NULL;
	28	switch (opt) {
	29	case 't':
21666f1a NP	30	type = sha1_object_info(sha1, NULL);
	31	if (type > 0) {
	32	printf("%s\n", typename(type));
f2a06330	33	return 0;
11e7d5c5	34	}
7950571a PA	35	break;
	36
	37	case 's':
21666f1a NP	38	type = sha1_object_info(sha1, &size);
21666f1a NP	39	if (type > 0) {
7950571a PA	40	printf("%lu\n", size);
	41	return 0;
	42	}
	43	break;
	44
	45	case 'e':
	46	return !has_sha1_file(sha1);
	47
3ac21617 MG	48	case 'c':
	49	if (!obj_context.path[0])
	50	die("git cat-file --textconv %s: <object> must be <sha1:path>",
	51	obj_name);
	52
	53	if (textconv_object(obj_context.path, obj_context.mode, sha1, 1, &buf, &size))
	54	break;
	55
a0f15fa5	56	case 'p':
21666f1a NP	57	type = sha1_object_info(sha1, NULL);
21666f1a NP	58	if (type < 0)
2b6854c8	59	die("Not a valid object name %s", obj_name);
a0f15fa5 JH	60
a0f15fa5 JH	61	/* custom pretty-print here */
2b6854c8	62	if (type == OBJ_TREE) {
66dbfd55 GV	63	const char *ls_args[3] = { NULL };
	64	ls_args[0] = "ls-tree";
	65	ls_args[1] = obj_name;
2b6854c8 SP	66	return cmd_ls_tree(2, ls_args, NULL);
2b6854c8 SP	67	}
a0f15fa5	68
00c8fd49 NTND	69	if (type == OBJ_BLOB)
00c8fd49 NTND	70	return stream_blob_to_fd(1, sha1, NULL, 0);
21666f1a	71	buf = read_sha1_file(sha1, &type, &size);
a0f15fa5	72	if (!buf)
2b6854c8	73	die("Cannot read object %s", obj_name);
a0f15fa5 JH	74
	75	/* otherwise just spit out the data */
	76	break;
e5fba602	77
7950571a	78	case 0:
00c8fd49 NTND	79	if (type_from_string(exp_type) == OBJ_BLOB) {
	80	unsigned char blob_sha1[20];
	81	if (sha1_object_info(sha1, NULL) == OBJ_TAG) {
	82	enum object_type type;
	83	unsigned long size;
	84	char *buffer = read_sha1_file(sha1, &type, &size);
	85	if (memcmp(buffer, "object ", 7) \|\|
	86	get_sha1_hex(buffer + 7, blob_sha1))
	87	die("%s not a valid tag", sha1_to_hex(sha1));
	88	free(buffer);
	89	} else
	90	hashcpy(blob_sha1, sha1);
	91
	92	if (sha1_object_info(blob_sha1, NULL) == OBJ_BLOB)
	93	return stream_blob_to_fd(1, blob_sha1, NULL, 0);
	94	/*
	95	* we attempted to dereference a tag to a blob
	96	* and failed; there may be new dereference
	97	* mechanisms this code is not aware of.
	98	* fall-back to the usual case.
	99	*/
	100	}
2b6854c8	101	buf = read_object_with_reference(sha1, exp_type, &size, NULL);
7950571a PA	102	break;
	103
	104	default:
d7530708	105	die("git cat-file: unknown option: %s", exp_type);
bf0c6e83 LT	106	}
bf0c6e83 LT	107
11e7d5c5	108	if (!buf)
34baebce	109	die("git cat-file %s: bad file", obj_name);
11e7d5c5	110
7230e6d0	111	write_or_die(1, buf, size);
bf0c6e83	112	return 0;
e83c5163	113	}
9cf71b17	114
93d2a607 JK	115	struct expand_data {
	116	unsigned char sha1[20];
	117	enum object_type type;
	118	unsigned long size;
a4ac1061	119	unsigned long disk_size;
97be0407	120	const char *rest;
93d2a607 JK	121
	122	/*
	123	* If mark_query is true, we do not expand anything, but rather
	124	* just mark the object_info with items we wish to query.
	125	*/
	126	int mark_query;
	127
97be0407 JK	128	/*
	129	* Whether to split the input on whitespace before feeding it to
	130	* get_sha1; this is decided during the mark_query phase based on
	131	* whether we have a %(rest) token in our format.
	132	*/
	133	int split_on_whitespace;
	134
93d2a607 JK	135	/*
	136	* After a mark_query run, this object_info is set up to be
	137	* passed to sha1_object_info_extended. It will point to the data
	138	* elements above, so you can retrieve the response from there.
	139	*/
	140	struct object_info info;
	141	};
	142
	143	static int is_atom(const char atom, const char s, int slen)
	144	{
	145	int alen = strlen(atom);
	146	return alen == slen && !memcmp(atom, s, alen);
	147	}
	148
	149	static void expand_atom(struct strbuf sb, const char atom, int len,
	150	void *vdata)
	151	{
	152	struct expand_data *data = vdata;
	153
	154	if (is_atom("objectname", atom, len)) {
	155	if (!data->mark_query)
	156	strbuf_addstr(sb, sha1_to_hex(data->sha1));
	157	} else if (is_atom("objecttype", atom, len)) {
5b086407 JK	158	if (data->mark_query)
	159	data->info.typep = &data->type;
	160	else
93d2a607 JK	161	strbuf_addstr(sb, typename(data->type));
	162	} else if (is_atom("objectsize", atom, len)) {
	163	if (data->mark_query)
	164	data->info.sizep = &data->size;
	165	else
	166	strbuf_addf(sb, "%lu", data->size);
a4ac1061 JK	167	} else if (is_atom("objectsize:disk", atom, len)) {
	168	if (data->mark_query)
	169	data->info.disk_sizep = &data->disk_size;
	170	else
	171	strbuf_addf(sb, "%lu", data->disk_size);
97be0407 JK	172	} else if (is_atom("rest", atom, len)) {
	173	if (data->mark_query)
	174	data->split_on_whitespace = 1;
	175	else if (data->rest)
	176	strbuf_addstr(sb, data->rest);
93d2a607 JK	177	} else
	178	die("unknown format element: %.*s", len, atom);
	179	}
	180
	181	static size_t expand_format(struct strbuf sb, const char start, void *data)
	182	{
	183	const char *end;
	184
	185	if (*start != '(')
	186	return 0;
	187	end = strchr(start + 1, ')');
	188	if (!end)
	189	die("format element '%s' does not end in ')'", start);
	190
	191	expand_atom(sb, start + 1, end - start - 1, data);
	192
	193	return end - start + 1;
	194	}
	195
98e2092b JK	196	static void print_object_or_die(int fd, const unsigned char *sha1,
	197	enum object_type type, unsigned long size)
	198	{
	199	if (type == OBJ_BLOB) {
	200	if (stream_blob_to_fd(fd, sha1, NULL, 0) < 0)
	201	die("unable to stream %s to stdout", sha1_to_hex(sha1));
	202	}
	203	else {
	204	enum object_type rtype;
	205	unsigned long rsize;
	206	void *contents;
	207
	208	contents = read_sha1_file(sha1, &rtype, &rsize);
	209	if (!contents)
	210	die("object %s disappeared", sha1_to_hex(sha1));
	211	if (rtype != type)
	212	die("object %s changed type!?", sha1_to_hex(sha1));
	213	if (rsize != size)
	214	die("object %s change size!?", sha1_to_hex(sha1));
	215
	216	write_or_die(fd, contents, size);
	217	free(contents);
	218	}
	219	}
	220
b71bd480 JK	221	struct batch_options {
	222	int enabled;
	223	int print_contents;
93d2a607	224	const char *format;
b71bd480 JK	225	};
b71bd480 JK	226
93d2a607 JK	227	static int batch_one_object(const char obj_name, struct batch_options opt,
93d2a607 JK	228	struct expand_data *data)
05d5667f	229	{
93d2a607	230	struct strbuf buf = STRBUF_INIT;
05d5667f AR	231
	232	if (!obj_name)
	233	return 1;
	234
93d2a607	235	if (get_sha1(obj_name, data->sha1)) {
05d5667f	236	printf("%s missing\n", obj_name);
422b2063	237	fflush(stdout);
05d5667f AR	238	return 0;
	239	}
	240
5b086407	241	if (sha1_object_info_extended(data->sha1, &data->info) < 0) {
3c076dbe LW	242	printf("%s missing\n", obj_name);
	243	fflush(stdout);
	244	return 0;
	245	}
05d5667f	246
93d2a607 JK	247	strbuf_expand(&buf, opt->format, expand_format, data);
	248	strbuf_addch(&buf, '\n');
	249	write_or_die(1, buf.buf, buf.len);
	250	strbuf_release(&buf);
a8128ed6	251
b71bd480	252	if (opt->print_contents) {
93d2a607	253	print_object_or_die(1, data->sha1, data->type, data->size);
98e2092b	254	write_or_die(1, "\n", 1);
a8128ed6	255	}
05d5667f AR	256	return 0;
	257	}
	258
b71bd480	259	static int batch_objects(struct batch_options *opt)
05d5667f	260	{
f285a2d7	261	struct strbuf buf = STRBUF_INIT;
93d2a607 JK	262	struct expand_data data;
	263
	264	if (!opt->format)
	265	opt->format = "%(objectname) %(objecttype) %(objectsize)";
	266
	267	/*
	268	* Expand once with our special mark_query flag, which will prime the
	269	* object_info to be handed to sha1_object_info_extended for each
	270	* object.
	271	*/
	272	memset(&data, 0, sizeof(data));
	273	data.mark_query = 1;
	274	strbuf_expand(&buf, opt->format, expand_format, &data);
	275	data.mark_query = 0;
05d5667f	276
25fba78d JK	277	/*
	278	* We are going to call get_sha1 on a potentially very large number of
	279	* objects. In most large cases, these will be actual object sha1s. The
	280	* cost to double-check that each one is not also a ref (just so we can
	281	* warn) ends up dwarfing the actual cost of the object lookups
	282	* themselves. We can work around it by just turning off the warning.
	283	*/
	284	warn_on_object_refname_ambiguity = 0;
	285
05d5667f	286	while (strbuf_getline(&buf, stdin, '\n') != EOF) {
97be0407 JK	287	int error;
	288
	289	if (data.split_on_whitespace) {
	290	/*
	291	* Split at first whitespace, tying off the beginning
	292	* of the string and saving the remainder (or NULL) in
	293	* data.rest.
	294	*/
	295	char *p = strpbrk(buf.buf, " \t");
	296	if (p) {
	297	while (p && strchr(" \t", p))
	298	*p++ = '\0';
	299	}
	300	data.rest = p;
	301	}
	302
	303	error = batch_one_object(buf.buf, opt, &data);
05d5667f AR	304	if (error)
	305	return error;
	306	}
	307
	308	return 0;
	309	}
	310
15d8e565	311	static const char * const cat_file_usage[] = {
d68faec7 NTND	312	N_("git cat-file (-t\|-s\|-e\|-p\|<type>\|--textconv) <object>"),
d68faec7 NTND	313	N_("git cat-file (--batch\|--batch-check) < <list_of_objects>"),
15d8e565 MB	314	NULL
15d8e565 MB	315	};
4814dbe8	316
e5fba602 CP	317	static int git_cat_file_config(const char var, const char value, void *cb)
e5fba602 CP	318	{
6680a087	319	if (userdiff_config(var, value) < 0)
e5fba602	320	return -1;
e5fba602 CP	321
	322	return git_default_config(var, value, cb);
	323	}
	324
b71bd480 JK	325	static int batch_option_callback(const struct option *opt,
	326	const char *arg,
	327	int unset)
	328	{
	329	struct batch_options *bo = opt->value;
	330
	331	if (unset) {
	332	memset(bo, 0, sizeof(*bo));
	333	return 0;
	334	}
	335
	336	bo->enabled = 1;
	337	bo->print_contents = !strcmp(opt->long_name, "batch");
93d2a607	338	bo->format = arg;
b71bd480 JK	339
	340	return 0;
	341	}
	342
9cf71b17 AR	343	int cmd_cat_file(int argc, const char *argv, const char prefix)
9cf71b17 AR	344	{
b71bd480	345	int opt = 0;
4814dbe8	346	const char exp_type = NULL, obj_name = NULL;
b71bd480	347	struct batch_options batch = {0};
9cf71b17	348
15d8e565	349	const struct option options[] = {
d68faec7 NTND	350	OPT_GROUP(N_("<type> can be one of: blob, tree, commit, tag")),
	351	OPT_SET_INT('t', NULL, &opt, N_("show object type"), 't'),
	352	OPT_SET_INT('s', NULL, &opt, N_("show object size"), 's'),
15d8e565	353	OPT_SET_INT('e', NULL, &opt,
d68faec7 NTND	354	N_("exit with zero when there's no error"), 'e'),
d68faec7 NTND	355	OPT_SET_INT('p', NULL, &opt, N_("pretty-print object's content"), 'p'),
e5fba602	356	OPT_SET_INT(0, "textconv", &opt,
d68faec7	357	N_("for blob objects, run textconv on object's content"), 'c'),
93d2a607	358	{ OPTION_CALLBACK, 0, "batch", &batch, "format",
b71bd480	359	N_("show info and content of objects fed from the standard input"),
93d2a607 JK	360	PARSE_OPT_OPTARG, batch_option_callback },
93d2a607 JK	361	{ OPTION_CALLBACK, 0, "batch-check", &batch, "format",
b71bd480	362	N_("show info about objects fed from the standard input"),
93d2a607	363	PARSE_OPT_OPTARG, batch_option_callback },
15d8e565 MB	364	OPT_END()
15d8e565 MB	365	};
a8128ed6	366
e5fba602	367	git_config(git_cat_file_config, NULL);
4814dbe8	368
15d8e565 MB	369	if (argc != 3 && argc != 2)
15d8e565 MB	370	usage_with_options(cat_file_usage, options);
4814dbe8	371
37782920	372	argc = parse_options(argc, argv, prefix, options, cat_file_usage, 0);
05d5667f	373
15d8e565 MB	374	if (opt) {
	375	if (argc == 1)
	376	obj_name = argv[0];
	377	else
	378	usage_with_options(cat_file_usage, options);
	379	}
b71bd480	380	if (!opt && !batch.enabled) {
15d8e565 MB	381	if (argc == 2) {
	382	exp_type = argv[0];
	383	obj_name = argv[1];
	384	} else
	385	usage_with_options(cat_file_usage, options);
	386	}
b71bd480	387	if (batch.enabled && (opt \|\| argc)) {
15d8e565	388	usage_with_options(cat_file_usage, options);
9cf71b17 AR	389	}
9cf71b17 AR	390
b71bd480 JK	391	if (batch.enabled)
b71bd480 JK	392	return batch_objects(&batch);
05d5667f	393
9cf71b17 AR	394	return cat_one_file(opt, exp_type, obj_name);
9cf71b17 AR	395	}