builtin/show-branch.c

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