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