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 char *buffer
= read_sha1_file(sha1
, &type
, &size
);
84 if (!skip_prefix(buffer
, "object ", &target
) ||
85 get_sha1_hex(target
, blob_sha1
))
86 die("%s not a valid tag", sha1_to_hex(sha1
));
89 hashcpy(blob_sha1
, sha1
);
91 if (sha1_object_info(blob_sha1
, NULL
) == OBJ_BLOB
)
92 return stream_blob_to_fd(1, blob_sha1
, NULL
, 0);
94 * we attempted to dereference a tag to a blob
95 * and failed; there may be new dereference
96 * mechanisms this code is not aware of.
97 * fall-back to the usual case.
100 buf
= read_object_with_reference(sha1
, exp_type
, &size
, NULL
);
104 die("git cat-file: unknown option: %s", exp_type
);
108 die("git cat-file %s: bad file", obj_name
);
110 write_or_die(1, buf
, size
);
115 unsigned char sha1
[20];
116 enum object_type type
;
118 unsigned long disk_size
;
120 unsigned char delta_base_sha1
[20];
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.
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.
133 int split_on_whitespace
;
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.
140 struct object_info info
;
143 static int is_atom(const char *atom
, const char *s
, int slen
)
145 int alen
= strlen(atom
);
146 return alen
== slen
&& !memcmp(atom
, s
, alen
);
149 static void expand_atom(struct strbuf
*sb
, const char *atom
, int len
,
152 struct expand_data
*data
= vdata
;
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
)) {
158 if (data
->mark_query
)
159 data
->info
.typep
= &data
->type
;
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
;
166 strbuf_addf(sb
, "%lu", data
->size
);
167 } else if (is_atom("objectsize:disk", atom
, len
)) {
168 if (data
->mark_query
)
169 data
->info
.disk_sizep
= &data
->disk_size
;
171 strbuf_addf(sb
, "%lu", data
->disk_size
);
172 } else if (is_atom("rest", atom
, len
)) {
173 if (data
->mark_query
)
174 data
->split_on_whitespace
= 1;
176 strbuf_addstr(sb
, data
->rest
);
177 } else if (is_atom("deltabase", atom
, len
)) {
178 if (data
->mark_query
)
179 data
->info
.delta_base_sha1
= data
->delta_base_sha1
;
181 strbuf_addstr(sb
, sha1_to_hex(data
->delta_base_sha1
));
183 die("unknown format element: %.*s", len
, atom
);
186 static size_t expand_format(struct strbuf
*sb
, const char *start
, void *data
)
192 end
= strchr(start
+ 1, ')');
194 die("format element '%s' does not end in ')'", start
);
196 expand_atom(sb
, start
+ 1, end
- start
- 1, data
);
198 return end
- start
+ 1;
201 static void print_object_or_die(int fd
, struct expand_data
*data
)
203 const unsigned char *sha1
= data
->sha1
;
205 assert(data
->info
.typep
);
207 if (data
->type
== OBJ_BLOB
) {
208 if (stream_blob_to_fd(fd
, sha1
, NULL
, 0) < 0)
209 die("unable to stream %s to stdout", sha1_to_hex(sha1
));
212 enum object_type type
;
216 contents
= read_sha1_file(sha1
, &type
, &size
);
218 die("object %s disappeared", sha1_to_hex(sha1
));
219 if (type
!= data
->type
)
220 die("object %s changed type!?", sha1_to_hex(sha1
));
221 if (data
->info
.sizep
&& size
!= data
->size
)
222 die("object %s changed size!?", sha1_to_hex(sha1
));
224 write_or_die(fd
, contents
, size
);
229 struct batch_options
{
235 static int batch_one_object(const char *obj_name
, struct batch_options
*opt
,
236 struct expand_data
*data
)
238 struct strbuf buf
= STRBUF_INIT
;
243 if (get_sha1(obj_name
, data
->sha1
)) {
244 printf("%s missing\n", obj_name
);
249 if (sha1_object_info_extended(data
->sha1
, &data
->info
, LOOKUP_REPLACE_OBJECT
) < 0) {
250 printf("%s missing\n", obj_name
);
255 strbuf_expand(&buf
, opt
->format
, expand_format
, data
);
256 strbuf_addch(&buf
, '\n');
257 write_or_die(1, buf
.buf
, buf
.len
);
258 strbuf_release(&buf
);
260 if (opt
->print_contents
) {
261 print_object_or_die(1, data
);
262 write_or_die(1, "\n", 1);
267 static int batch_objects(struct batch_options
*opt
)
269 struct strbuf buf
= STRBUF_INIT
;
270 struct expand_data data
;
275 opt
->format
= "%(objectname) %(objecttype) %(objectsize)";
278 * Expand once with our special mark_query flag, which will prime the
279 * object_info to be handed to sha1_object_info_extended for each
282 memset(&data
, 0, sizeof(data
));
284 strbuf_expand(&buf
, opt
->format
, expand_format
, &data
);
288 * If we are printing out the object, then always fill in the type,
289 * since we will want to decide whether or not to stream.
291 if (opt
->print_contents
)
292 data
.info
.typep
= &data
.type
;
295 * We are going to call get_sha1 on a potentially very large number of
296 * objects. In most large cases, these will be actual object sha1s. The
297 * cost to double-check that each one is not also a ref (just so we can
298 * warn) ends up dwarfing the actual cost of the object lookups
299 * themselves. We can work around it by just turning off the warning.
301 save_warning
= warn_on_object_refname_ambiguity
;
302 warn_on_object_refname_ambiguity
= 0;
304 while (strbuf_getline(&buf
, stdin
, '\n') != EOF
) {
305 if (data
.split_on_whitespace
) {
307 * Split at first whitespace, tying off the beginning
308 * of the string and saving the remainder (or NULL) in
311 char *p
= strpbrk(buf
.buf
, " \t");
313 while (*p
&& strchr(" \t", *p
))
319 retval
= batch_one_object(buf
.buf
, opt
, &data
);
324 strbuf_release(&buf
);
325 warn_on_object_refname_ambiguity
= save_warning
;
329 static const char * const cat_file_usage
[] = {
330 N_("git cat-file (-t|-s|-e|-p|<type>|--textconv) <object>"),
331 N_("git cat-file (--batch|--batch-check) < <list_of_objects>"),
335 static int git_cat_file_config(const char *var
, const char *value
, void *cb
)
337 if (userdiff_config(var
, value
) < 0)
340 return git_default_config(var
, value
, cb
);
343 static int batch_option_callback(const struct option
*opt
,
347 struct batch_options
*bo
= opt
->value
;
350 memset(bo
, 0, sizeof(*bo
));
355 bo
->print_contents
= !strcmp(opt
->long_name
, "batch");
361 int cmd_cat_file(int argc
, const char **argv
, const char *prefix
)
364 const char *exp_type
= NULL
, *obj_name
= NULL
;
365 struct batch_options batch
= {0};
367 const struct option options
[] = {
368 OPT_GROUP(N_("<type> can be one of: blob, tree, commit, tag")),
369 OPT_SET_INT('t', NULL
, &opt
, N_("show object type"), 't'),
370 OPT_SET_INT('s', NULL
, &opt
, N_("show object size"), 's'),
371 OPT_SET_INT('e', NULL
, &opt
,
372 N_("exit with zero when there's no error"), 'e'),
373 OPT_SET_INT('p', NULL
, &opt
, N_("pretty-print object's content"), 'p'),
374 OPT_SET_INT(0, "textconv", &opt
,
375 N_("for blob objects, run textconv on object's content"), 'c'),
376 { OPTION_CALLBACK
, 0, "batch", &batch
, "format",
377 N_("show info and content of objects fed from the standard input"),
378 PARSE_OPT_OPTARG
, batch_option_callback
},
379 { OPTION_CALLBACK
, 0, "batch-check", &batch
, "format",
380 N_("show info about objects fed from the standard input"),
381 PARSE_OPT_OPTARG
, batch_option_callback
},
385 git_config(git_cat_file_config
, NULL
);
387 if (argc
!= 3 && argc
!= 2)
388 usage_with_options(cat_file_usage
, options
);
390 argc
= parse_options(argc
, argv
, prefix
, options
, cat_file_usage
, 0);
396 usage_with_options(cat_file_usage
, options
);
398 if (!opt
&& !batch
.enabled
) {
403 usage_with_options(cat_file_usage
, options
);
405 if (batch
.enabled
&& (opt
|| argc
)) {
406 usage_with_options(cat_file_usage
, options
);
410 return batch_objects(&batch
);
412 return cat_one_file(opt
, exp_type
, obj_name
);