2 * GIT - The information manager from hell
4 * Copyright (C) Linus Torvalds, 2005
11 #include "parse-options.h"
14 #include "streaming.h"
16 static int cat_one_file(int opt
, const char *exp_type
, const char *obj_name
)
18 unsigned char sha1
[20];
19 enum object_type type
;
22 struct object_context obj_context
;
24 if (get_sha1_with_context(obj_name
, 0, sha1
, &obj_context
))
25 die("Not a valid object name %s", obj_name
);
30 type
= sha1_object_info(sha1
, NULL
);
32 printf("%s\n", typename(type
));
38 type
= sha1_object_info(sha1
, &size
);
40 printf("%lu\n", size
);
46 return !has_sha1_file(sha1
);
49 if (!obj_context
.path
[0])
50 die("git cat-file --textconv %s: <object> must be <sha1:path>",
53 if (textconv_object(obj_context
.path
, obj_context
.mode
, sha1
, 1, &buf
, &size
))
57 type
= sha1_object_info(sha1
, NULL
);
59 die("Not a valid object name %s", obj_name
);
61 /* custom pretty-print here */
62 if (type
== OBJ_TREE
) {
63 const char *ls_args
[3] = { NULL
};
64 ls_args
[0] = "ls-tree";
65 ls_args
[1] = obj_name
;
66 return cmd_ls_tree(2, ls_args
, NULL
);
70 return stream_blob_to_fd(1, sha1
, NULL
, 0);
71 buf
= read_sha1_file(sha1
, &type
, &size
);
73 die("Cannot read object %s", obj_name
);
75 /* otherwise just spit out the data */
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
;
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
));
90 hashcpy(blob_sha1
, sha1
);
92 if (sha1_object_info(blob_sha1
, NULL
) == OBJ_BLOB
)
93 return stream_blob_to_fd(1, blob_sha1
, NULL
, 0);
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.
101 buf
= read_object_with_reference(sha1
, exp_type
, &size
, NULL
);
105 die("git cat-file: unknown option: %s", exp_type
);
109 die("git cat-file %s: bad file", obj_name
);
111 write_or_die(1, buf
, size
);
116 unsigned char sha1
[20];
117 enum object_type type
;
119 unsigned long disk_size
;
121 unsigned char delta_base_sha1
[20];
124 * If mark_query is true, we do not expand anything, but rather
125 * just mark the object_info with items we wish to query.
130 * Whether to split the input on whitespace before feeding it to
131 * get_sha1; this is decided during the mark_query phase based on
132 * whether we have a %(rest) token in our format.
134 int split_on_whitespace
;
137 * After a mark_query run, this object_info is set up to be
138 * passed to sha1_object_info_extended. It will point to the data
139 * elements above, so you can retrieve the response from there.
141 struct object_info info
;
144 static int is_atom(const char *atom
, const char *s
, int slen
)
146 int alen
= strlen(atom
);
147 return alen
== slen
&& !memcmp(atom
, s
, alen
);
150 static void expand_atom(struct strbuf
*sb
, const char *atom
, int len
,
153 struct expand_data
*data
= vdata
;
155 if (is_atom("objectname", atom
, len
)) {
156 if (!data
->mark_query
)
157 strbuf_addstr(sb
, sha1_to_hex(data
->sha1
));
158 } else if (is_atom("objecttype", atom
, len
)) {
159 if (data
->mark_query
)
160 data
->info
.typep
= &data
->type
;
162 strbuf_addstr(sb
, typename(data
->type
));
163 } else if (is_atom("objectsize", atom
, len
)) {
164 if (data
->mark_query
)
165 data
->info
.sizep
= &data
->size
;
167 strbuf_addf(sb
, "%lu", data
->size
);
168 } else if (is_atom("objectsize:disk", atom
, len
)) {
169 if (data
->mark_query
)
170 data
->info
.disk_sizep
= &data
->disk_size
;
172 strbuf_addf(sb
, "%lu", data
->disk_size
);
173 } else if (is_atom("rest", atom
, len
)) {
174 if (data
->mark_query
)
175 data
->split_on_whitespace
= 1;
177 strbuf_addstr(sb
, data
->rest
);
178 } else if (is_atom("deltabase", atom
, len
)) {
179 if (data
->mark_query
)
180 data
->info
.delta_base_sha1
= data
->delta_base_sha1
;
182 strbuf_addstr(sb
, sha1_to_hex(data
->delta_base_sha1
));
184 die("unknown format element: %.*s", len
, atom
);
187 static size_t expand_format(struct strbuf
*sb
, const char *start
, void *data
)
193 end
= strchr(start
+ 1, ')');
195 die("format element '%s' does not end in ')'", start
);
197 expand_atom(sb
, start
+ 1, end
- start
- 1, data
);
199 return end
- start
+ 1;
202 static void print_object_or_die(int fd
, struct expand_data
*data
)
204 const unsigned char *sha1
= data
->sha1
;
206 assert(data
->info
.typep
);
208 if (data
->type
== OBJ_BLOB
) {
209 if (stream_blob_to_fd(fd
, sha1
, NULL
, 0) < 0)
210 die("unable to stream %s to stdout", sha1_to_hex(sha1
));
213 enum object_type type
;
217 contents
= read_sha1_file(sha1
, &type
, &size
);
219 die("object %s disappeared", sha1_to_hex(sha1
));
220 if (type
!= data
->type
)
221 die("object %s changed type!?", sha1_to_hex(sha1
));
222 if (data
->info
.sizep
&& size
!= data
->size
)
223 die("object %s changed size!?", sha1_to_hex(sha1
));
225 write_or_die(fd
, contents
, size
);
230 struct batch_options
{
236 static int batch_one_object(const char *obj_name
, struct batch_options
*opt
,
237 struct expand_data
*data
)
239 struct strbuf buf
= STRBUF_INIT
;
244 if (get_sha1(obj_name
, data
->sha1
)) {
245 printf("%s missing\n", obj_name
);
250 if (sha1_object_info_extended(data
->sha1
, &data
->info
, LOOKUP_REPLACE_OBJECT
) < 0) {
251 printf("%s missing\n", obj_name
);
256 strbuf_expand(&buf
, opt
->format
, expand_format
, data
);
257 strbuf_addch(&buf
, '\n');
258 write_or_die(1, buf
.buf
, buf
.len
);
259 strbuf_release(&buf
);
261 if (opt
->print_contents
) {
262 print_object_or_die(1, data
);
263 write_or_die(1, "\n", 1);
268 static int batch_objects(struct batch_options
*opt
)
270 struct strbuf buf
= STRBUF_INIT
;
271 struct expand_data data
;
276 opt
->format
= "%(objectname) %(objecttype) %(objectsize)";
279 * Expand once with our special mark_query flag, which will prime the
280 * object_info to be handed to sha1_object_info_extended for each
283 memset(&data
, 0, sizeof(data
));
285 strbuf_expand(&buf
, opt
->format
, expand_format
, &data
);
289 * If we are printing out the object, then always fill in the type,
290 * since we will want to decide whether or not to stream.
292 if (opt
->print_contents
)
293 data
.info
.typep
= &data
.type
;
296 * We are going to call get_sha1 on a potentially very large number of
297 * objects. In most large cases, these will be actual object sha1s. The
298 * cost to double-check that each one is not also a ref (just so we can
299 * warn) ends up dwarfing the actual cost of the object lookups
300 * themselves. We can work around it by just turning off the warning.
302 save_warning
= warn_on_object_refname_ambiguity
;
303 warn_on_object_refname_ambiguity
= 0;
305 while (strbuf_getline(&buf
, stdin
, '\n') != EOF
) {
306 if (data
.split_on_whitespace
) {
308 * Split at first whitespace, tying off the beginning
309 * of the string and saving the remainder (or NULL) in
312 char *p
= strpbrk(buf
.buf
, " \t");
314 while (*p
&& strchr(" \t", *p
))
320 retval
= batch_one_object(buf
.buf
, opt
, &data
);
325 strbuf_release(&buf
);
326 warn_on_object_refname_ambiguity
= save_warning
;
330 static const char * const cat_file_usage
[] = {
331 N_("git cat-file (-t|-s|-e|-p|<type>|--textconv) <object>"),
332 N_("git cat-file (--batch|--batch-check) < <list_of_objects>"),
336 static int git_cat_file_config(const char *var
, const char *value
, void *cb
)
338 if (userdiff_config(var
, value
) < 0)
341 return git_default_config(var
, value
, cb
);
344 static int batch_option_callback(const struct option
*opt
,
348 struct batch_options
*bo
= opt
->value
;
351 memset(bo
, 0, sizeof(*bo
));
356 bo
->print_contents
= !strcmp(opt
->long_name
, "batch");
362 int cmd_cat_file(int argc
, const char **argv
, const char *prefix
)
365 const char *exp_type
= NULL
, *obj_name
= NULL
;
366 struct batch_options batch
= {0};
368 const struct option options
[] = {
369 OPT_GROUP(N_("<type> can be one of: blob, tree, commit, tag")),
370 OPT_SET_INT('t', NULL
, &opt
, N_("show object type"), 't'),
371 OPT_SET_INT('s', NULL
, &opt
, N_("show object size"), 's'),
372 OPT_SET_INT('e', NULL
, &opt
,
373 N_("exit with zero when there's no error"), 'e'),
374 OPT_SET_INT('p', NULL
, &opt
, N_("pretty-print object's content"), 'p'),
375 OPT_SET_INT(0, "textconv", &opt
,
376 N_("for blob objects, run textconv on object's content"), 'c'),
377 { OPTION_CALLBACK
, 0, "batch", &batch
, "format",
378 N_("show info and content of objects fed from the standard input"),
379 PARSE_OPT_OPTARG
, batch_option_callback
},
380 { OPTION_CALLBACK
, 0, "batch-check", &batch
, "format",
381 N_("show info about objects fed from the standard input"),
382 PARSE_OPT_OPTARG
, batch_option_callback
},
386 git_config(git_cat_file_config
, NULL
);
388 if (argc
!= 3 && argc
!= 2)
389 usage_with_options(cat_file_usage
, options
);
391 argc
= parse_options(argc
, argv
, prefix
, options
, cat_file_usage
, 0);
397 usage_with_options(cat_file_usage
, options
);
399 if (!opt
&& !batch
.enabled
) {
404 usage_with_options(cat_file_usage
, options
);
406 if (batch
.enabled
&& (opt
|| argc
)) {
407 usage_with_options(cat_file_usage
, options
);
411 return batch_objects(&batch
);
413 return cat_one_file(opt
, exp_type
, obj_name
);