15 #define QUOTE_PYTHON 3
18 typedef enum { FIELD_STR
, FIELD_ULONG
, FIELD_TIME
} cmp_type
;
22 unsigned long ul
; /* used for sorting when not FIELD_STR */
26 struct ref_sort
*next
;
27 int atom
; /* index into used_atom array */
33 unsigned char objectname
[20];
34 struct atom_value
*value
;
43 { "objectsize", FIELD_ULONG
},
46 { "parent" }, /* NEEDSWORK: how to address 2nd and later parents? */
47 { "numparent", FIELD_ULONG
},
54 { "authordate", FIELD_TIME
},
58 { "committerdate", FIELD_TIME
},
62 { "taggerdate", FIELD_TIME
},
64 { "creatordate", FIELD_TIME
},
71 * An atom is a valid field atom listed above, possibly prefixed with
72 * a "*" to denote deref_tag().
74 * We parse given format string and sort specifiers, and make a list
75 * of properties that we need to extract out of objects. refinfo
76 * structure will hold an array of values extracted that can be
77 * indexed with the "atom number", which is an index into this
80 static const char **used_atom
;
81 static cmp_type
*used_atom_type
;
82 static int used_atom_cnt
, sort_atom_limit
, need_tagged
;
85 * Used to parse format string and sort specifiers
87 static int parse_atom(const char *atom
, const char *ep
)
94 if (*sp
== '*' && sp
< ep
)
97 die("malformed field name: %.*s", (int)(ep
-atom
), atom
);
99 /* Do we have the atom already used elsewhere? */
100 for (i
= 0; i
< used_atom_cnt
; i
++) {
101 int len
= strlen(used_atom
[i
]);
102 if (len
== ep
- atom
&& !memcmp(used_atom
[i
], atom
, len
))
106 /* Is the atom a valid one? */
107 for (i
= 0; i
< ARRAY_SIZE(valid_atom
); i
++) {
108 int len
= strlen(valid_atom
[i
].name
);
110 * If the atom name has a colon, strip it and everything after
111 * it off - it specifies the format for this entry, and
112 * shouldn't be used for checking against the valid_atom
115 const char *formatp
= strchr(sp
, ':');
118 if (len
== formatp
- sp
&& !memcmp(valid_atom
[i
].name
, sp
, len
))
122 if (ARRAY_SIZE(valid_atom
) <= i
)
123 die("unknown field name: %.*s", (int)(ep
-atom
), atom
);
125 /* Add it in, including the deref prefix */
128 used_atom
= xrealloc(used_atom
,
129 (sizeof *used_atom
) * used_atom_cnt
);
130 used_atom_type
= xrealloc(used_atom_type
,
131 (sizeof(*used_atom_type
) * used_atom_cnt
));
132 n
= xmalloc(ep
- atom
+ 1);
133 memcpy(n
, atom
, ep
- atom
);
136 used_atom_type
[at
] = valid_atom
[i
].cmp_type
;
141 * In a format string, find the next occurrence of %(atom).
143 static const char *find_next(const char *cp
)
147 /* %( is the start of an atom;
148 * %% is a quoted per-cent.
152 else if (cp
[1] == '%')
153 cp
++; /* skip over two % */
154 /* otherwise this is a singleton, literal % */
162 * Make sure the format string is well formed, and parse out
165 static void verify_format(const char *format
)
168 for (cp
= format
; *cp
&& (sp
= find_next(cp
)); ) {
169 const char *ep
= strchr(sp
, ')');
171 die("malformatted format string %s", sp
);
172 /* sp points at "%(" and ep points at the closing ")" */
173 parse_atom(sp
+ 2, ep
);
179 * Given an object name, read the object data and size, and return a
180 * "struct object". If the object data we are returning is also borrowed
181 * by the "struct object" representation, set *eaten as well---it is a
182 * signal from parse_object_buffer to us not to free the buffer.
184 static void *get_obj(const unsigned char *sha1
, struct object
**obj
, unsigned long *sz
, int *eaten
)
186 enum object_type type
;
187 void *buf
= read_sha1_file(sha1
, &type
, sz
);
190 *obj
= parse_object_buffer(sha1
, type
, *sz
, buf
, eaten
);
196 /* See grab_values */
197 static void grab_common_values(struct atom_value
*val
, int deref
, struct object
*obj
, void *buf
, unsigned long sz
)
201 for (i
= 0; i
< used_atom_cnt
; i
++) {
202 const char *name
= used_atom
[i
];
203 struct atom_value
*v
= &val
[i
];
204 if (!!deref
!= (*name
== '*'))
208 if (!strcmp(name
, "objecttype"))
209 v
->s
= typename(obj
->type
);
210 else if (!strcmp(name
, "objectsize")) {
211 char *s
= xmalloc(40);
212 sprintf(s
, "%lu", sz
);
216 else if (!strcmp(name
, "objectname")) {
217 char *s
= xmalloc(41);
218 strcpy(s
, sha1_to_hex(obj
->sha1
));
224 /* See grab_values */
225 static void grab_tag_values(struct atom_value
*val
, int deref
, struct object
*obj
, void *buf
, unsigned long sz
)
228 struct tag
*tag
= (struct tag
*) obj
;
230 for (i
= 0; i
< used_atom_cnt
; i
++) {
231 const char *name
= used_atom
[i
];
232 struct atom_value
*v
= &val
[i
];
233 if (!!deref
!= (*name
== '*'))
237 if (!strcmp(name
, "tag"))
242 static int num_parents(struct commit
*commit
)
244 struct commit_list
*parents
;
247 for (i
= 0, parents
= commit
->parents
;
249 parents
= parents
->next
)
254 /* See grab_values */
255 static void grab_commit_values(struct atom_value
*val
, int deref
, struct object
*obj
, void *buf
, unsigned long sz
)
258 struct commit
*commit
= (struct commit
*) obj
;
260 for (i
= 0; i
< used_atom_cnt
; i
++) {
261 const char *name
= used_atom
[i
];
262 struct atom_value
*v
= &val
[i
];
263 if (!!deref
!= (*name
== '*'))
267 if (!strcmp(name
, "tree")) {
268 char *s
= xmalloc(41);
269 strcpy(s
, sha1_to_hex(commit
->tree
->object
.sha1
));
272 if (!strcmp(name
, "numparent")) {
273 char *s
= xmalloc(40);
274 sprintf(s
, "%lu", v
->ul
);
276 v
->ul
= num_parents(commit
);
278 else if (!strcmp(name
, "parent")) {
279 int num
= num_parents(commit
);
281 struct commit_list
*parents
;
282 char *s
= xmalloc(42 * num
);
284 for (i
= 0, parents
= commit
->parents
;
286 parents
= parents
->next
, i
= i
+ 42) {
287 struct commit
*parent
= parents
->item
;
288 strcpy(s
+i
, sha1_to_hex(parent
->object
.sha1
));
296 static const char *find_wholine(const char *who
, int wholen
, const char *buf
, unsigned long sz
)
300 if (!strncmp(buf
, who
, wholen
) &&
302 return buf
+ wholen
+ 1;
303 eol
= strchr(buf
, '\n');
308 return ""; /* end of header */
314 static const char *copy_line(const char *buf
)
316 const char *eol
= strchr(buf
, '\n');
322 line
= xmalloc(len
+ 1);
323 memcpy(line
, buf
, len
);
328 static const char *copy_name(const char *buf
)
330 const char *eol
= strchr(buf
, '\n');
331 const char *eoname
= strstr(buf
, " <");
334 if (!(eoname
&& eol
&& eoname
< eol
))
337 line
= xmalloc(len
+ 1);
338 memcpy(line
, buf
, len
);
343 static const char *copy_email(const char *buf
)
345 const char *email
= strchr(buf
, '<');
346 const char *eoemail
= strchr(email
, '>');
349 if (!email
|| !eoemail
)
352 len
= eoemail
- email
;
353 line
= xmalloc(len
+ 1);
354 memcpy(line
, email
, len
);
359 static void grab_date(const char *buf
, struct atom_value
*v
)
361 const char *eoemail
= strstr(buf
, "> ");
363 unsigned long timestamp
;
368 timestamp
= strtoul(eoemail
+ 2, &zone
, 10);
369 if (timestamp
== ULONG_MAX
)
371 tz
= strtol(zone
, NULL
, 10);
372 if ((tz
== LONG_MIN
|| tz
== LONG_MAX
) && errno
== ERANGE
)
374 v
->s
= xstrdup(show_date(timestamp
, tz
, 0));
382 /* See grab_values */
383 static void grab_person(const char *who
, struct atom_value
*val
, int deref
, struct object
*obj
, void *buf
, unsigned long sz
)
386 int wholen
= strlen(who
);
387 const char *wholine
= NULL
;
389 for (i
= 0; i
< used_atom_cnt
; i
++) {
390 const char *name
= used_atom
[i
];
391 struct atom_value
*v
= &val
[i
];
392 if (!!deref
!= (*name
== '*'))
396 if (strncmp(who
, name
, wholen
))
398 if (name
[wholen
] != 0 &&
399 strcmp(name
+ wholen
, "name") &&
400 strcmp(name
+ wholen
, "email") &&
401 strcmp(name
+ wholen
, "date"))
404 wholine
= find_wholine(who
, wholen
, buf
, sz
);
406 return; /* no point looking for it */
407 if (name
[wholen
] == 0)
408 v
->s
= copy_line(wholine
);
409 else if (!strcmp(name
+ wholen
, "name"))
410 v
->s
= copy_name(wholine
);
411 else if (!strcmp(name
+ wholen
, "email"))
412 v
->s
= copy_email(wholine
);
413 else if (!strcmp(name
+ wholen
, "date"))
414 grab_date(wholine
, v
);
417 /* For a tag or a commit object, if "creator" or "creatordate" is
418 * requested, do something special.
420 if (strcmp(who
, "tagger") && strcmp(who
, "committer"))
421 return; /* "author" for commit object is not wanted */
423 wholine
= find_wholine(who
, wholen
, buf
, sz
);
426 for (i
= 0; i
< used_atom_cnt
; i
++) {
427 const char *name
= used_atom
[i
];
428 struct atom_value
*v
= &val
[i
];
429 if (!!deref
!= (*name
== '*'))
434 if (!strcmp(name
, "creatordate"))
435 grab_date(wholine
, v
);
436 else if (!strcmp(name
, "creator"))
437 v
->s
= copy_line(wholine
);
441 static void find_subpos(const char *buf
, unsigned long sz
, const char **sub
, const char **body
)
444 const char *eol
= strchr(buf
, '\n');
447 if (eol
[1] == '\n') {
449 break; /* found end of header */
457 *sub
= buf
; /* first non-empty line */
458 buf
= strchr(buf
, '\n');
460 return; /* no body */
462 buf
++; /* skip blank between subject and body */
466 /* See grab_values */
467 static void grab_sub_body_contents(struct atom_value
*val
, int deref
, struct object
*obj
, void *buf
, unsigned long sz
)
470 const char *subpos
= NULL
, *bodypos
= NULL
;
472 for (i
= 0; i
< used_atom_cnt
; i
++) {
473 const char *name
= used_atom
[i
];
474 struct atom_value
*v
= &val
[i
];
475 if (!!deref
!= (*name
== '*'))
479 if (strcmp(name
, "subject") &&
480 strcmp(name
, "body") &&
481 strcmp(name
, "contents"))
484 find_subpos(buf
, sz
, &subpos
, &bodypos
);
488 if (!strcmp(name
, "subject"))
489 v
->s
= copy_line(subpos
);
490 else if (!strcmp(name
, "body"))
491 v
->s
= xstrdup(bodypos
);
492 else if (!strcmp(name
, "contents"))
493 v
->s
= xstrdup(subpos
);
497 /* We want to have empty print-string for field requests
498 * that do not apply (e.g. "authordate" for a tag object)
500 static void fill_missing_values(struct atom_value
*val
)
503 for (i
= 0; i
< used_atom_cnt
; i
++) {
504 struct atom_value
*v
= &val
[i
];
511 * val is a list of atom_value to hold returned values. Extract
512 * the values for atoms in used_atom array out of (obj, buf, sz).
513 * when deref is false, (obj, buf, sz) is the object that is
514 * pointed at by the ref itself; otherwise it is the object the
515 * ref (which is a tag) refers to.
517 static void grab_values(struct atom_value
*val
, int deref
, struct object
*obj
, void *buf
, unsigned long sz
)
519 grab_common_values(val
, deref
, obj
, buf
, sz
);
522 grab_tag_values(val
, deref
, obj
, buf
, sz
);
523 grab_sub_body_contents(val
, deref
, obj
, buf
, sz
);
524 grab_person("tagger", val
, deref
, obj
, buf
, sz
);
527 grab_commit_values(val
, deref
, obj
, buf
, sz
);
528 grab_sub_body_contents(val
, deref
, obj
, buf
, sz
);
529 grab_person("author", val
, deref
, obj
, buf
, sz
);
530 grab_person("committer", val
, deref
, obj
, buf
, sz
);
533 // grab_tree_values(val, deref, obj, buf, sz);
536 // grab_blob_values(val, deref, obj, buf, sz);
539 die("Eh? Object of type %d?", obj
->type
);
544 * Parse the object referred by ref, and grab needed value.
546 static void populate_value(struct refinfo
*ref
)
552 const unsigned char *tagged
;
554 ref
->value
= xcalloc(sizeof(struct atom_value
), used_atom_cnt
);
556 buf
= get_obj(ref
->objectname
, &obj
, &size
, &eaten
);
558 die("missing object %s for %s",
559 sha1_to_hex(ref
->objectname
), ref
->refname
);
561 die("parse_object_buffer failed on %s for %s",
562 sha1_to_hex(ref
->objectname
), ref
->refname
);
564 /* Fill in specials first */
565 for (i
= 0; i
< used_atom_cnt
; i
++) {
566 const char *name
= used_atom
[i
];
567 struct atom_value
*v
= &ref
->value
[i
];
568 if (!strcmp(name
, "refname"))
570 else if (!strcmp(name
, "*refname")) {
571 int len
= strlen(ref
->refname
);
572 char *s
= xmalloc(len
+ 4);
573 sprintf(s
, "%s^{}", ref
->refname
);
578 grab_values(ref
->value
, 0, obj
, buf
, size
);
582 /* If there is no atom that wants to know about tagged
583 * object, we are done.
585 if (!need_tagged
|| (obj
->type
!= OBJ_TAG
))
588 /* If it is a tag object, see if we use a value that derefs
589 * the object, and if we do grab the object it refers to.
591 tagged
= ((struct tag
*)obj
)->tagged
->sha1
;
593 /* NEEDSWORK: This derefs tag only once, which
594 * is good to deal with chains of trust, but
595 * is not consistent with what deref_tag() does
596 * which peels the onion to the core.
598 buf
= get_obj(tagged
, &obj
, &size
, &eaten
);
600 die("missing object %s for %s",
601 sha1_to_hex(tagged
), ref
->refname
);
603 die("parse_object_buffer failed on %s for %s",
604 sha1_to_hex(tagged
), ref
->refname
);
605 grab_values(ref
->value
, 1, obj
, buf
, size
);
611 * Given a ref, return the value for the atom. This lazily gets value
612 * out of the object by calling populate value.
614 static void get_value(struct refinfo
*ref
, int atom
, struct atom_value
**v
)
618 fill_missing_values(ref
->value
);
620 *v
= &ref
->value
[atom
];
623 struct grab_ref_cbdata
{
624 struct refinfo
**grab_array
;
625 const char **grab_pattern
;
630 * A call-back given to for_each_ref(). It is unfortunate that we
631 * need to use global variables to pass extra information to this
634 static int grab_single_ref(const char *refname
, const unsigned char *sha1
, int flag
, void *cb_data
)
636 struct grab_ref_cbdata
*cb
= cb_data
;
640 if (*cb
->grab_pattern
) {
641 const char **pattern
;
642 int namelen
= strlen(refname
);
643 for (pattern
= cb
->grab_pattern
; *pattern
; pattern
++) {
644 const char *p
= *pattern
;
645 int plen
= strlen(p
);
647 if ((plen
<= namelen
) &&
648 !strncmp(refname
, p
, plen
) &&
649 (refname
[plen
] == '\0' ||
650 refname
[plen
] == '/'))
652 if (!fnmatch(p
, refname
, FNM_PATHNAME
))
659 /* We do not open the object yet; sort may only need refname
660 * to do its job and the resulting list may yet to be pruned
663 ref
= xcalloc(1, sizeof(*ref
));
664 ref
->refname
= xstrdup(refname
);
665 hashcpy(ref
->objectname
, sha1
);
668 cb
->grab_array
= xrealloc(cb
->grab_array
,
669 sizeof(*cb
->grab_array
) * (cnt
+ 1));
670 cb
->grab_array
[cnt
++] = ref
;
675 static int cmp_ref_sort(struct ref_sort
*s
, struct refinfo
*a
, struct refinfo
*b
)
677 struct atom_value
*va
, *vb
;
679 cmp_type cmp_type
= used_atom_type
[s
->atom
];
681 get_value(a
, s
->atom
, &va
);
682 get_value(b
, s
->atom
, &vb
);
685 cmp
= strcmp(va
->s
, vb
->s
);
690 else if (va
->ul
== vb
->ul
)
696 return (s
->reverse
) ? -cmp
: cmp
;
699 static struct ref_sort
*ref_sort
;
700 static int compare_refs(const void *a_
, const void *b_
)
702 struct refinfo
*a
= *((struct refinfo
**)a_
);
703 struct refinfo
*b
= *((struct refinfo
**)b_
);
706 for (s
= ref_sort
; s
; s
= s
->next
) {
707 int cmp
= cmp_ref_sort(s
, a
, b
);
714 static void sort_refs(struct ref_sort
*sort
, struct refinfo
**refs
, int num_refs
)
717 qsort(refs
, num_refs
, sizeof(struct refinfo
*), compare_refs
);
720 static void print_value(struct refinfo
*ref
, int atom
, int quote_style
)
722 struct atom_value
*v
;
723 get_value(ref
, atom
, &v
);
724 switch (quote_style
) {
729 sq_quote_print(stdout
, v
->s
);
732 perl_quote_print(stdout
, v
->s
);
735 python_quote_print(stdout
, v
->s
);
738 tcl_quote_print(stdout
, v
->s
);
743 static int hex1(char ch
)
745 if ('0' <= ch
&& ch
<= '9')
747 else if ('a' <= ch
&& ch
<= 'f')
748 return ch
- 'a' + 10;
749 else if ('A' <= ch
&& ch
<= 'F')
750 return ch
- 'A' + 10;
753 static int hex2(const char *cp
)
756 return (hex1(cp
[0]) << 4) | hex1(cp
[1]);
761 static void emit(const char *cp
, const char *ep
)
763 while (*cp
&& (!ep
|| cp
< ep
)) {
768 int ch
= hex2(cp
+ 1);
781 static void show_ref(struct refinfo
*info
, const char *format
, int quote_style
)
783 const char *cp
, *sp
, *ep
;
785 for (cp
= format
; *cp
&& (sp
= find_next(cp
)); cp
= ep
+ 1) {
786 ep
= strchr(sp
, ')');
789 print_value(info
, parse_atom(sp
+ 2, ep
), quote_style
);
792 sp
= cp
+ strlen(cp
);
798 static struct ref_sort
*default_sort(void)
800 static const char cstr_name
[] = "refname";
802 struct ref_sort
*sort
= xcalloc(1, sizeof(*sort
));
805 sort
->atom
= parse_atom(cstr_name
, cstr_name
+ strlen(cstr_name
));
809 int cmd_for_each_ref(int ac
, const char **av
, const char *prefix
)
812 const char *format
= NULL
;
813 struct ref_sort
*sort
= NULL
, **sort_tail
= &sort
;
815 int quote_style
= -1; /* unspecified yet */
816 struct refinfo
**refs
;
817 struct grab_ref_cbdata cbdata
;
819 for (i
= 1; i
< ac
; i
++) {
820 const char *arg
= av
[i
];
823 if (!strcmp(arg
, "--")) {
827 if (!prefixcmp(arg
, "--format=")) {
829 die("more than one --format?");
833 if (!strcmp(arg
, "-s") || !strcmp(arg
, "--shell") ) {
834 if (0 <= quote_style
)
835 die("more than one quoting style?");
836 quote_style
= QUOTE_SHELL
;
839 if (!strcmp(arg
, "-p") || !strcmp(arg
, "--perl") ) {
840 if (0 <= quote_style
)
841 die("more than one quoting style?");
842 quote_style
= QUOTE_PERL
;
845 if (!strcmp(arg
, "--python") ) {
846 if (0 <= quote_style
)
847 die("more than one quoting style?");
848 quote_style
= QUOTE_PYTHON
;
851 if (!strcmp(arg
, "--tcl") ) {
852 if (0 <= quote_style
)
853 die("more than one quoting style?");
854 quote_style
= QUOTE_TCL
;
857 if (!prefixcmp(arg
, "--count=")) {
859 die("more than one --count?");
860 maxcount
= atoi(arg
+ 8);
862 die("The number %s did not parse", arg
);
865 if (!prefixcmp(arg
, "--sort=")) {
866 struct ref_sort
*s
= xcalloc(1, sizeof(*s
));
871 sort_tail
= &s
->next
;
879 sort
->atom
= parse_atom(arg
, arg
+len
);
885 quote_style
= QUOTE_NONE
;
888 sort
= default_sort();
889 sort_atom_limit
= used_atom_cnt
;
891 format
= "%(objectname) %(objecttype)\t%(refname)";
893 verify_format(format
);
895 memset(&cbdata
, 0, sizeof(cbdata
));
896 cbdata
.grab_pattern
= av
+ i
;
897 for_each_ref(grab_single_ref
, &cbdata
);
898 refs
= cbdata
.grab_array
;
899 num_refs
= cbdata
.grab_cnt
;
901 for (i
= 0; i
< used_atom_cnt
; i
++) {
902 if (used_atom
[i
][0] == '*') {
908 sort_refs(sort
, refs
, num_refs
);
910 if (!maxcount
|| num_refs
< maxcount
)
912 for (i
= 0; i
< maxcount
; i
++)
913 show_ref(refs
[i
], format
, quote_style
);