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