Add git-for-each-ref: helper for language bindings
[git/git.git] / builtin-for-each-ref.c
1 #include "cache.h"
2 #include "refs.h"
3 #include "object.h"
4 #include "tag.h"
5 #include "commit.h"
6 #include "tree.h"
7 #include "blob.h"
8 #include "quote.h"
9 #include <fnmatch.h>
10
11 /* Quoting styles */
12 #define QUOTE_NONE 0
13 #define QUOTE_SHELL 1
14 #define QUOTE_PERL 2
15 #define QUOTE_PYTHON 3
16
17 typedef enum { FIELD_STR, FIELD_ULONG, FIELD_TIME } cmp_type;
18
19 struct atom_value {
20 const char *s;
21 unsigned long ul; /* used for sorting when not FIELD_STR */
22 };
23
24 struct ref_sort {
25 struct ref_sort *next;
26 int atom; /* index into used_atom array */
27 unsigned reverse : 1;
28 };
29
30 struct refinfo {
31 char *refname;
32 unsigned char objectname[20];
33 struct atom_value *value;
34 };
35
36 static struct {
37 const char *name;
38 cmp_type cmp_type;
39 } valid_atom[] = {
40 { "refname" },
41 { "objecttype" },
42 { "objectsize", FIELD_ULONG },
43 { "objectname" },
44 { "tree" },
45 { "parent" }, /* NEEDSWORK: how to address 2nd and later parents? */
46 { "numparent", FIELD_ULONG },
47 { "object" },
48 { "type" },
49 { "tag" },
50 { "author" },
51 { "authorname" },
52 { "authoremail" },
53 { "authordate", FIELD_TIME },
54 { "committer" },
55 { "committername" },
56 { "committeremail" },
57 { "committerdate", FIELD_TIME },
58 { "tagger" },
59 { "taggername" },
60 { "taggeremail" },
61 { "taggerdate", FIELD_TIME },
62 { "subject" },
63 { "body" },
64 { "contents" },
65 };
66
67 /*
68 * An atom is a valid field atom listed above, possibly prefixed with
69 * a "*" to denote deref_tag().
70 *
71 * We parse given format string and sort specifiers, and make a list
72 * of properties that we need to extract out of objects. refinfo
73 * structure will hold an array of values extracted that can be
74 * indexed with the "atom number", which is an index into this
75 * array.
76 */
77 static const char **used_atom;
78 static cmp_type *used_atom_type;
79 static int used_atom_cnt, sort_atom_limit, need_tagged;
80
81 /*
82 * Used to parse format string and sort specifiers
83 */
84 static int parse_atom(const char *atom, const char *ep)
85 {
86 const char *sp;
87 char *n;
88 int i, at;
89
90 sp = atom;
91 if (*sp == '*' && sp < ep)
92 sp++; /* deref */
93 if (ep <= sp)
94 die("malformed field name: %.*s", (int)(ep-atom), atom);
95
96 /* Do we have the atom already used elsewhere? */
97 for (i = 0; i < used_atom_cnt; i++) {
98 int len = strlen(used_atom[i]);
99 if (len == ep - atom && !memcmp(used_atom[i], atom, len))
100 return i;
101 }
102
103 /* Is the atom a valid one? */
104 for (i = 0; i < ARRAY_SIZE(valid_atom); i++) {
105 int len = strlen(valid_atom[i].name);
106 if (len == ep - sp && !memcmp(valid_atom[i].name, sp, len))
107 break;
108 }
109
110 if (ARRAY_SIZE(valid_atom) <= i)
111 die("unknown field name: %.*s", (int)(ep-atom), atom);
112
113 /* Add it in, including the deref prefix */
114 at = used_atom_cnt;
115 used_atom_cnt++;
116 used_atom = xrealloc(used_atom,
117 (sizeof *used_atom) * used_atom_cnt);
118 used_atom_type = xrealloc(used_atom_type,
119 (sizeof(*used_atom_type) * used_atom_cnt));
120 n = xmalloc(ep - atom + 1);
121 memcpy(n, atom, ep - atom);
122 n[ep-atom] = 0;
123 used_atom[at] = n;
124 used_atom_type[at] = valid_atom[i].cmp_type;
125 return at;
126 }
127
128 /*
129 * In a format string, find the next occurrence of %(atom).
130 */
131 static const char *find_next(const char *cp)
132 {
133 while (*cp) {
134 if (*cp == '%') {
135 /* %( is the start of an atom;
136 * %% is a quoteed per-cent.
137 */
138 if (cp[1] == '(')
139 return cp;
140 else if (cp[1] == '%')
141 cp++; /* skip over two % */
142 /* otherwise this is a singleton, literal % */
143 }
144 cp++;
145 }
146 return NULL;
147 }
148
149 /*
150 * Make sure the format string is well formed, and parse out
151 * the used atoms.
152 */
153 static void verify_format(const char *format)
154 {
155 const char *cp, *sp;
156 for (cp = format; *cp && (sp = find_next(cp)); ) {
157 const char *ep = strchr(sp, ')');
158 if (!ep)
159 die("malformatted format string %s", sp);
160 /* sp points at "%(" and ep points at the closing ")" */
161 parse_atom(sp + 2, ep);
162 cp = ep + 1;
163 }
164 }
165
166 /*
167 * Given an object name, read the object data and size, and return a
168 * "struct object". If the object data we are returning is also borrowed
169 * by the "struct object" representation, set *eaten as well---it is a
170 * signal from parse_object_buffer to us not to free the buffer.
171 */
172 static void *get_obj(const unsigned char *sha1, struct object **obj, unsigned long *sz, int *eaten)
173 {
174 char type[20];
175 void *buf = read_sha1_file(sha1, type, sz);
176
177 if (buf)
178 *obj = parse_object_buffer(sha1, type, *sz, buf, eaten);
179 else
180 *obj = NULL;
181 return buf;
182 }
183
184 /* See grab_values */
185 static void grab_common_values(struct atom_value *val, int deref, struct object *obj, void *buf, unsigned long sz)
186 {
187 int i;
188
189 for (i = 0; i < used_atom_cnt; i++) {
190 const char *name = used_atom[i];
191 struct atom_value *v = &val[i];
192 if (!!deref != (*name == '*'))
193 continue;
194 if (deref)
195 name++;
196 if (!strcmp(name, "objecttype"))
197 v->s = type_names[obj->type];
198 else if (!strcmp(name, "objectsize")) {
199 char *s = xmalloc(40);
200 sprintf(s, "%lu", sz);
201 v->ul = sz;
202 v->s = s;
203 }
204 else if (!strcmp(name, "objectname")) {
205 char *s = xmalloc(41);
206 strcpy(s, sha1_to_hex(obj->sha1));
207 v->s = s;
208 }
209 }
210 }
211
212 /* See grab_values */
213 static void grab_tag_values(struct atom_value *val, int deref, struct object *obj, void *buf, unsigned long sz)
214 {
215 int i;
216 struct tag *tag = (struct tag *) obj;
217
218 for (i = 0; i < used_atom_cnt; i++) {
219 const char *name = used_atom[i];
220 struct atom_value *v = &val[i];
221 if (!!deref != (*name == '*'))
222 continue;
223 if (deref)
224 name++;
225 if (!strcmp(name, "tag"))
226 v->s = tag->tag;
227 }
228 }
229
230 static int num_parents(struct commit *commit)
231 {
232 struct commit_list *parents;
233 int i;
234
235 for (i = 0, parents = commit->parents;
236 parents;
237 parents = parents->next)
238 i++;
239 return i;
240 }
241
242 /* See grab_values */
243 static void grab_commit_values(struct atom_value *val, int deref, struct object *obj, void *buf, unsigned long sz)
244 {
245 int i;
246 struct commit *commit = (struct commit *) obj;
247
248 for (i = 0; i < used_atom_cnt; i++) {
249 const char *name = used_atom[i];
250 struct atom_value *v = &val[i];
251 if (!!deref != (*name == '*'))
252 continue;
253 if (deref)
254 name++;
255 if (!strcmp(name, "tree")) {
256 char *s = xmalloc(41);
257 strcpy(s, sha1_to_hex(commit->tree->object.sha1));
258 v->s = s;
259 }
260 if (!strcmp(name, "numparent")) {
261 char *s = xmalloc(40);
262 sprintf(s, "%lu", v->ul);
263 v->s = s;
264 v->ul = num_parents(commit);
265 }
266 else if (!strcmp(name, "parent")) {
267 int num = num_parents(commit);
268 int i;
269 struct commit_list *parents;
270 char *s = xmalloc(42 * num);
271 v->s = s;
272 for (i = 0, parents = commit->parents;
273 parents;
274 parents = parents->next, i = i + 42) {
275 struct commit *parent = parents->item;
276 strcpy(s+i, sha1_to_hex(parent->object.sha1));
277 if (parents->next)
278 s[i+40] = ' ';
279 }
280 }
281 }
282 }
283
284 static const char *find_wholine(const char *who, int wholen, const char *buf, unsigned long sz)
285 {
286 const char *eol;
287 while (*buf) {
288 if (!strncmp(buf, who, wholen) &&
289 buf[wholen] == ' ')
290 return buf + wholen + 1;
291 eol = strchr(buf, '\n');
292 if (!eol)
293 return "";
294 eol++;
295 if (eol[1] == '\n')
296 return ""; /* end of header */
297 buf = eol;
298 }
299 return "";
300 }
301
302 static char *copy_line(const char *buf)
303 {
304 const char *eol = strchr(buf, '\n');
305 char *line;
306 int len;
307 if (!eol)
308 return "";
309 len = eol - buf;
310 line = xmalloc(len + 1);
311 memcpy(line, buf, len);
312 line[len] = 0;
313 return line;
314 }
315
316 static char *copy_name(const char *buf)
317 {
318 const char *eol = strchr(buf, '\n');
319 const char *eoname = strstr(buf, " <");
320 char *line;
321 int len;
322 if (!(eoname && eol && eoname < eol))
323 return "";
324 len = eoname - buf;
325 line = xmalloc(len + 1);
326 memcpy(line, buf, len);
327 line[len] = 0;
328 return line;
329 }
330
331 static char *copy_email(const char *buf)
332 {
333 const char *email = strchr(buf, '<');
334 const char *eoemail = strchr(email, '>');
335 char *line;
336 int len;
337 if (!email || !eoemail)
338 return "";
339 eoemail++;
340 len = eoemail - email;
341 line = xmalloc(len + 1);
342 memcpy(line, email, len);
343 line[len] = 0;
344 return line;
345 }
346
347 static void grab_date(const char *buf, struct atom_value *v)
348 {
349 const char *eoemail = strstr(buf, "> ");
350 char *zone;
351 unsigned long timestamp;
352 long tz;
353
354 if (!eoemail)
355 goto bad;
356 timestamp = strtoul(eoemail + 2, &zone, 10);
357 if (timestamp == ULONG_MAX)
358 goto bad;
359 tz = strtol(zone, NULL, 10);
360 if ((tz == LONG_MIN || tz == LONG_MAX) && errno == ERANGE)
361 goto bad;
362 v->s = xstrdup(show_date(timestamp, tz, 0));
363 v->ul = timestamp;
364 return;
365 bad:
366 v->s = "";
367 v->ul = 0;
368 }
369
370 /* See grab_values */
371 static void grab_person(const char *who, struct atom_value *val, int deref, struct object *obj, void *buf, unsigned long sz)
372 {
373 int i;
374 int wholen = strlen(who);
375 const char *wholine = NULL;
376
377 for (i = 0; i < used_atom_cnt; i++) {
378 const char *name = used_atom[i];
379 struct atom_value *v = &val[i];
380 if (!!deref != (*name == '*'))
381 continue;
382 if (deref)
383 name++;
384 if (strncmp(who, name, wholen))
385 continue;
386 if (name[wholen] != 0 &&
387 strcmp(name + wholen, "name") &&
388 strcmp(name + wholen, "email") &&
389 strcmp(name + wholen, "date"))
390 continue;
391 if (!wholine)
392 wholine = find_wholine(who, wholen, buf, sz);
393 if (!wholine)
394 return; /* no point looking for it */
395 if (name[wholen] == 0)
396 v->s = copy_line(wholine);
397 else if (!strcmp(name + wholen, "name"))
398 v->s = copy_name(wholine);
399 else if (!strcmp(name + wholen, "email"))
400 v->s = copy_email(wholine);
401 else if (!strcmp(name + wholen, "date"))
402 grab_date(wholine, v);
403 }
404 }
405
406 static void find_subpos(const char *buf, unsigned long sz, const char **sub, const char **body)
407 {
408 while (*buf) {
409 const char *eol = strchr(buf, '\n');
410 if (!eol)
411 return;
412 if (eol[1] == '\n') {
413 buf = eol + 1;
414 break; /* found end of header */
415 }
416 buf = eol + 1;
417 }
418 while (*buf == '\n')
419 buf++;
420 if (!*buf)
421 return;
422 *sub = buf; /* first non-empty line */
423 buf = strchr(buf, '\n');
424 if (!buf)
425 return; /* no body */
426 while (*buf == '\n')
427 buf++; /* skip blank between subject and body */
428 *body = buf;
429 }
430
431 /* See grab_values */
432 static void grab_sub_body_contents(struct atom_value *val, int deref, struct object *obj, void *buf, unsigned long sz)
433 {
434 int i;
435 const char *subpos = NULL, *bodypos = NULL;
436
437 for (i = 0; i < used_atom_cnt; i++) {
438 const char *name = used_atom[i];
439 struct atom_value *v = &val[i];
440 if (!!deref != (*name == '*'))
441 continue;
442 if (deref)
443 name++;
444 if (strcmp(name, "subject") &&
445 strcmp(name, "body") &&
446 strcmp(name, "contents"))
447 continue;
448 if (!subpos)
449 find_subpos(buf, sz, &subpos, &bodypos);
450 if (!subpos)
451 return;
452
453 if (!strcmp(name, "subject"))
454 v->s = copy_line(subpos);
455 else if (!strcmp(name, "body"))
456 v->s = bodypos;
457 else if (!strcmp(name, "contents"))
458 v->s = subpos;
459 }
460 }
461
462 /* We want to have empty print-string for field requests
463 * that do not apply (e.g. "authordate" for a tag object)
464 */
465 static void fill_missing_values(struct atom_value *val)
466 {
467 int i;
468 for (i = 0; i < used_atom_cnt; i++) {
469 struct atom_value *v = &val[i];
470 if (v->s == NULL)
471 v->s = "";
472 }
473 }
474
475 /*
476 * val is a list of atom_value to hold returned values. Extract
477 * the values for atoms in used_atom array out of (obj, buf, sz).
478 * when deref is false, (obj, buf, sz) is the object that is
479 * pointed at by the ref itself; otherwise it is the object the
480 * ref (which is a tag) refers to.
481 */
482 static void grab_values(struct atom_value *val, int deref, struct object *obj, void *buf, unsigned long sz)
483 {
484 grab_common_values(val, deref, obj, buf, sz);
485 switch (obj->type) {
486 case OBJ_TAG:
487 grab_tag_values(val, deref, obj, buf, sz);
488 grab_sub_body_contents(val, deref, obj, buf, sz);
489 grab_person("tagger", val, deref, obj, buf, sz);
490 break;
491 case OBJ_COMMIT:
492 grab_commit_values(val, deref, obj, buf, sz);
493 grab_sub_body_contents(val, deref, obj, buf, sz);
494 grab_person("author", val, deref, obj, buf, sz);
495 grab_person("committer", val, deref, obj, buf, sz);
496 break;
497 case OBJ_TREE:
498 // grab_tree_values(val, deref, obj, buf, sz);
499 break;
500 case OBJ_BLOB:
501 // grab_blob_values(val, deref, obj, buf, sz);
502 break;
503 default:
504 die("Eh? Object of type %d?", obj->type);
505 }
506 }
507
508 /*
509 * Parse the object referred by ref, and grab needed value.
510 */
511 static void populate_value(struct refinfo *ref)
512 {
513 void *buf;
514 struct object *obj;
515 int eaten, i;
516 unsigned long size;
517 const unsigned char *tagged;
518
519 ref->value = xcalloc(sizeof(struct atom_value), used_atom_cnt);
520
521 buf = get_obj(ref->objectname, &obj, &size, &eaten);
522 if (!buf)
523 die("missing object %s for %s",
524 sha1_to_hex(ref->objectname), ref->refname);
525 if (!obj)
526 die("parse_object_buffer failed on %s for %s",
527 sha1_to_hex(ref->objectname), ref->refname);
528
529 /* Fill in specials first */
530 for (i = 0; i < used_atom_cnt; i++) {
531 const char *name = used_atom[i];
532 struct atom_value *v = &ref->value[i];
533 if (!strcmp(name, "refname"))
534 v->s = ref->refname;
535 else if (!strcmp(name, "*refname")) {
536 int len = strlen(ref->refname);
537 char *s = xmalloc(len + 4);
538 sprintf(s, "%s^{}", ref->refname);
539 v->s = s;
540 }
541 }
542
543 grab_values(ref->value, 0, obj, buf, size);
544 if (!eaten)
545 free(buf);
546
547 /* If there is no atom that wants to know about tagged
548 * object, we are done.
549 */
550 if (!need_tagged || (obj->type != OBJ_TAG))
551 return;
552
553 /* If it is a tag object, see if we use a value that derefs
554 * the object, and if we do grab the object it refers to.
555 */
556 tagged = ((struct tag *)obj)->tagged->sha1;
557
558 /* NEEDSWORK: This derefs tag only once, which
559 * is good to deal with chains of trust, but
560 * is not consistent with what deref_tag() does
561 * which peels the onion to the core.
562 */
563 buf = get_obj(tagged, &obj, &size, &eaten);
564 if (!buf)
565 die("missing object %s for %s",
566 sha1_to_hex(tagged), ref->refname);
567 if (!obj)
568 die("parse_object_buffer failed on %s for %s",
569 sha1_to_hex(tagged), ref->refname);
570 grab_values(ref->value, 1, obj, buf, size);
571 if (!eaten)
572 free(buf);
573 }
574
575 /*
576 * Given a ref, return the value for the atom. This lazily gets value
577 * out of the object by calling populate value.
578 */
579 static void get_value(struct refinfo *ref, int atom, struct atom_value **v)
580 {
581 if (!ref->value) {
582 populate_value(ref);
583 fill_missing_values(ref->value);
584 }
585 *v = &ref->value[atom];
586 }
587
588 static struct refinfo **grab_array;
589 static const char **grab_pattern;
590 static int *grab_cnt;
591
592 /*
593 * A call-back given to for_each_ref(). It is unfortunate that we
594 * need to use global variables to pass extra information to this
595 * function.
596 */
597 static int grab_single_ref(const char *refname, const unsigned char *sha1)
598 {
599 struct refinfo *ref;
600 int cnt;
601
602 if (*grab_pattern) {
603 const char **pattern;
604 int namelen = strlen(refname);
605 for (pattern = grab_pattern; *pattern; pattern++) {
606 const char *p = *pattern;
607 int plen = strlen(p);
608
609 if ((plen <= namelen) &&
610 !strncmp(refname, p, plen) &&
611 (refname[plen] == '\0' ||
612 refname[plen] == '/'))
613 break;
614 if (!fnmatch(p, refname, FNM_PATHNAME))
615 break;
616 }
617 if (!*pattern)
618 return 0;
619 }
620
621 /* We do not open the object yet; sort may only need refname
622 * to do its job and the resulting list may yet to be pruned
623 * by maxcount logic.
624 */
625 ref = xcalloc(1, sizeof(*ref));
626 ref->refname = xstrdup(refname);
627 hashcpy(ref->objectname, sha1);
628
629 cnt = *grab_cnt;
630 grab_array = xrealloc(grab_array, sizeof(*grab_array) * (cnt + 1));
631 grab_array[cnt++] = ref;
632 *grab_cnt = cnt;
633 return 0;
634 }
635
636 static struct refinfo **grab_refs(const char **pattern, int *cnt)
637 {
638 /* Sheesh, we really should make for-each-ref to take
639 * callback data.
640 */
641 *cnt = 0;
642 grab_pattern = pattern;
643 grab_cnt = cnt;
644 for_each_ref(grab_single_ref);
645 return grab_array;
646 }
647
648 static int cmp_ref_sort(struct ref_sort *s, struct refinfo *a, struct refinfo *b)
649 {
650 struct atom_value *va, *vb;
651 int cmp;
652 cmp_type cmp_type = used_atom_type[s->atom];
653
654 get_value(a, s->atom, &va);
655 get_value(b, s->atom, &vb);
656 switch (cmp_type) {
657 case FIELD_STR:
658 cmp = strcmp(va->s, vb->s);
659 break;
660 default:
661 if (va->ul < vb->ul)
662 cmp = -1;
663 else if (va->ul == vb->ul)
664 cmp = 0;
665 else
666 cmp = 1;
667 break;
668 }
669 return (s->reverse) ? -cmp : cmp;
670 }
671
672 static struct ref_sort *ref_sort;
673 static int compare_refs(const void *a_, const void *b_)
674 {
675 struct refinfo *a = *((struct refinfo **)a_);
676 struct refinfo *b = *((struct refinfo **)b_);
677 struct ref_sort *s;
678
679 for (s = ref_sort; s; s = s->next) {
680 int cmp = cmp_ref_sort(s, a, b);
681 if (cmp)
682 return cmp;
683 }
684 return 0;
685 }
686
687 static void sort_refs(struct ref_sort *sort, struct refinfo **refs, int num_refs)
688 {
689 ref_sort = sort;
690 qsort(refs, num_refs, sizeof(struct refinfo *), compare_refs);
691 }
692
693 static void print_value(struct refinfo *ref, int atom, int quote_style)
694 {
695 struct atom_value *v;
696 get_value(ref, atom, &v);
697 switch (quote_style) {
698 case QUOTE_NONE:
699 fputs(v->s, stdout);
700 break;
701 case QUOTE_SHELL:
702 sq_quote_print(stdout, v->s);
703 break;
704 case QUOTE_PERL:
705 perl_quote_print(stdout, v->s);
706 break;
707 case QUOTE_PYTHON:
708 python_quote_print(stdout, v->s);
709 break;
710 }
711 }
712
713 static int hex1(char ch)
714 {
715 if ('0' <= ch && ch <= '9')
716 return ch - '0';
717 else if ('a' <= ch && ch <= 'f')
718 return ch - 'a' + 10;
719 else if ('A' <= ch && ch <= 'F')
720 return ch - 'A' + 10;
721 return -1;
722 }
723 static int hex2(const char *cp)
724 {
725 if (cp[0] && cp[1])
726 return (hex1(cp[0]) << 4) | hex1(cp[1]);
727 else
728 return -1;
729 }
730
731 static void emit(const char *cp, const char *ep)
732 {
733 while (*cp && (!ep || cp < ep)) {
734 if (*cp == '%') {
735 if (cp[1] == '%')
736 cp++;
737 else {
738 int ch = hex2(cp + 1);
739 if (0 <= ch) {
740 putchar(ch);
741 cp += 3;
742 continue;
743 }
744 }
745 }
746 putchar(*cp);
747 cp++;
748 }
749 }
750
751 static void show_ref(struct refinfo *info, const char *format, int quote_style)
752 {
753 const char *cp, *sp, *ep;
754
755 for (cp = format; *cp && (sp = find_next(cp)); cp = ep + 1) {
756 ep = strchr(sp, ')');
757 if (cp < sp)
758 emit(cp, sp);
759 print_value(info, parse_atom(sp + 2, ep), quote_style);
760 }
761 if (*cp) {
762 sp = cp + strlen(cp);
763 emit(cp, sp);
764 }
765 putchar('\n');
766 }
767
768 static struct ref_sort *default_sort(void)
769 {
770 static const char cstr_name[] = "refname";
771
772 struct ref_sort *sort = xcalloc(1, sizeof(*sort));
773
774 sort->next = NULL;
775 sort->atom = parse_atom(cstr_name, cstr_name + strlen(cstr_name));
776 return sort;
777 }
778
779 int cmd_for_each_ref(int ac, const char **av, char *prefix)
780 {
781 int i, num_refs;
782 const char *format = NULL;
783 struct ref_sort *sort = NULL, **sort_tail = &sort;
784 int maxcount = 0;
785 int quote_style = -1; /* unspecified yet */
786 struct refinfo **refs;
787
788 for (i = 1; i < ac; i++) {
789 const char *arg = av[i];
790 if (arg[0] != '-')
791 break;
792 if (!strcmp(arg, "--")) {
793 i++;
794 break;
795 }
796 if (!strncmp(arg, "--format=", 9)) {
797 if (format)
798 die("more than one --format?");
799 format = arg + 9;
800 continue;
801 }
802 if (!strcmp(arg, "-s") || !strcmp(arg, "--shell") ) {
803 if (0 <= quote_style)
804 die("more than one quoting style?");
805 quote_style = QUOTE_SHELL;
806 continue;
807 }
808 if (!strcmp(arg, "-p") || !strcmp(arg, "--perl") ) {
809 if (0 <= quote_style)
810 die("more than one quoting style?");
811 quote_style = QUOTE_PERL;
812 continue;
813 }
814 if (!strcmp(arg, "--python") ) {
815 if (0 <= quote_style)
816 die("more than one quoting style?");
817 quote_style = QUOTE_PYTHON;
818 continue;
819 }
820 if (!strncmp(arg, "--count=", 8)) {
821 if (maxcount)
822 die("more than one --count?");
823 maxcount = atoi(arg + 8);
824 if (maxcount <= 0)
825 die("The number %s did not parse", arg);
826 continue;
827 }
828 if (!strncmp(arg, "--sort=", 7)) {
829 struct ref_sort *s = xcalloc(1, sizeof(*s));
830 int len;
831
832 s->next = NULL;
833 *sort_tail = s;
834 sort_tail = &s->next;
835
836 arg += 7;
837 if (*arg == '-') {
838 s->reverse = 1;
839 arg++;
840 }
841 len = strlen(arg);
842 sort->atom = parse_atom(arg, arg+len);
843 continue;
844 }
845 break;
846 }
847 if (quote_style < 0)
848 quote_style = QUOTE_NONE;
849
850 if (!sort)
851 sort = default_sort();
852 sort_atom_limit = used_atom_cnt;
853 if (!format)
854 format = "%(objectname) %(objecttype)\t%(refname)";
855
856 verify_format(format);
857
858 refs = grab_refs(av + i, &num_refs);
859
860 for (i = 0; i < used_atom_cnt; i++) {
861 if (used_atom[i][0] == '*') {
862 need_tagged = 1;
863 break;
864 }
865 }
866
867 sort_refs(sort, refs, num_refs);
868
869 if (!maxcount || num_refs < maxcount)
870 maxcount = num_refs;
871 for (i = 0; i < maxcount; i++)
872 show_ref(refs[i], format, quote_style);
873 return 0;
874 }