builtin-show-branch.c

   1 #include "cache.h"
   2 #include "commit.h"
   3 #include "refs.h"
   4 #include "builtin.h"
   5
   6 static const char show_branch_usage[] =
   7 "git-show-branch [--sparse] [--current] [--all] [--remotes] [--topo-order] [--more=count | --list | --independent | --merge-base ] [--topics] [<refs>...] | --reflog[=n] <branch>";
   8
   9 static int default_num;
  10 static int default_alloc;
  11 static const char **default_arg;
  12
  13 #define UNINTERESTING   01
  14
  15 #define REV_SHIFT        2
  16 #define MAX_REVS        (FLAG_BITS - REV_SHIFT) /* should not exceed bits_per_int - REV_SHIFT */
  17
  18 #define DEFAULT_REFLOG  4
  19
  20 static struct commit *interesting(struct commit_list *list)
  21 {
  22         while (list) {
  23                 struct commit *commit = list->item;
  24                 list = list->next;
  25                 if (commit->object.flags & UNINTERESTING)
  26                         continue;
  27                 return commit;
  28         }
  29         return NULL;
  30 }
  31
  32 static struct commit *pop_one_commit(struct commit_list **list_p)
  33 {
  34         struct commit *commit;
  35         struct commit_list *list;
  36         list = *list_p;
  37         commit = list->item;
  38         *list_p = list->next;
  39         free(list);
  40         return commit;
  41 }
  42
  43 struct commit_name {
  44         const char *head_name; /* which head's ancestor? */
  45         int generation; /* how many parents away from head_name */
  46 };
  47
  48 /* Name the commit as nth generation ancestor of head_name;
  49  * we count only the first-parent relationship for naming purposes.
  50  */
  51 static void name_commit(struct commit *commit, const char *head_name, int nth)
  52 {
  53         struct commit_name *name;
  54         if (!commit->util)
  55                 commit->util = xmalloc(sizeof(struct commit_name));
  56         name = commit->util;
  57         name->head_name = head_name;
  58         name->generation = nth;
  59 }
  60
  61 /* Parent is the first parent of the commit.  We may name it
  62  * as (n+1)th generation ancestor of the same head_name as
  63  * commit is nth generation ancestor of, if that generation
  64  * number is better than the name it already has.
  65  */
  66 static void name_parent(struct commit *commit, struct commit *parent)
  67 {
  68         struct commit_name *commit_name = commit->util;
  69         struct commit_name *parent_name = parent->util;
  70         if (!commit_name)
  71                 return;
  72         if (!parent_name ||
  73             commit_name->generation + 1 < parent_name->generation)
  74                 name_commit(parent, commit_name->head_name,
  75                             commit_name->generation + 1);
  76 }
  77
  78 static int name_first_parent_chain(struct commit *c)
  79 {
  80         int i = 0;
  81         while (c) {
  82                 struct commit *p;
  83                 if (!c->util)
  84                         break;
  85                 if (!c->parents)
  86                         break;
  87                 p = c->parents->item;
  88                 if (!p->util) {
  89                         name_parent(c, p);
  90                         i++;
  91                 }
  92                 else
  93                         break;
  94                 c = p;
  95         }
  96         return i;
  97 }
  98
  99 static void name_commits(struct commit_list *list,
 100                          struct commit **rev,
 101                          char **ref_name,
 102                          int num_rev)
 103 {
 104         struct commit_list *cl;
 105         struct commit *c;
 106         int i;
 107
 108         /* First give names to the given heads */
 109         for (cl = list; cl; cl = cl->next) {
 110                 c = cl->item;
 111                 if (c->util)
 112                         continue;
 113                 for (i = 0; i < num_rev; i++) {
 114                         if (rev[i] == c) {
 115                                 name_commit(c, ref_name[i], 0);
 116                                 break;
 117                         }
 118                 }
 119         }
 120
 121         /* Then commits on the first parent ancestry chain */
 122         do {
 123                 i = 0;
 124                 for (cl = list; cl; cl = cl->next) {
 125                         i += name_first_parent_chain(cl->item);
 126                 }
 127         } while (i);
 128
 129         /* Finally, any unnamed commits */
 130         do {
 131                 i = 0;
 132                 for (cl = list; cl; cl = cl->next) {
 133                         struct commit_list *parents;
 134                         struct commit_name *n;
 135                         int nth;
 136                         c = cl->item;
 137                         if (!c->util)
 138                                 continue;
 139                         n = c->util;
 140                         parents = c->parents;
 141                         nth = 0;
 142                         while (parents) {
 143                                 struct commit *p = parents->item;
 144                                 char newname[1000], *en;
 145                                 parents = parents->next;
 146                                 nth++;
 147                                 if (p->util)
 148                                         continue;
 149                                 en = newname;
 150                                 switch (n->generation) {
 151                                 case 0:
 152                                         en += sprintf(en, "%s", n->head_name);
 153                                         break;
 154                                 case 1:
 155                                         en += sprintf(en, "%s^", n->head_name);
 156                                         break;
 157                                 default:
 158                                         en += sprintf(en, "%s~%d",
 159                                                 n->head_name, n->generation);
 160                                         break;
 161                                 }
 162                                 if (nth == 1)
 163                                         en += sprintf(en, "^");
 164                                 else
 165                                         en += sprintf(en, "^%d", nth);
 166                                 name_commit(p, xstrdup(newname), 0);
 167                                 i++;
 168                                 name_first_parent_chain(p);
 169                         }
 170                 }
 171         } while (i);
 172 }
 173
 174 static int mark_seen(struct commit *commit, struct commit_list **seen_p)
 175 {
 176         if (!commit->object.flags) {
 177                 commit_list_insert(commit, seen_p);
 178                 return 1;
 179         }
 180         return 0;
 181 }
 182
 183 static void join_revs(struct commit_list **list_p,
 184                       struct commit_list **seen_p,
 185                       int num_rev, int extra)
 186 {
 187         int all_mask = ((1u << (REV_SHIFT + num_rev)) - 1);
 188         int all_revs = all_mask & ~((1u << REV_SHIFT) - 1);
 189
 190         while (*list_p) {
 191                 struct commit_list *parents;
 192                 int still_interesting = !!interesting(*list_p);
 193                 struct commit *commit = pop_one_commit(list_p);
 194                 int flags = commit->object.flags & all_mask;
 195
 196                 if (!still_interesting && extra <= 0)
 197                         break;
 198
 199                 mark_seen(commit, seen_p);
 200                 if ((flags & all_revs) == all_revs)
 201                         flags |= UNINTERESTING;
 202                 parents = commit->parents;
 203
 204                 while (parents) {
 205                         struct commit *p = parents->item;
 206                         int this_flag = p->object.flags;
 207                         parents = parents->next;
 208                         if ((this_flag & flags) == flags)
 209                                 continue;
 210                         if (!p->object.parsed)
 211                                 parse_commit(p);
 212                         if (mark_seen(p, seen_p) && !still_interesting)
 213                                 extra--;
 214                         p->object.flags |= flags;
 215                         insert_by_date(p, list_p);
 216                 }
 217         }
 218
 219         /*
 220          * Postprocess to complete well-poisoning.
 221          *
 222          * At this point we have all the commits we have seen in
 223          * seen_p list.  Mark anything that can be reached from
 224          * uninteresting commits not interesting.
 225          */
 226         for (;;) {
 227                 int changed = 0;
 228                 struct commit_list *s;
 229                 for (s = *seen_p; s; s = s->next) {
 230                         struct commit *c = s->item;
 231                         struct commit_list *parents;
 232
 233                         if (((c->object.flags & all_revs) != all_revs) &&
 234                             !(c->object.flags & UNINTERESTING))
 235                                 continue;
 236
 237                         /* The current commit is either a merge base or
 238                          * already uninteresting one.  Mark its parents
 239                          * as uninteresting commits _only_ if they are
 240                          * already parsed.  No reason to find new ones
 241                          * here.
 242                          */
 243                         parents = c->parents;
 244                         while (parents) {
 245                                 struct commit *p = parents->item;
 246                                 parents = parents->next;
 247                                 if (!(p->object.flags & UNINTERESTING)) {
 248                                         p->object.flags |= UNINTERESTING;
 249                                         changed = 1;
 250                                 }
 251                         }
 252                 }
 253                 if (!changed)
 254                         break;
 255         }
 256 }
 257
 258 static void show_one_commit(struct commit *commit, int no_name)
 259 {
 260         char pretty[256], *cp;
 261         struct commit_name *name = commit->util;
 262         if (commit->object.parsed)
 263                 pretty_print_commit(CMIT_FMT_ONELINE, commit, ~0,
 264                                     pretty, sizeof(pretty), 0, NULL, NULL, 0);
 265         else
 266                 strcpy(pretty, "(unavailable)");
 267         if (!strncmp(pretty, "[PATCH] ", 8))
 268                 cp = pretty + 8;
 269         else
 270                 cp = pretty;
 271
 272         if (!no_name) {
 273                 if (name && name->head_name) {
 274                         printf("[%s", name->head_name);
 275                         if (name->generation) {
 276                                 if (name->generation == 1)
 277                                         printf("^");
 278                                 else
 279                                         printf("~%d", name->generation);
 280                         }
 281                         printf("] ");
 282                 }
 283                 else
 284                         printf("[%s] ",
 285                                find_unique_abbrev(commit->object.sha1, 7));
 286         }
 287         puts(cp);
 288 }
 289
 290 static char *ref_name[MAX_REVS + 1];
 291 static int ref_name_cnt;
 292
 293 static const char *find_digit_prefix(const char *s, int *v)
 294 {
 295         const char *p;
 296         int ver;
 297         char ch;
 298
 299         for (p = s, ver = 0;
 300              '0' <= (ch = *p) && ch <= '9';
 301              p++)
 302                 ver = ver * 10 + ch - '0';
 303         *v = ver;
 304         return p;
 305 }
 306
 307
 308 static int version_cmp(const char *a, const char *b)
 309 {
 310         while (1) {
 311                 int va, vb;
 312
 313                 a = find_digit_prefix(a, &va);
 314                 b = find_digit_prefix(b, &vb);
 315                 if (va != vb)
 316                         return va - vb;
 317
 318                 while (1) {
 319                         int ca = *a;
 320                         int cb = *b;
 321                         if ('0' <= ca && ca <= '9')
 322                                 ca = 0;
 323                         if ('0' <= cb && cb <= '9')
 324                                 cb = 0;
 325                         if (ca != cb)
 326                                 return ca - cb;
 327                         if (!ca)
 328                                 break;
 329                         a++;
 330                         b++;
 331                 }
 332                 if (!*a && !*b)
 333                         return 0;
 334         }
 335 }
 336
 337 static int compare_ref_name(const void *a_, const void *b_)
 338 {
 339         const char * const*a = a_, * const*b = b_;
 340         return version_cmp(*a, *b);
 341 }
 342
 343 static void sort_ref_range(int bottom, int top)
 344 {
 345         qsort(ref_name + bottom, top - bottom, sizeof(ref_name[0]),
 346               compare_ref_name);
 347 }
 348
 349 static int append_ref(const char *refname, const unsigned char *sha1,
 350                       int allow_dups)
 351 {
 352         struct commit *commit = lookup_commit_reference_gently(sha1, 1);
 353         int i;
 354
 355         if (!commit)
 356                 return 0;
 357
 358         if (!allow_dups) {
 359                 /* Avoid adding the same thing twice */
 360                 for (i = 0; i < ref_name_cnt; i++)
 361                         if (!strcmp(refname, ref_name[i]))
 362                                 return 0;
 363         }
 364         if (MAX_REVS <= ref_name_cnt) {
 365                 fprintf(stderr, "warning: ignoring %s; "
 366                         "cannot handle more than %d refs\n",
 367                         refname, MAX_REVS);
 368                 return 0;
 369         }
 370         ref_name[ref_name_cnt++] = xstrdup(refname);
 371         ref_name[ref_name_cnt] = NULL;
 372         return 0;
 373 }
 374
 375 static int append_head_ref(const char *refname, const unsigned char *sha1, int flag, void *cb_data)
 376 {
 377         unsigned char tmp[20];
 378         int ofs = 11;
 379         if (strncmp(refname, "refs/heads/", ofs))
 380                 return 0;
 381         /* If both heads/foo and tags/foo exists, get_sha1 would
 382          * get confused.
 383          */
 384         if (get_sha1(refname + ofs, tmp) || hashcmp(tmp, sha1))
 385                 ofs = 5;
 386         return append_ref(refname + ofs, sha1, 0);
 387 }
 388
 389 static int append_remote_ref(const char *refname, const unsigned char *sha1, int flag, void *cb_data)
 390 {
 391         unsigned char tmp[20];
 392         int ofs = 13;
 393         if (strncmp(refname, "refs/remotes/", ofs))
 394                 return 0;
 395         /* If both heads/foo and tags/foo exists, get_sha1 would
 396          * get confused.
 397          */
 398         if (get_sha1(refname + ofs, tmp) || hashcmp(tmp, sha1))
 399                 ofs = 5;
 400         return append_ref(refname + ofs, sha1, 0);
 401 }
 402
 403 static int append_tag_ref(const char *refname, const unsigned char *sha1, int flag, void *cb_data)
 404 {
 405         if (strncmp(refname, "refs/tags/", 10))
 406                 return 0;
 407         return append_ref(refname + 5, sha1, 0);
 408 }
 409
 410 static const char *match_ref_pattern = NULL;
 411 static int match_ref_slash = 0;
 412 static int count_slash(const char *s)
 413 {
 414         int cnt = 0;
 415         while (*s)
 416                 if (*s++ == '/')
 417                         cnt++;
 418         return cnt;
 419 }
 420
 421 static int append_matching_ref(const char *refname, const unsigned char *sha1, int flag, void *cb_data)
 422 {
 423         /* we want to allow pattern hold/<asterisk> to show all
 424          * branches under refs/heads/hold/, and v0.99.9? to show
 425          * refs/tags/v0.99.9a and friends.
 426          */
 427         const char *tail;
 428         int slash = count_slash(refname);
 429         for (tail = refname; *tail && match_ref_slash < slash; )
 430                 if (*tail++ == '/')
 431                         slash--;
 432         if (!*tail)
 433                 return 0;
 434         if (fnmatch(match_ref_pattern, tail, 0))
 435                 return 0;
 436         if (!strncmp("refs/heads/", refname, 11))
 437                 return append_head_ref(refname, sha1, flag, cb_data);
 438         if (!strncmp("refs/tags/", refname, 10))
 439                 return append_tag_ref(refname, sha1, flag, cb_data);
 440         return append_ref(refname, sha1, 0);
 441 }
 442
 443 static void snarf_refs(int head, int remotes)
 444 {
 445         if (head) {
 446                 int orig_cnt = ref_name_cnt;
 447                 for_each_ref(append_head_ref, NULL);
 448                 sort_ref_range(orig_cnt, ref_name_cnt);
 449         }
 450         if (remotes) {
 451                 int orig_cnt = ref_name_cnt;
 452                 for_each_ref(append_remote_ref, NULL);
 453                 sort_ref_range(orig_cnt, ref_name_cnt);
 454         }
 455 }
 456
 457 static int rev_is_head(char *head, int headlen, char *name,
 458                        unsigned char *head_sha1, unsigned char *sha1)
 459 {
 460         if ((!head[0]) ||
 461             (head_sha1 && sha1 && hashcmp(head_sha1, sha1)))
 462                 return 0;
 463         if (!strncmp(head, "refs/heads/", 11))
 464                 head += 11;
 465         if (!strncmp(name, "refs/heads/", 11))
 466                 name += 11;
 467         else if (!strncmp(name, "heads/", 6))
 468                 name += 6;
 469         return !strcmp(head, name);
 470 }
 471
 472 static int show_merge_base(struct commit_list *seen, int num_rev)
 473 {
 474         int all_mask = ((1u << (REV_SHIFT + num_rev)) - 1);
 475         int all_revs = all_mask & ~((1u << REV_SHIFT) - 1);
 476         int exit_status = 1;
 477
 478         while (seen) {
 479                 struct commit *commit = pop_one_commit(&seen);
 480                 int flags = commit->object.flags & all_mask;
 481                 if (!(flags & UNINTERESTING) &&
 482                     ((flags & all_revs) == all_revs)) {
 483                         puts(sha1_to_hex(commit->object.sha1));
 484                         exit_status = 0;
 485                         commit->object.flags |= UNINTERESTING;
 486                 }
 487         }
 488         return exit_status;
 489 }
 490
 491 static int show_independent(struct commit **rev,
 492                             int num_rev,
 493                             char **ref_name,
 494                             unsigned int *rev_mask)
 495 {
 496         int i;
 497
 498         for (i = 0; i < num_rev; i++) {
 499                 struct commit *commit = rev[i];
 500                 unsigned int flag = rev_mask[i];
 501
 502                 if (commit->object.flags == flag)
 503                         puts(sha1_to_hex(commit->object.sha1));
 504                 commit->object.flags |= UNINTERESTING;
 505         }
 506         return 0;
 507 }
 508
 509 static void append_one_rev(const char *av)
 510 {
 511         unsigned char revkey[20];
 512         if (!get_sha1(av, revkey)) {
 513                 append_ref(av, revkey, 0);
 514                 return;
 515         }
 516         if (strchr(av, '*') || strchr(av, '?') || strchr(av, '[')) {
 517                 /* glob style match */
 518                 int saved_matches = ref_name_cnt;
 519                 match_ref_pattern = av;
 520                 match_ref_slash = count_slash(av);
 521                 for_each_ref(append_matching_ref, NULL);
 522                 if (saved_matches == ref_name_cnt &&
 523                     ref_name_cnt < MAX_REVS)
 524                         error("no matching refs with %s", av);
 525                 if (saved_matches + 1 < ref_name_cnt)
 526                         sort_ref_range(saved_matches, ref_name_cnt);
 527                 return;
 528         }
 529         die("bad sha1 reference %s", av);
 530 }
 531
 532 static int git_show_branch_config(const char *var, const char *value)
 533 {
 534         if (!strcmp(var, "showbranch.default")) {
 535                 if (default_alloc <= default_num + 1) {
 536                         default_alloc = default_alloc * 3 / 2 + 20;
 537                         default_arg = xrealloc(default_arg, sizeof *default_arg * default_alloc);
 538                 }
 539                 default_arg[default_num++] = xstrdup(value);
 540                 default_arg[default_num] = NULL;
 541                 return 0;
 542         }
 543
 544         return git_default_config(var, value);
 545 }
 546
 547 static int omit_in_dense(struct commit *commit, struct commit **rev, int n)
 548 {
 549         /* If the commit is tip of the named branches, do not
 550          * omit it.
 551          * Otherwise, if it is a merge that is reachable from only one
 552          * tip, it is not that interesting.
 553          */
 554         int i, flag, count;
 555         for (i = 0; i < n; i++)
 556                 if (rev[i] == commit)
 557                         return 0;
 558         flag = commit->object.flags;
 559         for (i = count = 0; i < n; i++) {
 560                 if (flag & (1u << (i + REV_SHIFT)))
 561                         count++;
 562         }
 563         if (count == 1)
 564                 return 1;
 565         return 0;
 566 }
 567
 568 static void parse_reflog_param(const char *arg, int *cnt, const char **base)
 569 {
 570         char *ep;
 571         *cnt = strtoul(arg, &ep, 10);
 572         if (*ep == ',')
 573                 *base = ep + 1;
 574         else if (*ep)
 575                 die("unrecognized reflog param '%s'", arg + 9);
 576         else
 577                 *base = NULL;
 578         if (*cnt <= 0)
 579                 *cnt = DEFAULT_REFLOG;
 580 }
 581
 582 int cmd_show_branch(int ac, const char **av, const char *prefix)
 583 {
 584         struct commit *rev[MAX_REVS], *commit;
 585         char *reflog_msg[MAX_REVS];
 586         struct commit_list *list = NULL, *seen = NULL;
 587         unsigned int rev_mask[MAX_REVS];
 588         int num_rev, i, extra = 0;
 589         int all_heads = 0, all_remotes = 0;
 590         int all_mask, all_revs;
 591         int lifo = 1;
 592         char head[128];
 593         const char *head_p;
 594         int head_len;
 595         unsigned char head_sha1[20];
 596         int merge_base = 0;
 597         int independent = 0;
 598         int no_name = 0;
 599         int sha1_name = 0;
 600         int shown_merge_point = 0;
 601         int with_current_branch = 0;
 602         int head_at = -1;
 603         int topics = 0;
 604         int dense = 1;
 605         int reflog = 0;
 606         const char *reflog_base = NULL;
 607
 608         git_config(git_show_branch_config);
 609
 610         /* If nothing is specified, try the default first */
 611         if (ac == 1 && default_num) {
 612                 ac = default_num + 1;
 613                 av = default_arg - 1; /* ick; we would not address av[0] */
 614         }
 615
 616         while (1 < ac && av[1][0] == '-') {
 617                 const char *arg = av[1];
 618                 if (!strcmp(arg, "--")) {
 619                         ac--; av++;
 620                         break;
 621                 }
 622                 else if (!strcmp(arg, "--all") || !strcmp(arg, "-a"))
 623                         all_heads = all_remotes = 1;
 624                 else if (!strcmp(arg, "--remotes") || !strcmp(arg, "-r"))
 625                         all_remotes = 1;
 626                 else if (!strcmp(arg, "--more"))
 627                         extra = 1;
 628                 else if (!strcmp(arg, "--list"))
 629                         extra = -1;
 630                 else if (!strcmp(arg, "--no-name"))
 631                         no_name = 1;
 632                 else if (!strcmp(arg, "--current"))
 633                         with_current_branch = 1;
 634                 else if (!strcmp(arg, "--sha1-name"))
 635                         sha1_name = 1;
 636                 else if (!strncmp(arg, "--more=", 7))
 637                         extra = atoi(arg + 7);
 638                 else if (!strcmp(arg, "--merge-base"))
 639                         merge_base = 1;
 640                 else if (!strcmp(arg, "--independent"))
 641                         independent = 1;
 642                 else if (!strcmp(arg, "--topo-order"))
 643                         lifo = 1;
 644                 else if (!strcmp(arg, "--topics"))
 645                         topics = 1;
 646                 else if (!strcmp(arg, "--sparse"))
 647                         dense = 0;
 648                 else if (!strcmp(arg, "--date-order"))
 649                         lifo = 0;
 650                 else if (!strcmp(arg, "--reflog")) {
 651                         reflog = DEFAULT_REFLOG;
 652                 }
 653                 else if (!strncmp(arg, "--reflog=", 9))
 654                         parse_reflog_param(arg + 9, &reflog, &reflog_base);
 655                 else
 656                         usage(show_branch_usage);
 657                 ac--; av++;
 658         }
 659         ac--; av++;
 660
 661         if (!!extra || !!reflog) {
 662                 /* "listing" mode is incompatible with
 663                  * independent nor merge-base modes.
 664                  */
 665                 if (independent || merge_base)
 666                         usage(show_branch_usage);
 667                 if (!!reflog && (0 < extra))
 668                         /*
 669                          * Asking for --more in reflog mode does not
 670                          * make sense.
 671                          */
 672                         usage(show_branch_usage);
 673         }
 674
 675         /* If nothing is specified, show all branches by default */
 676         if (ac + all_heads + all_remotes == 0)
 677                 all_heads = 1;
 678
 679         if (all_heads + all_remotes)
 680                 snarf_refs(all_heads, all_remotes);
 681         if (reflog) {
 682                 unsigned char sha1[20];
 683                 char nth_desc[256];
 684                 char *ref;
 685                 int base = 0;
 686                 if (ac != 1)
 687                         die("--reflog option needs one branch name");
 688                 if (!dwim_ref(*av, strlen(*av), sha1, &ref))
 689                         die("No such ref %s", *av);
 690
 691                 /* Has the base been specified? */
 692                 if (reflog_base) {
 693                         char *ep;
 694                         base = strtoul(reflog_base, &ep, 10);
 695                         if (*ep) {
 696                                 /* Ah, that is a date spec... */
 697                                 unsigned long at;
 698                                 at = approxidate(reflog_base);
 699                                 read_ref_at(ref, at, -1, sha1, NULL,
 700                                             NULL, NULL, &base);
 701                         }
 702                 }
 703
 704                 for (i = 0; i < reflog; i++) {
 705                         char *logmsg, *msg, *m;
 706                         unsigned long timestamp;
 707                         int tz;
 708
 709                         if (read_ref_at(ref, 0, base+i, sha1, &logmsg,
 710                                         &timestamp, &tz, NULL)) {
 711                                 reflog = i;
 712                                 break;
 713                         }
 714                         msg = strchr(logmsg, '\t');
 715                         if (!msg)
 716                                 msg = "(none)";
 717                         else
 718                                 msg++;
 719                         m = xmalloc(strlen(msg) + 200);
 720                         sprintf(m, "(%s) %s",
 721                                 show_date(timestamp, 0, 1),
 722                                 msg);
 723                         reflog_msg[i] = m;
 724                         free(logmsg);
 725                         sprintf(nth_desc, "%s@{%d}", *av, base+i);
 726                         append_ref(nth_desc, sha1, 1);
 727                 }
 728         }
 729         else {
 730                 while (0 < ac) {
 731                         append_one_rev(*av);
 732                         ac--; av++;
 733                 }
 734         }
 735
 736         head_p = resolve_ref("HEAD", head_sha1, 1, NULL);
 737         if (head_p) {
 738                 head_len = strlen(head_p);
 739                 memcpy(head, head_p, head_len + 1);
 740         }
 741         else {
 742                 head_len = 0;
 743                 head[0] = 0;
 744         }
 745
 746         if (with_current_branch && head_p) {
 747                 int has_head = 0;
 748                 for (i = 0; !has_head && i < ref_name_cnt; i++) {
 749                         /* We are only interested in adding the branch
 750                          * HEAD points at.
 751                          */
 752                         if (rev_is_head(head,
 753                                         head_len,
 754                                         ref_name[i],
 755                                         head_sha1, NULL))
 756                                 has_head++;
 757                 }
 758                 if (!has_head) {
 759                         int pfxlen = strlen("refs/heads/");
 760                         append_one_rev(head + pfxlen);
 761                 }
 762         }
 763
 764         if (!ref_name_cnt) {
 765                 fprintf(stderr, "No revs to be shown.\n");
 766                 exit(0);
 767         }
 768
 769         for (num_rev = 0; ref_name[num_rev]; num_rev++) {
 770                 unsigned char revkey[20];
 771                 unsigned int flag = 1u << (num_rev + REV_SHIFT);
 772
 773                 if (MAX_REVS <= num_rev)
 774                         die("cannot handle more than %d revs.", MAX_REVS);
 775                 if (get_sha1(ref_name[num_rev], revkey))
 776                         die("'%s' is not a valid ref.", ref_name[num_rev]);
 777                 commit = lookup_commit_reference(revkey);
 778                 if (!commit)
 779                         die("cannot find commit %s (%s)",
 780                             ref_name[num_rev], revkey);
 781                 parse_commit(commit);
 782                 mark_seen(commit, &seen);
 783
 784                 /* rev#0 uses bit REV_SHIFT, rev#1 uses bit REV_SHIFT+1,
 785                  * and so on.  REV_SHIFT bits from bit 0 are used for
 786                  * internal bookkeeping.
 787                  */
 788                 commit->object.flags |= flag;
 789                 if (commit->object.flags == flag)
 790                         insert_by_date(commit, &list);
 791                 rev[num_rev] = commit;
 792         }
 793         for (i = 0; i < num_rev; i++)
 794                 rev_mask[i] = rev[i]->object.flags;
 795
 796         if (0 <= extra)
 797                 join_revs(&list, &seen, num_rev, extra);
 798
 799         sort_by_date(&seen);
 800
 801         if (merge_base)
 802                 return show_merge_base(seen, num_rev);
 803
 804         if (independent)
 805                 return show_independent(rev, num_rev, ref_name, rev_mask);
 806
 807         /* Show list; --more=-1 means list-only */
 808         if (1 < num_rev || extra < 0) {
 809                 for (i = 0; i < num_rev; i++) {
 810                         int j;
 811                         int is_head = rev_is_head(head,
 812                                                   head_len,
 813                                                   ref_name[i],
 814                                                   head_sha1,
 815                                                   rev[i]->object.sha1);
 816                         if (extra < 0)
 817                                 printf("%c [%s] ",
 818                                        is_head ? '*' : ' ', ref_name[i]);
 819                         else {
 820                                 for (j = 0; j < i; j++)
 821                                         putchar(' ');
 822                                 printf("%c [%s] ",
 823                                        is_head ? '*' : '!', ref_name[i]);
 824                         }
 825
 826                         if (!reflog) {
 827                                 /* header lines never need name */
 828                                 show_one_commit(rev[i], 1);
 829                         }
 830                         else
 831                                 puts(reflog_msg[i]);
 832
 833                         if (is_head)
 834                                 head_at = i;
 835                 }
 836                 if (0 <= extra) {
 837                         for (i = 0; i < num_rev; i++)
 838                                 putchar('-');
 839                         putchar('\n');
 840                 }
 841         }
 842         if (extra < 0)
 843                 exit(0);
 844
 845         /* Sort topologically */
 846         sort_in_topological_order(&seen, lifo);
 847
 848         /* Give names to commits */
 849         if (!sha1_name && !no_name)
 850                 name_commits(seen, rev, ref_name, num_rev);
 851
 852         all_mask = ((1u << (REV_SHIFT + num_rev)) - 1);
 853         all_revs = all_mask & ~((1u << REV_SHIFT) - 1);
 854
 855         while (seen) {
 856                 struct commit *commit = pop_one_commit(&seen);
 857                 int this_flag = commit->object.flags;
 858                 int is_merge_point = ((this_flag & all_revs) == all_revs);
 859
 860                 shown_merge_point |= is_merge_point;
 861
 862                 if (1 < num_rev) {
 863                         int is_merge = !!(commit->parents &&
 864                                           commit->parents->next);
 865                         if (topics &&
 866                             !is_merge_point &&
 867                             (this_flag & (1u << REV_SHIFT)))
 868                                 continue;
 869                         if (dense && is_merge &&
 870                             omit_in_dense(commit, rev, num_rev))
 871                                 continue;
 872                         for (i = 0; i < num_rev; i++) {
 873                                 int mark;
 874                                 if (!(this_flag & (1u << (i + REV_SHIFT))))
 875                                         mark = ' ';
 876                                 else if (is_merge)
 877                                         mark = '-';
 878                                 else if (i == head_at)
 879                                         mark = '*';
 880                                 else
 881                                         mark = '+';
 882                                 putchar(mark);
 883                         }
 884                         putchar(' ');
 885                 }
 886                 show_one_commit(commit, no_name);
 887
 888                 if (shown_merge_point && --extra < 0)
 889                         break;
 890         }
 891         return 0;
 892 }