builtin/show-branch.c

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