2 * GIT - The information manager from hell
4 * Copyright (C) Linus Torvalds, 2005
8 #include "parse-options.h"
10 #include "streaming.h"
12 static int cat_one_file(int opt
, const char *exp_type
, const char *obj_name
,
15 unsigned char sha1
[20];
16 enum object_type type
;
19 struct object_context obj_context
;
20 struct object_info oi
= {NULL
};
21 struct strbuf sb
= STRBUF_INIT
;
22 unsigned flags
= LOOKUP_REPLACE_OBJECT
;
25 flags
|= LOOKUP_UNKNOWN_OBJECT
;
27 if (get_sha1_with_context(obj_name
, 0, sha1
, &obj_context
))
28 die("Not a valid object name %s", obj_name
);
34 if (sha1_object_info_extended(sha1
, &oi
, flags
) < 0)
35 die("git cat-file: could not get object info");
37 printf("%s\n", sb
.buf
);
45 if (sha1_object_info_extended(sha1
, &oi
, flags
) < 0)
46 die("git cat-file: could not get object info");
47 printf("%lu\n", size
);
51 return !has_sha1_file(sha1
);
54 if (!obj_context
.path
[0])
55 die("git cat-file --textconv %s: <object> must be <sha1:path>",
58 if (textconv_object(obj_context
.path
, obj_context
.mode
, sha1
, 1, &buf
, &size
))
62 type
= sha1_object_info(sha1
, NULL
);
64 die("Not a valid object name %s", obj_name
);
66 /* custom pretty-print here */
67 if (type
== OBJ_TREE
) {
68 const char *ls_args
[3] = { NULL
};
69 ls_args
[0] = "ls-tree";
70 ls_args
[1] = obj_name
;
71 return cmd_ls_tree(2, ls_args
, NULL
);
75 return stream_blob_to_fd(1, sha1
, NULL
, 0);
76 buf
= read_sha1_file(sha1
, &type
, &size
);
78 die("Cannot read object %s", obj_name
);
80 /* otherwise just spit out the data */
84 if (type_from_string(exp_type
) == OBJ_BLOB
) {
85 unsigned char blob_sha1
[20];
86 if (sha1_object_info(sha1
, NULL
) == OBJ_TAG
) {
87 char *buffer
= read_sha1_file(sha1
, &type
, &size
);
89 if (!skip_prefix(buffer
, "object ", &target
) ||
90 get_sha1_hex(target
, blob_sha1
))
91 die("%s not a valid tag", sha1_to_hex(sha1
));
94 hashcpy(blob_sha1
, sha1
);
96 if (sha1_object_info(blob_sha1
, NULL
) == OBJ_BLOB
)
97 return stream_blob_to_fd(1, blob_sha1
, NULL
, 0);
99 * we attempted to dereference a tag to a blob
100 * and failed; there may be new dereference
101 * mechanisms this code is not aware of.
102 * fall-back to the usual case.
105 buf
= read_object_with_reference(sha1
, exp_type
, &size
, NULL
);
109 die("git cat-file: unknown option: %s", exp_type
);
113 die("git cat-file %s: bad file", obj_name
);
115 write_or_die(1, buf
, size
);
120 unsigned char sha1
[20];
121 enum object_type type
;
123 unsigned long disk_size
;
125 unsigned char delta_base_sha1
[20];
128 * If mark_query is true, we do not expand anything, but rather
129 * just mark the object_info with items we wish to query.
134 * Whether to split the input on whitespace before feeding it to
135 * get_sha1; this is decided during the mark_query phase based on
136 * whether we have a %(rest) token in our format.
138 int split_on_whitespace
;
141 * After a mark_query run, this object_info is set up to be
142 * passed to sha1_object_info_extended. It will point to the data
143 * elements above, so you can retrieve the response from there.
145 struct object_info info
;
148 static int is_atom(const char *atom
, const char *s
, int slen
)
150 int alen
= strlen(atom
);
151 return alen
== slen
&& !memcmp(atom
, s
, alen
);
154 static void expand_atom(struct strbuf
*sb
, const char *atom
, int len
,
157 struct expand_data
*data
= vdata
;
159 if (is_atom("objectname", atom
, len
)) {
160 if (!data
->mark_query
)
161 strbuf_addstr(sb
, sha1_to_hex(data
->sha1
));
162 } else if (is_atom("objecttype", atom
, len
)) {
163 if (data
->mark_query
)
164 data
->info
.typep
= &data
->type
;
166 strbuf_addstr(sb
, typename(data
->type
));
167 } else if (is_atom("objectsize", atom
, len
)) {
168 if (data
->mark_query
)
169 data
->info
.sizep
= &data
->size
;
171 strbuf_addf(sb
, "%lu", data
->size
);
172 } else if (is_atom("objectsize:disk", atom
, len
)) {
173 if (data
->mark_query
)
174 data
->info
.disk_sizep
= &data
->disk_size
;
176 strbuf_addf(sb
, "%lu", data
->disk_size
);
177 } else if (is_atom("rest", atom
, len
)) {
178 if (data
->mark_query
)
179 data
->split_on_whitespace
= 1;
181 strbuf_addstr(sb
, data
->rest
);
182 } else if (is_atom("deltabase", atom
, len
)) {
183 if (data
->mark_query
)
184 data
->info
.delta_base_sha1
= data
->delta_base_sha1
;
186 strbuf_addstr(sb
, sha1_to_hex(data
->delta_base_sha1
));
188 die("unknown format element: %.*s", len
, atom
);
191 static size_t expand_format(struct strbuf
*sb
, const char *start
, void *data
)
197 end
= strchr(start
+ 1, ')');
199 die("format element '%s' does not end in ')'", start
);
201 expand_atom(sb
, start
+ 1, end
- start
- 1, data
);
203 return end
- start
+ 1;
206 static void print_object_or_die(int fd
, struct expand_data
*data
)
208 const unsigned char *sha1
= data
->sha1
;
210 assert(data
->info
.typep
);
212 if (data
->type
== OBJ_BLOB
) {
213 if (stream_blob_to_fd(fd
, sha1
, NULL
, 0) < 0)
214 die("unable to stream %s to stdout", sha1_to_hex(sha1
));
217 enum object_type type
;
221 contents
= read_sha1_file(sha1
, &type
, &size
);
223 die("object %s disappeared", sha1_to_hex(sha1
));
224 if (type
!= data
->type
)
225 die("object %s changed type!?", sha1_to_hex(sha1
));
226 if (data
->info
.sizep
&& size
!= data
->size
)
227 die("object %s changed size!?", sha1_to_hex(sha1
));
229 write_or_die(fd
, contents
, size
);
234 struct batch_options
{
240 static int batch_one_object(const char *obj_name
, struct batch_options
*opt
,
241 struct expand_data
*data
)
243 struct strbuf buf
= STRBUF_INIT
;
248 if (get_sha1(obj_name
, data
->sha1
)) {
249 printf("%s missing\n", obj_name
);
254 if (sha1_object_info_extended(data
->sha1
, &data
->info
, LOOKUP_REPLACE_OBJECT
) < 0) {
255 printf("%s missing\n", obj_name
);
260 strbuf_expand(&buf
, opt
->format
, expand_format
, data
);
261 strbuf_addch(&buf
, '\n');
262 write_or_die(1, buf
.buf
, buf
.len
);
263 strbuf_release(&buf
);
265 if (opt
->print_contents
) {
266 print_object_or_die(1, data
);
267 write_or_die(1, "\n", 1);
272 static int batch_objects(struct batch_options
*opt
)
274 struct strbuf buf
= STRBUF_INIT
;
275 struct expand_data data
;
280 opt
->format
= "%(objectname) %(objecttype) %(objectsize)";
283 * Expand once with our special mark_query flag, which will prime the
284 * object_info to be handed to sha1_object_info_extended for each
287 memset(&data
, 0, sizeof(data
));
289 strbuf_expand(&buf
, opt
->format
, expand_format
, &data
);
293 * If we are printing out the object, then always fill in the type,
294 * since we will want to decide whether or not to stream.
296 if (opt
->print_contents
)
297 data
.info
.typep
= &data
.type
;
300 * We are going to call get_sha1 on a potentially very large number of
301 * objects. In most large cases, these will be actual object sha1s. The
302 * cost to double-check that each one is not also a ref (just so we can
303 * warn) ends up dwarfing the actual cost of the object lookups
304 * themselves. We can work around it by just turning off the warning.
306 save_warning
= warn_on_object_refname_ambiguity
;
307 warn_on_object_refname_ambiguity
= 0;
309 while (strbuf_getline(&buf
, stdin
, '\n') != EOF
) {
310 if (data
.split_on_whitespace
) {
312 * Split at first whitespace, tying off the beginning
313 * of the string and saving the remainder (or NULL) in
316 char *p
= strpbrk(buf
.buf
, " \t");
318 while (*p
&& strchr(" \t", *p
))
324 retval
= batch_one_object(buf
.buf
, opt
, &data
);
329 strbuf_release(&buf
);
330 warn_on_object_refname_ambiguity
= save_warning
;
334 static const char * const cat_file_usage
[] = {
335 N_("git cat-file (-t [--allow-unknown-type]|-s [--allow-unknown-type]|-e|-p|<type>|--textconv) <object>"),
336 N_("git cat-file (--batch | --batch-check) < <list-of-objects>"),
340 static int git_cat_file_config(const char *var
, const char *value
, void *cb
)
342 if (userdiff_config(var
, value
) < 0)
345 return git_default_config(var
, value
, cb
);
348 static int batch_option_callback(const struct option
*opt
,
352 struct batch_options
*bo
= opt
->value
;
355 memset(bo
, 0, sizeof(*bo
));
360 bo
->print_contents
= !strcmp(opt
->long_name
, "batch");
366 int cmd_cat_file(int argc
, const char **argv
, const char *prefix
)
369 const char *exp_type
= NULL
, *obj_name
= NULL
;
370 struct batch_options batch
= {0};
371 int unknown_type
= 0;
373 const struct option options
[] = {
374 OPT_GROUP(N_("<type> can be one of: blob, tree, commit, tag")),
375 OPT_CMDMODE('t', NULL
, &opt
, N_("show object type"), 't'),
376 OPT_CMDMODE('s', NULL
, &opt
, N_("show object size"), 's'),
377 OPT_CMDMODE('e', NULL
, &opt
,
378 N_("exit with zero when there's no error"), 'e'),
379 OPT_CMDMODE('p', NULL
, &opt
, N_("pretty-print object's content"), 'p'),
380 OPT_CMDMODE(0, "textconv", &opt
,
381 N_("for blob objects, run textconv on object's content"), 'c'),
382 OPT_BOOL( 0, "allow-unknown-type", &unknown_type
,
383 N_("allow -s and -t to work with broken/corrupt objects")),
384 { OPTION_CALLBACK
, 0, "batch", &batch
, "format",
385 N_("show info and content of objects fed from the standard input"),
386 PARSE_OPT_OPTARG
, batch_option_callback
},
387 { OPTION_CALLBACK
, 0, "batch-check", &batch
, "format",
388 N_("show info about objects fed from the standard input"),
389 PARSE_OPT_OPTARG
, batch_option_callback
},
393 git_config(git_cat_file_config
, NULL
);
395 argc
= parse_options(argc
, argv
, prefix
, options
, cat_file_usage
, 0);
401 usage_with_options(cat_file_usage
, options
);
403 if (!opt
&& !batch
.enabled
) {
408 usage_with_options(cat_file_usage
, options
);
410 if (batch
.enabled
&& (opt
|| argc
)) {
411 usage_with_options(cat_file_usage
, options
);
415 return batch_objects(&batch
);
417 if (unknown_type
&& opt
!= 't' && opt
!= 's')
418 die("git cat-file --allow-unknown-type: use with -s or -t");
419 return cat_one_file(opt
, exp_type
, obj_name
, unknown_type
);