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 struct grab_ref_cbdata {
 589         struct refinfo **grab_array;
 590         const char **grab_pattern;
 591         int grab_cnt;
 592 };
 593
 594 /*
 595  * A call-back given to for_each_ref().  It is unfortunate that we
 596  * need to use global variables to pass extra information to this
 597  * function.
 598  */
 599 static int grab_single_ref(const char *refname, const unsigned char *sha1, int flag, void *cb_data)
 600 {
 601         struct grab_ref_cbdata *cb = cb_data;
 602         struct refinfo *ref;
 603         int cnt;
 604
 605         if (*cb->grab_pattern) {
 606                 const char **pattern;
 607                 int namelen = strlen(refname);
 608                 for (pattern = cb->grab_pattern; *pattern; pattern++) {
 609                         const char *p = *pattern;
 610                         int plen = strlen(p);
 611
 612                         if ((plen <= namelen) &&
 613                             !strncmp(refname, p, plen) &&
 614                             (refname[plen] == '\0' ||
 615                              refname[plen] == '/'))
 616                                 break;
 617                         if (!fnmatch(p, refname, FNM_PATHNAME))
 618                                 break;
 619                 }
 620                 if (!*pattern)
 621                         return 0;
 622         }
 623
 624         /* We do not open the object yet; sort may only need refname
 625          * to do its job and the resulting list may yet to be pruned
 626          * by maxcount logic.
 627          */
 628         ref = xcalloc(1, sizeof(*ref));
 629         ref->refname = xstrdup(refname);
 630         hashcpy(ref->objectname, sha1);
 631
 632         cnt = cb->grab_cnt;
 633         cb->grab_array = xrealloc(cb->grab_array,
 634                                   sizeof(*cb->grab_array) * (cnt + 1));
 635         cb->grab_array[cnt++] = ref;
 636         cb->grab_cnt = cnt;
 637         return 0;
 638 }
 639
 640 static int cmp_ref_sort(struct ref_sort *s, struct refinfo *a, struct refinfo *b)
 641 {
 642         struct atom_value *va, *vb;
 643         int cmp;
 644         cmp_type cmp_type = used_atom_type[s->atom];
 645
 646         get_value(a, s->atom, &va);
 647         get_value(b, s->atom, &vb);
 648         switch (cmp_type) {
 649         case FIELD_STR:
 650                 cmp = strcmp(va->s, vb->s);
 651                 break;
 652         default:
 653                 if (va->ul < vb->ul)
 654                         cmp = -1;
 655                 else if (va->ul == vb->ul)
 656                         cmp = 0;
 657                 else
 658                         cmp = 1;
 659                 break;
 660         }
 661         return (s->reverse) ? -cmp : cmp;
 662 }
 663
 664 static struct ref_sort *ref_sort;
 665 static int compare_refs(const void *a_, const void *b_)
 666 {
 667         struct refinfo *a = *((struct refinfo **)a_);
 668         struct refinfo *b = *((struct refinfo **)b_);
 669         struct ref_sort *s;
 670
 671         for (s = ref_sort; s; s = s->next) {
 672                 int cmp = cmp_ref_sort(s, a, b);
 673                 if (cmp)
 674                         return cmp;
 675         }
 676         return 0;
 677 }
 678
 679 static void sort_refs(struct ref_sort *sort, struct refinfo **refs, int num_refs)
 680 {
 681         ref_sort = sort;
 682         qsort(refs, num_refs, sizeof(struct refinfo *), compare_refs);
 683 }
 684
 685 static void print_value(struct refinfo *ref, int atom, int quote_style)
 686 {
 687         struct atom_value *v;
 688         get_value(ref, atom, &v);
 689         switch (quote_style) {
 690         case QUOTE_NONE:
 691                 fputs(v->s, stdout);
 692                 break;
 693         case QUOTE_SHELL:
 694                 sq_quote_print(stdout, v->s);
 695                 break;
 696         case QUOTE_PERL:
 697                 perl_quote_print(stdout, v->s);
 698                 break;
 699         case QUOTE_PYTHON:
 700                 python_quote_print(stdout, v->s);
 701                 break;
 702         }
 703 }
 704
 705 static int hex1(char ch)
 706 {
 707         if ('0' <= ch && ch <= '9')
 708                 return ch - '0';
 709         else if ('a' <= ch && ch <= 'f')
 710                 return ch - 'a' + 10;
 711         else if ('A' <= ch && ch <= 'F')
 712                 return ch - 'A' + 10;
 713         return -1;
 714 }
 715 static int hex2(const char *cp)
 716 {
 717         if (cp[0] && cp[1])
 718                 return (hex1(cp[0]) << 4) | hex1(cp[1]);
 719         else
 720                 return -1;
 721 }
 722
 723 static void emit(const char *cp, const char *ep)
 724 {
 725         while (*cp && (!ep || cp < ep)) {
 726                 if (*cp == '%') {
 727                         if (cp[1] == '%')
 728                                 cp++;
 729                         else {
 730                                 int ch = hex2(cp + 1);
 731                                 if (0 <= ch) {
 732                                         putchar(ch);
 733                                         cp += 3;
 734                                         continue;
 735                                 }
 736                         }
 737                 }
 738                 putchar(*cp);
 739                 cp++;
 740         }
 741 }
 742
 743 static void show_ref(struct refinfo *info, const char *format, int quote_style)
 744 {
 745         const char *cp, *sp, *ep;
 746
 747         for (cp = format; *cp && (sp = find_next(cp)); cp = ep + 1) {
 748                 ep = strchr(sp, ')');
 749                 if (cp < sp)
 750                         emit(cp, sp);
 751                 print_value(info, parse_atom(sp + 2, ep), quote_style);
 752         }
 753         if (*cp) {
 754                 sp = cp + strlen(cp);
 755                 emit(cp, sp);
 756         }
 757         putchar('\n');
 758 }
 759
 760 static struct ref_sort *default_sort(void)
 761 {
 762         static const char cstr_name[] = "refname";
 763
 764         struct ref_sort *sort = xcalloc(1, sizeof(*sort));
 765
 766         sort->next = NULL;
 767         sort->atom = parse_atom(cstr_name, cstr_name + strlen(cstr_name));
 768         return sort;
 769 }
 770
 771 int cmd_for_each_ref(int ac, const char **av, char *prefix)
 772 {
 773         int i, num_refs;
 774         const char *format = NULL;
 775         struct ref_sort *sort = NULL, **sort_tail = &sort;
 776         int maxcount = 0;
 777         int quote_style = -1; /* unspecified yet */
 778         struct refinfo **refs;
 779         struct grab_ref_cbdata cbdata;
 780
 781         for (i = 1; i < ac; i++) {
 782                 const char *arg = av[i];
 783                 if (arg[0] != '-')
 784                         break;
 785                 if (!strcmp(arg, "--")) {
 786                         i++;
 787                         break;
 788                 }
 789                 if (!strncmp(arg, "--format=", 9)) {
 790                         if (format)
 791                                 die("more than one --format?");
 792                         format = arg + 9;
 793                         continue;
 794                 }
 795                 if (!strcmp(arg, "-s") || !strcmp(arg, "--shell") ) {
 796                         if (0 <= quote_style)
 797                                 die("more than one quoting style?");
 798                         quote_style = QUOTE_SHELL;
 799                         continue;
 800                 }
 801                 if (!strcmp(arg, "-p") || !strcmp(arg, "--perl") ) {
 802                         if (0 <= quote_style)
 803                                 die("more than one quoting style?");
 804                         quote_style = QUOTE_PERL;
 805                         continue;
 806                 }
 807                 if (!strcmp(arg, "--python") ) {
 808                         if (0 <= quote_style)
 809                                 die("more than one quoting style?");
 810                         quote_style = QUOTE_PYTHON;
 811                         continue;
 812                 }
 813                 if (!strncmp(arg, "--count=", 8)) {
 814                         if (maxcount)
 815                                 die("more than one --count?");
 816                         maxcount = atoi(arg + 8);
 817                         if (maxcount <= 0)
 818                                 die("The number %s did not parse", arg);
 819                         continue;
 820                 }
 821                 if (!strncmp(arg, "--sort=", 7)) {
 822                         struct ref_sort *s = xcalloc(1, sizeof(*s));
 823                         int len;
 824
 825                         s->next = NULL;
 826                         *sort_tail = s;
 827                         sort_tail = &s->next;
 828
 829                         arg += 7;
 830                         if (*arg == '-') {
 831                                 s->reverse = 1;
 832                                 arg++;
 833                         }
 834                         len = strlen(arg);
 835                         sort->atom = parse_atom(arg, arg+len);
 836                         continue;
 837                 }
 838                 break;
 839         }
 840         if (quote_style < 0)
 841                 quote_style = QUOTE_NONE;
 842
 843         if (!sort)
 844                 sort = default_sort();
 845         sort_atom_limit = used_atom_cnt;
 846         if (!format)
 847                 format = "%(objectname) %(objecttype)\t%(refname)";
 848
 849         verify_format(format);
 850
 851         memset(&cbdata, 0, sizeof(cbdata));
 852         cbdata.grab_pattern = av + i;
 853         for_each_ref(grab_single_ref, &cbdata);
 854         refs = cbdata.grab_array;
 855         num_refs = cbdata.grab_cnt;
 856
 857         for (i = 0; i < used_atom_cnt; i++) {
 858                 if (used_atom[i][0] == '*') {
 859                         need_tagged = 1;
 860                         break;
 861                 }
 862         }
 863
 864         sort_refs(sort, refs, num_refs);
 865
 866         if (!maxcount || num_refs < maxcount)
 867                 maxcount = num_refs;
 868         for (i = 0; i < maxcount; i++)
 869                 show_ref(refs[i], format, quote_style);
 870         return 0;
 871 }