builtin / log.con commit Merge branch 'fc/makefile' (0846fe1)
   1/*
   2 * Builtin "git log" and related commands (show, whatchanged)
   3 *
   4 * (C) Copyright 2006 Linus Torvalds
   5 *               2006 Junio Hamano
   6 */
   7#include "cache.h"
   8#include "color.h"
   9#include "commit.h"
  10#include "diff.h"
  11#include "revision.h"
  12#include "log-tree.h"
  13#include "builtin.h"
  14#include "tag.h"
  15#include "reflog-walk.h"
  16#include "patch-ids.h"
  17#include "run-command.h"
  18#include "shortlog.h"
  19#include "remote.h"
  20#include "string-list.h"
  21#include "parse-options.h"
  22#include "line-log.h"
  23#include "branch.h"
  24#include "streaming.h"
  25#include "version.h"
  26#include "mailmap.h"
  27#include "gpg-interface.h"
  28
  29/* Set a default date-time format for git log ("log.date" config variable) */
  30static const char *default_date_mode = NULL;
  31
  32static int default_abbrev_commit;
  33static int default_show_root = 1;
  34static int decoration_style;
  35static int decoration_given;
  36static int use_mailmap_config;
  37static const char *fmt_patch_subject_prefix = "PATCH";
  38static const char *fmt_pretty;
  39
  40static const char * const builtin_log_usage[] = {
  41        N_("git log [<options>] [<revision range>] [[--] <path>...]\n")
  42        N_("   or: git show [options] <object>..."),
  43        NULL
  44};
  45
  46struct line_opt_callback_data {
  47        struct rev_info *rev;
  48        const char *prefix;
  49        struct string_list args;
  50};
  51
  52static int parse_decoration_style(const char *var, const char *value)
  53{
  54        switch (git_config_maybe_bool(var, value)) {
  55        case 1:
  56                return DECORATE_SHORT_REFS;
  57        case 0:
  58                return 0;
  59        default:
  60                break;
  61        }
  62        if (!strcmp(value, "full"))
  63                return DECORATE_FULL_REFS;
  64        else if (!strcmp(value, "short"))
  65                return DECORATE_SHORT_REFS;
  66        return -1;
  67}
  68
  69static int decorate_callback(const struct option *opt, const char *arg, int unset)
  70{
  71        if (unset)
  72                decoration_style = 0;
  73        else if (arg)
  74                decoration_style = parse_decoration_style("command line", arg);
  75        else
  76                decoration_style = DECORATE_SHORT_REFS;
  77
  78        if (decoration_style < 0)
  79                die("invalid --decorate option: %s", arg);
  80
  81        decoration_given = 1;
  82
  83        return 0;
  84}
  85
  86static int log_line_range_callback(const struct option *option, const char *arg, int unset)
  87{
  88        struct line_opt_callback_data *data = option->value;
  89
  90        if (!arg)
  91                return -1;
  92
  93        data->rev->line_level_traverse = 1;
  94        string_list_append(&data->args, arg);
  95
  96        return 0;
  97}
  98
  99static void cmd_log_init_defaults(struct rev_info *rev)
 100{
 101        if (fmt_pretty)
 102                get_commit_format(fmt_pretty, rev);
 103        rev->verbose_header = 1;
 104        DIFF_OPT_SET(&rev->diffopt, RECURSIVE);
 105        rev->diffopt.stat_width = -1; /* use full terminal width */
 106        rev->diffopt.stat_graph_width = -1; /* respect statGraphWidth config */
 107        rev->abbrev_commit = default_abbrev_commit;
 108        rev->show_root_diff = default_show_root;
 109        rev->subject_prefix = fmt_patch_subject_prefix;
 110        DIFF_OPT_SET(&rev->diffopt, ALLOW_TEXTCONV);
 111
 112        if (default_date_mode)
 113                rev->date_mode = parse_date_format(default_date_mode);
 114}
 115
 116static void cmd_log_init_finish(int argc, const char **argv, const char *prefix,
 117                         struct rev_info *rev, struct setup_revision_opt *opt)
 118{
 119        struct userformat_want w;
 120        int quiet = 0, source = 0, mailmap = 0;
 121        static struct line_opt_callback_data line_cb = {NULL, NULL, STRING_LIST_INIT_DUP};
 122
 123        const struct option builtin_log_options[] = {
 124                OPT_BOOL(0, "quiet", &quiet, N_("suppress diff output")),
 125                OPT_BOOL(0, "source", &source, N_("show source")),
 126                OPT_BOOL(0, "use-mailmap", &mailmap, N_("Use mail map file")),
 127                { OPTION_CALLBACK, 0, "decorate", NULL, NULL, N_("decorate options"),
 128                  PARSE_OPT_OPTARG, decorate_callback},
 129                OPT_CALLBACK('L', NULL, &line_cb, "n,m:file",
 130                             "Process line range n,m in file, counting from 1",
 131                             log_line_range_callback),
 132                OPT_END()
 133        };
 134
 135        line_cb.rev = rev;
 136        line_cb.prefix = prefix;
 137
 138        mailmap = use_mailmap_config;
 139        argc = parse_options(argc, argv, prefix,
 140                             builtin_log_options, builtin_log_usage,
 141                             PARSE_OPT_KEEP_ARGV0 | PARSE_OPT_KEEP_UNKNOWN |
 142                             PARSE_OPT_KEEP_DASHDASH);
 143
 144        if (quiet)
 145                rev->diffopt.output_format |= DIFF_FORMAT_NO_OUTPUT;
 146        argc = setup_revisions(argc, argv, rev, opt);
 147
 148        /* Any arguments at this point are not recognized */
 149        if (argc > 1)
 150                die("unrecognized argument: %s", argv[1]);
 151
 152        memset(&w, 0, sizeof(w));
 153        userformat_find_requirements(NULL, &w);
 154
 155        if (!rev->show_notes_given && (!rev->pretty_given || w.notes))
 156                rev->show_notes = 1;
 157        if (rev->show_notes)
 158                init_display_notes(&rev->notes_opt);
 159
 160        if (rev->diffopt.pickaxe || rev->diffopt.filter)
 161                rev->always_show_header = 0;
 162        if (DIFF_OPT_TST(&rev->diffopt, FOLLOW_RENAMES)) {
 163                rev->always_show_header = 0;
 164                if (rev->diffopt.pathspec.nr != 1)
 165                        usage("git logs can only follow renames on one pathname at a time");
 166        }
 167
 168        if (source)
 169                rev->show_source = 1;
 170
 171        if (mailmap) {
 172                rev->mailmap = xcalloc(1, sizeof(struct string_list));
 173                read_mailmap(rev->mailmap, NULL);
 174        }
 175
 176        if (rev->pretty_given && rev->commit_format == CMIT_FMT_RAW) {
 177                /*
 178                 * "log --pretty=raw" is special; ignore UI oriented
 179                 * configuration variables such as decoration.
 180                 */
 181                if (!decoration_given)
 182                        decoration_style = 0;
 183                if (!rev->abbrev_commit_given)
 184                        rev->abbrev_commit = 0;
 185        }
 186
 187        if (decoration_style) {
 188                rev->show_decorations = 1;
 189                load_ref_decorations(decoration_style);
 190        }
 191
 192        if (rev->line_level_traverse)
 193                line_log_init(rev, line_cb.prefix, &line_cb.args);
 194
 195        setup_pager();
 196}
 197
 198static void cmd_log_init(int argc, const char **argv, const char *prefix,
 199                         struct rev_info *rev, struct setup_revision_opt *opt)
 200{
 201        cmd_log_init_defaults(rev);
 202        cmd_log_init_finish(argc, argv, prefix, rev, opt);
 203}
 204
 205/*
 206 * This gives a rough estimate for how many commits we
 207 * will print out in the list.
 208 */
 209static int estimate_commit_count(struct rev_info *rev, struct commit_list *list)
 210{
 211        int n = 0;
 212
 213        while (list) {
 214                struct commit *commit = list->item;
 215                unsigned int flags = commit->object.flags;
 216                list = list->next;
 217                if (!(flags & (TREESAME | UNINTERESTING)))
 218                        n++;
 219        }
 220        return n;
 221}
 222
 223static void show_early_header(struct rev_info *rev, const char *stage, int nr)
 224{
 225        if (rev->shown_one) {
 226                rev->shown_one = 0;
 227                if (rev->commit_format != CMIT_FMT_ONELINE)
 228                        putchar(rev->diffopt.line_termination);
 229        }
 230        printf(_("Final output: %d %s\n"), nr, stage);
 231}
 232
 233static struct itimerval early_output_timer;
 234
 235static void log_show_early(struct rev_info *revs, struct commit_list *list)
 236{
 237        int i = revs->early_output;
 238        int show_header = 1;
 239
 240        sort_in_topological_order(&list, revs->lifo);
 241        while (list && i) {
 242                struct commit *commit = list->item;
 243                switch (simplify_commit(revs, commit)) {
 244                case commit_show:
 245                        if (show_header) {
 246                                int n = estimate_commit_count(revs, list);
 247                                show_early_header(revs, "incomplete", n);
 248                                show_header = 0;
 249                        }
 250                        log_tree_commit(revs, commit);
 251                        i--;
 252                        break;
 253                case commit_ignore:
 254                        break;
 255                case commit_error:
 256                        return;
 257                }
 258                list = list->next;
 259        }
 260
 261        /* Did we already get enough commits for the early output? */
 262        if (!i)
 263                return;
 264
 265        /*
 266         * ..if no, then repeat it twice a second until we
 267         * do.
 268         *
 269         * NOTE! We don't use "it_interval", because if the
 270         * reader isn't listening, we want our output to be
 271         * throttled by the writing, and not have the timer
 272         * trigger every second even if we're blocked on a
 273         * reader!
 274         */
 275        early_output_timer.it_value.tv_sec = 0;
 276        early_output_timer.it_value.tv_usec = 500000;
 277        setitimer(ITIMER_REAL, &early_output_timer, NULL);
 278}
 279
 280static void early_output(int signal)
 281{
 282        show_early_output = log_show_early;
 283}
 284
 285static void setup_early_output(struct rev_info *rev)
 286{
 287        struct sigaction sa;
 288
 289        /*
 290         * Set up the signal handler, minimally intrusively:
 291         * we only set a single volatile integer word (not
 292         * using sigatomic_t - trying to avoid unnecessary
 293         * system dependencies and headers), and using
 294         * SA_RESTART.
 295         */
 296        memset(&sa, 0, sizeof(sa));
 297        sa.sa_handler = early_output;
 298        sigemptyset(&sa.sa_mask);
 299        sa.sa_flags = SA_RESTART;
 300        sigaction(SIGALRM, &sa, NULL);
 301
 302        /*
 303         * If we can get the whole output in less than a
 304         * tenth of a second, don't even bother doing the
 305         * early-output thing..
 306         *
 307         * This is a one-time-only trigger.
 308         */
 309        early_output_timer.it_value.tv_sec = 0;
 310        early_output_timer.it_value.tv_usec = 100000;
 311        setitimer(ITIMER_REAL, &early_output_timer, NULL);
 312}
 313
 314static void finish_early_output(struct rev_info *rev)
 315{
 316        int n = estimate_commit_count(rev, rev->commits);
 317        signal(SIGALRM, SIG_IGN);
 318        show_early_header(rev, "done", n);
 319}
 320
 321static int cmd_log_walk(struct rev_info *rev)
 322{
 323        struct commit *commit;
 324        int saved_nrl = 0;
 325        int saved_dcctc = 0;
 326
 327        if (rev->early_output)
 328                setup_early_output(rev);
 329
 330        if (prepare_revision_walk(rev))
 331                die(_("revision walk setup failed"));
 332
 333        if (rev->early_output)
 334                finish_early_output(rev);
 335
 336        /*
 337         * For --check and --exit-code, the exit code is based on CHECK_FAILED
 338         * and HAS_CHANGES being accumulated in rev->diffopt, so be careful to
 339         * retain that state information if replacing rev->diffopt in this loop
 340         */
 341        while ((commit = get_revision(rev)) != NULL) {
 342                if (!log_tree_commit(rev, commit) &&
 343                    rev->max_count >= 0)
 344                        /*
 345                         * We decremented max_count in get_revision,
 346                         * but we didn't actually show the commit.
 347                         */
 348                        rev->max_count++;
 349                if (!rev->reflog_info) {
 350                        /* we allow cycles in reflog ancestry */
 351                        free(commit->buffer);
 352                        commit->buffer = NULL;
 353                }
 354                free_commit_list(commit->parents);
 355                commit->parents = NULL;
 356                if (saved_nrl < rev->diffopt.needed_rename_limit)
 357                        saved_nrl = rev->diffopt.needed_rename_limit;
 358                if (rev->diffopt.degraded_cc_to_c)
 359                        saved_dcctc = 1;
 360        }
 361        rev->diffopt.degraded_cc_to_c = saved_dcctc;
 362        rev->diffopt.needed_rename_limit = saved_nrl;
 363
 364        if (rev->diffopt.output_format & DIFF_FORMAT_CHECKDIFF &&
 365            DIFF_OPT_TST(&rev->diffopt, CHECK_FAILED)) {
 366                return 02;
 367        }
 368        return diff_result_code(&rev->diffopt, 0);
 369}
 370
 371static int git_log_config(const char *var, const char *value, void *cb)
 372{
 373        if (!strcmp(var, "format.pretty"))
 374                return git_config_string(&fmt_pretty, var, value);
 375        if (!strcmp(var, "format.subjectprefix"))
 376                return git_config_string(&fmt_patch_subject_prefix, var, value);
 377        if (!strcmp(var, "log.abbrevcommit")) {
 378                default_abbrev_commit = git_config_bool(var, value);
 379                return 0;
 380        }
 381        if (!strcmp(var, "log.date"))
 382                return git_config_string(&default_date_mode, var, value);
 383        if (!strcmp(var, "log.decorate")) {
 384                decoration_style = parse_decoration_style(var, value);
 385                if (decoration_style < 0)
 386                        decoration_style = 0; /* maybe warn? */
 387                return 0;
 388        }
 389        if (!strcmp(var, "log.showroot")) {
 390                default_show_root = git_config_bool(var, value);
 391                return 0;
 392        }
 393        if (!prefixcmp(var, "color.decorate."))
 394                return parse_decorate_color_config(var, 15, value);
 395        if (!strcmp(var, "log.mailmap")) {
 396                use_mailmap_config = git_config_bool(var, value);
 397                return 0;
 398        }
 399
 400        if (grep_config(var, value, cb) < 0)
 401                return -1;
 402        if (git_gpg_config(var, value, cb) < 0)
 403                return -1;
 404        return git_diff_ui_config(var, value, cb);
 405}
 406
 407int cmd_whatchanged(int argc, const char **argv, const char *prefix)
 408{
 409        struct rev_info rev;
 410        struct setup_revision_opt opt;
 411
 412        init_grep_defaults();
 413        git_config(git_log_config, NULL);
 414
 415        init_revisions(&rev, prefix);
 416        rev.diff = 1;
 417        rev.simplify_history = 0;
 418        memset(&opt, 0, sizeof(opt));
 419        opt.def = "HEAD";
 420        opt.revarg_opt = REVARG_COMMITTISH;
 421        cmd_log_init(argc, argv, prefix, &rev, &opt);
 422        if (!rev.diffopt.output_format)
 423                rev.diffopt.output_format = DIFF_FORMAT_RAW;
 424        return cmd_log_walk(&rev);
 425}
 426
 427static void show_tagger(char *buf, int len, struct rev_info *rev)
 428{
 429        struct strbuf out = STRBUF_INIT;
 430        struct pretty_print_context pp = {0};
 431
 432        pp.fmt = rev->commit_format;
 433        pp.date_mode = rev->date_mode;
 434        pp_user_info(&pp, "Tagger", &out, buf, get_log_output_encoding());
 435        printf("%s", out.buf);
 436        strbuf_release(&out);
 437}
 438
 439static int show_blob_object(const unsigned char *sha1, struct rev_info *rev)
 440{
 441        fflush(stdout);
 442        return stream_blob_to_fd(1, sha1, NULL, 0);
 443}
 444
 445static int show_tag_object(const unsigned char *sha1, struct rev_info *rev)
 446{
 447        unsigned long size;
 448        enum object_type type;
 449        char *buf = read_sha1_file(sha1, &type, &size);
 450        int offset = 0;
 451
 452        if (!buf)
 453                return error(_("Could not read object %s"), sha1_to_hex(sha1));
 454
 455        assert(type == OBJ_TAG);
 456        while (offset < size && buf[offset] != '\n') {
 457                int new_offset = offset + 1;
 458                while (new_offset < size && buf[new_offset++] != '\n')
 459                        ; /* do nothing */
 460                if (!prefixcmp(buf + offset, "tagger "))
 461                        show_tagger(buf + offset + 7,
 462                                    new_offset - offset - 7, rev);
 463                offset = new_offset;
 464        }
 465
 466        if (offset < size)
 467                fwrite(buf + offset, size - offset, 1, stdout);
 468        free(buf);
 469        return 0;
 470}
 471
 472static int show_tree_object(const unsigned char *sha1,
 473                const char *base, int baselen,
 474                const char *pathname, unsigned mode, int stage, void *context)
 475{
 476        printf("%s%s\n", pathname, S_ISDIR(mode) ? "/" : "");
 477        return 0;
 478}
 479
 480static void show_rev_tweak_rev(struct rev_info *rev, struct setup_revision_opt *opt)
 481{
 482        if (rev->ignore_merges) {
 483                /* There was no "-m" on the command line */
 484                rev->ignore_merges = 0;
 485                if (!rev->first_parent_only && !rev->combine_merges) {
 486                        /* No "--first-parent", "-c", nor "--cc" */
 487                        rev->combine_merges = 1;
 488                        rev->dense_combined_merges = 1;
 489                }
 490        }
 491        if (!rev->diffopt.output_format)
 492                rev->diffopt.output_format = DIFF_FORMAT_PATCH;
 493}
 494
 495int cmd_show(int argc, const char **argv, const char *prefix)
 496{
 497        struct rev_info rev;
 498        struct object_array_entry *objects;
 499        struct setup_revision_opt opt;
 500        struct pathspec match_all;
 501        int i, count, ret = 0;
 502
 503        init_grep_defaults();
 504        git_config(git_log_config, NULL);
 505
 506        init_pathspec(&match_all, NULL);
 507        init_revisions(&rev, prefix);
 508        rev.diff = 1;
 509        rev.always_show_header = 1;
 510        rev.no_walk = REVISION_WALK_NO_WALK_SORTED;
 511        rev.diffopt.stat_width = -1;    /* Scale to real terminal size */
 512
 513        memset(&opt, 0, sizeof(opt));
 514        opt.def = "HEAD";
 515        opt.tweak = show_rev_tweak_rev;
 516        cmd_log_init(argc, argv, prefix, &rev, &opt);
 517
 518        if (!rev.no_walk)
 519                return cmd_log_walk(&rev);
 520
 521        count = rev.pending.nr;
 522        objects = rev.pending.objects;
 523        for (i = 0; i < count && !ret; i++) {
 524                struct object *o = objects[i].item;
 525                const char *name = objects[i].name;
 526                switch (o->type) {
 527                case OBJ_BLOB:
 528                        ret = show_blob_object(o->sha1, NULL);
 529                        break;
 530                case OBJ_TAG: {
 531                        struct tag *t = (struct tag *)o;
 532
 533                        if (rev.shown_one)
 534                                putchar('\n');
 535                        printf("%stag %s%s\n",
 536                                        diff_get_color_opt(&rev.diffopt, DIFF_COMMIT),
 537                                        t->tag,
 538                                        diff_get_color_opt(&rev.diffopt, DIFF_RESET));
 539                        ret = show_tag_object(o->sha1, &rev);
 540                        rev.shown_one = 1;
 541                        if (ret)
 542                                break;
 543                        o = parse_object(t->tagged->sha1);
 544                        if (!o)
 545                                ret = error(_("Could not read object %s"),
 546                                            sha1_to_hex(t->tagged->sha1));
 547                        objects[i].item = o;
 548                        i--;
 549                        break;
 550                }
 551                case OBJ_TREE:
 552                        if (rev.shown_one)
 553                                putchar('\n');
 554                        printf("%stree %s%s\n\n",
 555                                        diff_get_color_opt(&rev.diffopt, DIFF_COMMIT),
 556                                        name,
 557                                        diff_get_color_opt(&rev.diffopt, DIFF_RESET));
 558                        read_tree_recursive((struct tree *)o, "", 0, 0, &match_all,
 559                                        show_tree_object, NULL);
 560                        rev.shown_one = 1;
 561                        break;
 562                case OBJ_COMMIT:
 563                        rev.pending.nr = rev.pending.alloc = 0;
 564                        rev.pending.objects = NULL;
 565                        add_object_array(o, name, &rev.pending);
 566                        ret = cmd_log_walk(&rev);
 567                        break;
 568                default:
 569                        ret = error(_("Unknown type: %d"), o->type);
 570                }
 571        }
 572        free(objects);
 573        return ret;
 574}
 575
 576/*
 577 * This is equivalent to "git log -g --abbrev-commit --pretty=oneline"
 578 */
 579int cmd_log_reflog(int argc, const char **argv, const char *prefix)
 580{
 581        struct rev_info rev;
 582        struct setup_revision_opt opt;
 583
 584        init_grep_defaults();
 585        git_config(git_log_config, NULL);
 586
 587        init_revisions(&rev, prefix);
 588        init_reflog_walk(&rev.reflog_info);
 589        rev.verbose_header = 1;
 590        memset(&opt, 0, sizeof(opt));
 591        opt.def = "HEAD";
 592        cmd_log_init_defaults(&rev);
 593        rev.abbrev_commit = 1;
 594        rev.commit_format = CMIT_FMT_ONELINE;
 595        rev.use_terminator = 1;
 596        rev.always_show_header = 1;
 597        cmd_log_init_finish(argc, argv, prefix, &rev, &opt);
 598
 599        return cmd_log_walk(&rev);
 600}
 601
 602int cmd_log(int argc, const char **argv, const char *prefix)
 603{
 604        struct rev_info rev;
 605        struct setup_revision_opt opt;
 606
 607        init_grep_defaults();
 608        git_config(git_log_config, NULL);
 609
 610        init_revisions(&rev, prefix);
 611        rev.always_show_header = 1;
 612        memset(&opt, 0, sizeof(opt));
 613        opt.def = "HEAD";
 614        opt.revarg_opt = REVARG_COMMITTISH;
 615        cmd_log_init(argc, argv, prefix, &rev, &opt);
 616        return cmd_log_walk(&rev);
 617}
 618
 619/* format-patch */
 620
 621static const char *fmt_patch_suffix = ".patch";
 622static int numbered = 0;
 623static int auto_number = 1;
 624
 625static char *default_attach = NULL;
 626
 627static struct string_list extra_hdr;
 628static struct string_list extra_to;
 629static struct string_list extra_cc;
 630
 631static void add_header(const char *value)
 632{
 633        struct string_list_item *item;
 634        int len = strlen(value);
 635        while (len && value[len - 1] == '\n')
 636                len--;
 637
 638        if (!strncasecmp(value, "to: ", 4)) {
 639                item = string_list_append(&extra_to, value + 4);
 640                len -= 4;
 641        } else if (!strncasecmp(value, "cc: ", 4)) {
 642                item = string_list_append(&extra_cc, value + 4);
 643                len -= 4;
 644        } else {
 645                item = string_list_append(&extra_hdr, value);
 646        }
 647
 648        item->string[len] = '\0';
 649}
 650
 651#define THREAD_SHALLOW 1
 652#define THREAD_DEEP 2
 653static int thread;
 654static int do_signoff;
 655static const char *signature = git_version_string;
 656static int config_cover_letter;
 657
 658enum {
 659        COVER_UNSET,
 660        COVER_OFF,
 661        COVER_ON,
 662        COVER_AUTO
 663};
 664
 665static int git_format_config(const char *var, const char *value, void *cb)
 666{
 667        if (!strcmp(var, "format.headers")) {
 668                if (!value)
 669                        die(_("format.headers without value"));
 670                add_header(value);
 671                return 0;
 672        }
 673        if (!strcmp(var, "format.suffix"))
 674                return git_config_string(&fmt_patch_suffix, var, value);
 675        if (!strcmp(var, "format.to")) {
 676                if (!value)
 677                        return config_error_nonbool(var);
 678                string_list_append(&extra_to, value);
 679                return 0;
 680        }
 681        if (!strcmp(var, "format.cc")) {
 682                if (!value)
 683                        return config_error_nonbool(var);
 684                string_list_append(&extra_cc, value);
 685                return 0;
 686        }
 687        if (!strcmp(var, "diff.color") || !strcmp(var, "color.diff") ||
 688            !strcmp(var, "color.ui")) {
 689                return 0;
 690        }
 691        if (!strcmp(var, "format.numbered")) {
 692                if (value && !strcasecmp(value, "auto")) {
 693                        auto_number = 1;
 694                        return 0;
 695                }
 696                numbered = git_config_bool(var, value);
 697                auto_number = auto_number && numbered;
 698                return 0;
 699        }
 700        if (!strcmp(var, "format.attach")) {
 701                if (value && *value)
 702                        default_attach = xstrdup(value);
 703                else
 704                        default_attach = xstrdup(git_version_string);
 705                return 0;
 706        }
 707        if (!strcmp(var, "format.thread")) {
 708                if (value && !strcasecmp(value, "deep")) {
 709                        thread = THREAD_DEEP;
 710                        return 0;
 711                }
 712                if (value && !strcasecmp(value, "shallow")) {
 713                        thread = THREAD_SHALLOW;
 714                        return 0;
 715                }
 716                thread = git_config_bool(var, value) && THREAD_SHALLOW;
 717                return 0;
 718        }
 719        if (!strcmp(var, "format.signoff")) {
 720                do_signoff = git_config_bool(var, value);
 721                return 0;
 722        }
 723        if (!strcmp(var, "format.signature"))
 724                return git_config_string(&signature, var, value);
 725        if (!strcmp(var, "format.coverletter")) {
 726                if (value && !strcasecmp(value, "auto")) {
 727                        config_cover_letter = COVER_AUTO;
 728                        return 0;
 729                }
 730                config_cover_letter = git_config_bool(var, value) ? COVER_ON : COVER_OFF;
 731                return 0;
 732        }
 733
 734        return git_log_config(var, value, cb);
 735}
 736
 737static FILE *realstdout = NULL;
 738static const char *output_directory = NULL;
 739static int outdir_offset;
 740
 741static int reopen_stdout(struct commit *commit, const char *subject,
 742                         struct rev_info *rev, int quiet)
 743{
 744        struct strbuf filename = STRBUF_INIT;
 745        int suffix_len = strlen(rev->patch_suffix) + 1;
 746
 747        if (output_directory) {
 748                strbuf_addstr(&filename, output_directory);
 749                if (filename.len >=
 750                    PATH_MAX - FORMAT_PATCH_NAME_MAX - suffix_len)
 751                        return error(_("name of output directory is too long"));
 752                if (filename.buf[filename.len - 1] != '/')
 753                        strbuf_addch(&filename, '/');
 754        }
 755
 756        if (rev->numbered_files)
 757                strbuf_addf(&filename, "%d", rev->nr);
 758        else if (commit)
 759                fmt_output_commit(&filename, commit, rev);
 760        else
 761                fmt_output_subject(&filename, subject, rev);
 762
 763        if (!quiet)
 764                fprintf(realstdout, "%s\n", filename.buf + outdir_offset);
 765
 766        if (freopen(filename.buf, "w", stdout) == NULL)
 767                return error(_("Cannot open patch file %s"), filename.buf);
 768
 769        strbuf_release(&filename);
 770        return 0;
 771}
 772
 773static void get_patch_ids(struct rev_info *rev, struct patch_ids *ids)
 774{
 775        struct rev_info check_rev;
 776        struct commit *commit;
 777        struct object *o1, *o2;
 778        unsigned flags1, flags2;
 779
 780        if (rev->pending.nr != 2)
 781                die(_("Need exactly one range."));
 782
 783        o1 = rev->pending.objects[0].item;
 784        flags1 = o1->flags;
 785        o2 = rev->pending.objects[1].item;
 786        flags2 = o2->flags;
 787
 788        if ((flags1 & UNINTERESTING) == (flags2 & UNINTERESTING))
 789                die(_("Not a range."));
 790
 791        init_patch_ids(ids);
 792
 793        /* given a range a..b get all patch ids for b..a */
 794        init_revisions(&check_rev, rev->prefix);
 795        check_rev.max_parents = 1;
 796        o1->flags ^= UNINTERESTING;
 797        o2->flags ^= UNINTERESTING;
 798        add_pending_object(&check_rev, o1, "o1");
 799        add_pending_object(&check_rev, o2, "o2");
 800        if (prepare_revision_walk(&check_rev))
 801                die(_("revision walk setup failed"));
 802
 803        while ((commit = get_revision(&check_rev)) != NULL) {
 804                add_commit_patch_id(commit, ids);
 805        }
 806
 807        /* reset for next revision walk */
 808        clear_commit_marks((struct commit *)o1,
 809                        SEEN | UNINTERESTING | SHOWN | ADDED);
 810        clear_commit_marks((struct commit *)o2,
 811                        SEEN | UNINTERESTING | SHOWN | ADDED);
 812        o1->flags = flags1;
 813        o2->flags = flags2;
 814}
 815
 816static void gen_message_id(struct rev_info *info, char *base)
 817{
 818        struct strbuf buf = STRBUF_INIT;
 819        strbuf_addf(&buf, "%s.%lu.git.%s", base,
 820                    (unsigned long) time(NULL),
 821                    git_committer_info(IDENT_NO_NAME|IDENT_NO_DATE|IDENT_STRICT));
 822        info->message_id = strbuf_detach(&buf, NULL);
 823}
 824
 825static void print_signature(void)
 826{
 827        if (signature && *signature)
 828                printf("-- \n%s\n\n", signature);
 829}
 830
 831static void add_branch_description(struct strbuf *buf, const char *branch_name)
 832{
 833        struct strbuf desc = STRBUF_INIT;
 834        if (!branch_name || !*branch_name)
 835                return;
 836        read_branch_desc(&desc, branch_name);
 837        if (desc.len) {
 838                strbuf_addch(buf, '\n');
 839                strbuf_add(buf, desc.buf, desc.len);
 840                strbuf_addch(buf, '\n');
 841        }
 842}
 843
 844static char *find_branch_name(struct rev_info *rev)
 845{
 846        int i, positive = -1;
 847        unsigned char branch_sha1[20];
 848        const unsigned char *tip_sha1;
 849        const char *ref;
 850        char *full_ref, *branch = NULL;
 851
 852        for (i = 0; i < rev->cmdline.nr; i++) {
 853                if (rev->cmdline.rev[i].flags & UNINTERESTING)
 854                        continue;
 855                if (positive < 0)
 856                        positive = i;
 857                else
 858                        return NULL;
 859        }
 860        if (positive < 0)
 861                return NULL;
 862        ref = rev->cmdline.rev[positive].name;
 863        tip_sha1 = rev->cmdline.rev[positive].item->sha1;
 864        if (dwim_ref(ref, strlen(ref), branch_sha1, &full_ref) &&
 865            !prefixcmp(full_ref, "refs/heads/") &&
 866            !hashcmp(tip_sha1, branch_sha1))
 867                branch = xstrdup(full_ref + strlen("refs/heads/"));
 868        free(full_ref);
 869        return branch;
 870}
 871
 872static void make_cover_letter(struct rev_info *rev, int use_stdout,
 873                              struct commit *origin,
 874                              int nr, struct commit **list,
 875                              const char *branch_name,
 876                              int quiet)
 877{
 878        const char *committer;
 879        const char *body = "*** SUBJECT HERE ***\n\n*** BLURB HERE ***\n";
 880        const char *msg;
 881        struct shortlog log;
 882        struct strbuf sb = STRBUF_INIT;
 883        int i;
 884        const char *encoding = "UTF-8";
 885        struct diff_options opts;
 886        int need_8bit_cte = 0;
 887        struct pretty_print_context pp = {0};
 888        struct commit *head = list[0];
 889
 890        if (rev->commit_format != CMIT_FMT_EMAIL)
 891                die(_("Cover letter needs email format"));
 892
 893        committer = git_committer_info(0);
 894
 895        if (!use_stdout &&
 896            reopen_stdout(NULL, rev->numbered_files ? NULL : "cover-letter", rev, quiet))
 897                return;
 898
 899        log_write_email_headers(rev, head, &pp.subject, &pp.after_subject,
 900                                &need_8bit_cte);
 901
 902        for (i = 0; !need_8bit_cte && i < nr; i++)
 903                if (has_non_ascii(list[i]->buffer))
 904                        need_8bit_cte = 1;
 905
 906        if (!branch_name)
 907                branch_name = find_branch_name(rev);
 908
 909        msg = body;
 910        pp.fmt = CMIT_FMT_EMAIL;
 911        pp.date_mode = DATE_RFC2822;
 912        pp_user_info(&pp, NULL, &sb, committer, encoding);
 913        pp_title_line(&pp, &msg, &sb, encoding, need_8bit_cte);
 914        pp_remainder(&pp, &msg, &sb, 0);
 915        add_branch_description(&sb, branch_name);
 916        printf("%s\n", sb.buf);
 917
 918        strbuf_release(&sb);
 919
 920        shortlog_init(&log);
 921        log.wrap_lines = 1;
 922        log.wrap = 72;
 923        log.in1 = 2;
 924        log.in2 = 4;
 925        for (i = 0; i < nr; i++)
 926                shortlog_add_commit(&log, list[i]);
 927
 928        shortlog_output(&log);
 929
 930        /*
 931         * We can only do diffstat with a unique reference point
 932         */
 933        if (!origin)
 934                return;
 935
 936        memcpy(&opts, &rev->diffopt, sizeof(opts));
 937        opts.output_format = DIFF_FORMAT_SUMMARY | DIFF_FORMAT_DIFFSTAT;
 938
 939        diff_setup_done(&opts);
 940
 941        diff_tree_sha1(origin->tree->object.sha1,
 942                       head->tree->object.sha1,
 943                       "", &opts);
 944        diffcore_std(&opts);
 945        diff_flush(&opts);
 946
 947        printf("\n");
 948        print_signature();
 949}
 950
 951static const char *clean_message_id(const char *msg_id)
 952{
 953        char ch;
 954        const char *a, *z, *m;
 955
 956        m = msg_id;
 957        while ((ch = *m) && (isspace(ch) || (ch == '<')))
 958                m++;
 959        a = m;
 960        z = NULL;
 961        while ((ch = *m)) {
 962                if (!isspace(ch) && (ch != '>'))
 963                        z = m;
 964                m++;
 965        }
 966        if (!z)
 967                die(_("insane in-reply-to: %s"), msg_id);
 968        if (++z == m)
 969                return a;
 970        return xmemdupz(a, z - a);
 971}
 972
 973static const char *set_outdir(const char *prefix, const char *output_directory)
 974{
 975        if (output_directory && is_absolute_path(output_directory))
 976                return output_directory;
 977
 978        if (!prefix || !*prefix) {
 979                if (output_directory)
 980                        return output_directory;
 981                /* The user did not explicitly ask for "./" */
 982                outdir_offset = 2;
 983                return "./";
 984        }
 985
 986        outdir_offset = strlen(prefix);
 987        if (!output_directory)
 988                return prefix;
 989
 990        return xstrdup(prefix_filename(prefix, outdir_offset,
 991                                       output_directory));
 992}
 993
 994static const char * const builtin_format_patch_usage[] = {
 995        N_("git format-patch [options] [<since> | <revision range>]"),
 996        NULL
 997};
 998
 999static int keep_subject = 0;
1000
1001static int keep_callback(const struct option *opt, const char *arg, int unset)
1002{
1003        ((struct rev_info *)opt->value)->total = -1;
1004        keep_subject = 1;
1005        return 0;
1006}
1007
1008static int subject_prefix = 0;
1009
1010static int subject_prefix_callback(const struct option *opt, const char *arg,
1011                            int unset)
1012{
1013        subject_prefix = 1;
1014        ((struct rev_info *)opt->value)->subject_prefix = arg;
1015        return 0;
1016}
1017
1018static int numbered_cmdline_opt = 0;
1019
1020static int numbered_callback(const struct option *opt, const char *arg,
1021                             int unset)
1022{
1023        *(int *)opt->value = numbered_cmdline_opt = unset ? 0 : 1;
1024        if (unset)
1025                auto_number =  0;
1026        return 0;
1027}
1028
1029static int no_numbered_callback(const struct option *opt, const char *arg,
1030                                int unset)
1031{
1032        return numbered_callback(opt, arg, 1);
1033}
1034
1035static int output_directory_callback(const struct option *opt, const char *arg,
1036                              int unset)
1037{
1038        const char **dir = (const char **)opt->value;
1039        if (*dir)
1040                die(_("Two output directories?"));
1041        *dir = arg;
1042        return 0;
1043}
1044
1045static int thread_callback(const struct option *opt, const char *arg, int unset)
1046{
1047        int *thread = (int *)opt->value;
1048        if (unset)
1049                *thread = 0;
1050        else if (!arg || !strcmp(arg, "shallow"))
1051                *thread = THREAD_SHALLOW;
1052        else if (!strcmp(arg, "deep"))
1053                *thread = THREAD_DEEP;
1054        else
1055                return 1;
1056        return 0;
1057}
1058
1059static int attach_callback(const struct option *opt, const char *arg, int unset)
1060{
1061        struct rev_info *rev = (struct rev_info *)opt->value;
1062        if (unset)
1063                rev->mime_boundary = NULL;
1064        else if (arg)
1065                rev->mime_boundary = arg;
1066        else
1067                rev->mime_boundary = git_version_string;
1068        rev->no_inline = unset ? 0 : 1;
1069        return 0;
1070}
1071
1072static int inline_callback(const struct option *opt, const char *arg, int unset)
1073{
1074        struct rev_info *rev = (struct rev_info *)opt->value;
1075        if (unset)
1076                rev->mime_boundary = NULL;
1077        else if (arg)
1078                rev->mime_boundary = arg;
1079        else
1080                rev->mime_boundary = git_version_string;
1081        rev->no_inline = 0;
1082        return 0;
1083}
1084
1085static int header_callback(const struct option *opt, const char *arg, int unset)
1086{
1087        if (unset) {
1088                string_list_clear(&extra_hdr, 0);
1089                string_list_clear(&extra_to, 0);
1090                string_list_clear(&extra_cc, 0);
1091        } else {
1092            add_header(arg);
1093        }
1094        return 0;
1095}
1096
1097static int to_callback(const struct option *opt, const char *arg, int unset)
1098{
1099        if (unset)
1100                string_list_clear(&extra_to, 0);
1101        else
1102                string_list_append(&extra_to, arg);
1103        return 0;
1104}
1105
1106static int cc_callback(const struct option *opt, const char *arg, int unset)
1107{
1108        if (unset)
1109                string_list_clear(&extra_cc, 0);
1110        else
1111                string_list_append(&extra_cc, arg);
1112        return 0;
1113}
1114
1115int cmd_format_patch(int argc, const char **argv, const char *prefix)
1116{
1117        struct commit *commit;
1118        struct commit **list = NULL;
1119        struct rev_info rev;
1120        struct setup_revision_opt s_r_opt;
1121        int nr = 0, total, i;
1122        int use_stdout = 0;
1123        int start_number = -1;
1124        int just_numbers = 0;
1125        int ignore_if_in_upstream = 0;
1126        int cover_letter = -1;
1127        int boundary_count = 0;
1128        int no_binary_diff = 0;
1129        struct commit *origin = NULL;
1130        const char *in_reply_to = NULL;
1131        struct patch_ids ids;
1132        struct strbuf buf = STRBUF_INIT;
1133        int use_patch_format = 0;
1134        int quiet = 0;
1135        int reroll_count = -1;
1136        char *branch_name = NULL;
1137        const struct option builtin_format_patch_options[] = {
1138                { OPTION_CALLBACK, 'n', "numbered", &numbered, NULL,
1139                            N_("use [PATCH n/m] even with a single patch"),
1140                            PARSE_OPT_NOARG, numbered_callback },
1141                { OPTION_CALLBACK, 'N', "no-numbered", &numbered, NULL,
1142                            N_("use [PATCH] even with multiple patches"),
1143                            PARSE_OPT_NOARG, no_numbered_callback },
1144                OPT_BOOL('s', "signoff", &do_signoff, N_("add Signed-off-by:")),
1145                OPT_BOOL(0, "stdout", &use_stdout,
1146                            N_("print patches to standard out")),
1147                OPT_BOOL(0, "cover-letter", &cover_letter,
1148                            N_("generate a cover letter")),
1149                OPT_BOOL(0, "numbered-files", &just_numbers,
1150                            N_("use simple number sequence for output file names")),
1151                OPT_STRING(0, "suffix", &fmt_patch_suffix, N_("sfx"),
1152                            N_("use <sfx> instead of '.patch'")),
1153                OPT_INTEGER(0, "start-number", &start_number,
1154                            N_("start numbering patches at <n> instead of 1")),
1155                OPT_INTEGER('v', "reroll-count", &reroll_count,
1156                            N_("mark the series as Nth re-roll")),
1157                { OPTION_CALLBACK, 0, "subject-prefix", &rev, N_("prefix"),
1158                            N_("Use [<prefix>] instead of [PATCH]"),
1159                            PARSE_OPT_NONEG, subject_prefix_callback },
1160                { OPTION_CALLBACK, 'o', "output-directory", &output_directory,
1161                            N_("dir"), N_("store resulting files in <dir>"),
1162                            PARSE_OPT_NONEG, output_directory_callback },
1163                { OPTION_CALLBACK, 'k', "keep-subject", &rev, NULL,
1164                            N_("don't strip/add [PATCH]"),
1165                            PARSE_OPT_NOARG | PARSE_OPT_NONEG, keep_callback },
1166                OPT_BOOLEAN(0, "no-binary", &no_binary_diff,
1167                            N_("don't output binary diffs")),
1168                OPT_BOOLEAN(0, "ignore-if-in-upstream", &ignore_if_in_upstream,
1169                            N_("don't include a patch matching a commit upstream")),
1170                { OPTION_BOOLEAN, 'p', "no-stat", &use_patch_format, NULL,
1171                  N_("show patch format instead of default (patch + stat)"),
1172                  PARSE_OPT_NONEG | PARSE_OPT_NOARG },
1173                OPT_GROUP(N_("Messaging")),
1174                { OPTION_CALLBACK, 0, "add-header", NULL, N_("header"),
1175                            N_("add email header"), 0, header_callback },
1176                { OPTION_CALLBACK, 0, "to", NULL, N_("email"), N_("add To: header"),
1177                            0, to_callback },
1178                { OPTION_CALLBACK, 0, "cc", NULL, N_("email"), N_("add Cc: header"),
1179                            0, cc_callback },
1180                OPT_STRING(0, "in-reply-to", &in_reply_to, N_("message-id"),
1181                            N_("make first mail a reply to <message-id>")),
1182                { OPTION_CALLBACK, 0, "attach", &rev, N_("boundary"),
1183                            N_("attach the patch"), PARSE_OPT_OPTARG,
1184                            attach_callback },
1185                { OPTION_CALLBACK, 0, "inline", &rev, N_("boundary"),
1186                            N_("inline the patch"),
1187                            PARSE_OPT_OPTARG | PARSE_OPT_NONEG,
1188                            inline_callback },
1189                { OPTION_CALLBACK, 0, "thread", &thread, N_("style"),
1190                            N_("enable message threading, styles: shallow, deep"),
1191                            PARSE_OPT_OPTARG, thread_callback },
1192                OPT_STRING(0, "signature", &signature, N_("signature"),
1193                            N_("add a signature")),
1194                OPT_BOOLEAN(0, "quiet", &quiet,
1195                            N_("don't print the patch filenames")),
1196                OPT_END()
1197        };
1198
1199        extra_hdr.strdup_strings = 1;
1200        extra_to.strdup_strings = 1;
1201        extra_cc.strdup_strings = 1;
1202        init_grep_defaults();
1203        git_config(git_format_config, NULL);
1204        init_revisions(&rev, prefix);
1205        rev.commit_format = CMIT_FMT_EMAIL;
1206        rev.verbose_header = 1;
1207        rev.diff = 1;
1208        rev.max_parents = 1;
1209        DIFF_OPT_SET(&rev.diffopt, RECURSIVE);
1210        rev.subject_prefix = fmt_patch_subject_prefix;
1211        memset(&s_r_opt, 0, sizeof(s_r_opt));
1212        s_r_opt.def = "HEAD";
1213        s_r_opt.revarg_opt = REVARG_COMMITTISH;
1214
1215        if (default_attach) {
1216                rev.mime_boundary = default_attach;
1217                rev.no_inline = 1;
1218        }
1219
1220        /*
1221         * Parse the arguments before setup_revisions(), or something
1222         * like "git format-patch -o a123 HEAD^.." may fail; a123 is
1223         * possibly a valid SHA1.
1224         */
1225        argc = parse_options(argc, argv, prefix, builtin_format_patch_options,
1226                             builtin_format_patch_usage,
1227                             PARSE_OPT_KEEP_ARGV0 | PARSE_OPT_KEEP_UNKNOWN |
1228                             PARSE_OPT_KEEP_DASHDASH);
1229
1230        if (0 < reroll_count) {
1231                struct strbuf sprefix = STRBUF_INIT;
1232                strbuf_addf(&sprefix, "%s v%d",
1233                            rev.subject_prefix, reroll_count);
1234                rev.reroll_count = reroll_count;
1235                rev.subject_prefix = strbuf_detach(&sprefix, NULL);
1236        }
1237
1238        for (i = 0; i < extra_hdr.nr; i++) {
1239                strbuf_addstr(&buf, extra_hdr.items[i].string);
1240                strbuf_addch(&buf, '\n');
1241        }
1242
1243        if (extra_to.nr)
1244                strbuf_addstr(&buf, "To: ");
1245        for (i = 0; i < extra_to.nr; i++) {
1246                if (i)
1247                        strbuf_addstr(&buf, "    ");
1248                strbuf_addstr(&buf, extra_to.items[i].string);
1249                if (i + 1 < extra_to.nr)
1250                        strbuf_addch(&buf, ',');
1251                strbuf_addch(&buf, '\n');
1252        }
1253
1254        if (extra_cc.nr)
1255                strbuf_addstr(&buf, "Cc: ");
1256        for (i = 0; i < extra_cc.nr; i++) {
1257                if (i)
1258                        strbuf_addstr(&buf, "    ");
1259                strbuf_addstr(&buf, extra_cc.items[i].string);
1260                if (i + 1 < extra_cc.nr)
1261                        strbuf_addch(&buf, ',');
1262                strbuf_addch(&buf, '\n');
1263        }
1264
1265        rev.extra_headers = strbuf_detach(&buf, NULL);
1266
1267        if (start_number < 0)
1268                start_number = 1;
1269
1270        /*
1271         * If numbered is set solely due to format.numbered in config,
1272         * and it would conflict with --keep-subject (-k) from the
1273         * command line, reset "numbered".
1274         */
1275        if (numbered && keep_subject && !numbered_cmdline_opt)
1276                numbered = 0;
1277
1278        if (numbered && keep_subject)
1279                die (_("-n and -k are mutually exclusive."));
1280        if (keep_subject && subject_prefix)
1281                die (_("--subject-prefix and -k are mutually exclusive."));
1282        rev.preserve_subject = keep_subject;
1283
1284        argc = setup_revisions(argc, argv, &rev, &s_r_opt);
1285        if (argc > 1)
1286                die (_("unrecognized argument: %s"), argv[1]);
1287
1288        if (rev.diffopt.output_format & DIFF_FORMAT_NAME)
1289                die(_("--name-only does not make sense"));
1290        if (rev.diffopt.output_format & DIFF_FORMAT_NAME_STATUS)
1291                die(_("--name-status does not make sense"));
1292        if (rev.diffopt.output_format & DIFF_FORMAT_CHECKDIFF)
1293                die(_("--check does not make sense"));
1294
1295        if (!use_patch_format &&
1296                (!rev.diffopt.output_format ||
1297                 rev.diffopt.output_format == DIFF_FORMAT_PATCH))
1298                rev.diffopt.output_format = DIFF_FORMAT_DIFFSTAT | DIFF_FORMAT_SUMMARY;
1299
1300        /* Always generate a patch */
1301        rev.diffopt.output_format |= DIFF_FORMAT_PATCH;
1302
1303        if (!DIFF_OPT_TST(&rev.diffopt, TEXT) && !no_binary_diff)
1304                DIFF_OPT_SET(&rev.diffopt, BINARY);
1305
1306        if (rev.show_notes)
1307                init_display_notes(&rev.notes_opt);
1308
1309        if (!use_stdout)
1310                output_directory = set_outdir(prefix, output_directory);
1311        else
1312                setup_pager();
1313
1314        if (output_directory) {
1315                if (use_stdout)
1316                        die(_("standard output, or directory, which one?"));
1317                if (mkdir(output_directory, 0777) < 0 && errno != EEXIST)
1318                        die_errno(_("Could not create directory '%s'"),
1319                                  output_directory);
1320        }
1321
1322        if (rev.pending.nr == 1) {
1323                int check_head = 0;
1324
1325                if (rev.max_count < 0 && !rev.show_root_diff) {
1326                        /*
1327                         * This is traditional behaviour of "git format-patch
1328                         * origin" that prepares what the origin side still
1329                         * does not have.
1330                         */
1331                        rev.pending.objects[0].item->flags |= UNINTERESTING;
1332                        add_head_to_pending(&rev);
1333                        check_head = 1;
1334                }
1335                /*
1336                 * Otherwise, it is "format-patch -22 HEAD", and/or
1337                 * "format-patch --root HEAD".  The user wants
1338                 * get_revision() to do the usual traversal.
1339                 */
1340
1341                if (!strcmp(rev.pending.objects[0].name, "HEAD"))
1342                        check_head = 1;
1343
1344                if (check_head) {
1345                        unsigned char sha1[20];
1346                        const char *ref;
1347                        ref = resolve_ref_unsafe("HEAD", sha1, 1, NULL);
1348                        if (ref && !prefixcmp(ref, "refs/heads/"))
1349                                branch_name = xstrdup(ref + strlen("refs/heads/"));
1350                        else
1351                                branch_name = xstrdup(""); /* no branch */
1352                }
1353        }
1354
1355        /*
1356         * We cannot move this anywhere earlier because we do want to
1357         * know if --root was given explicitly from the command line.
1358         */
1359        rev.show_root_diff = 1;
1360
1361        if (ignore_if_in_upstream) {
1362                /* Don't say anything if head and upstream are the same. */
1363                if (rev.pending.nr == 2) {
1364                        struct object_array_entry *o = rev.pending.objects;
1365                        if (hashcmp(o[0].item->sha1, o[1].item->sha1) == 0)
1366                                return 0;
1367                }
1368                get_patch_ids(&rev, &ids);
1369        }
1370
1371        if (!use_stdout)
1372                realstdout = xfdopen(xdup(1), "w");
1373
1374        if (prepare_revision_walk(&rev))
1375                die(_("revision walk setup failed"));
1376        rev.boundary = 1;
1377        while ((commit = get_revision(&rev)) != NULL) {
1378                if (commit->object.flags & BOUNDARY) {
1379                        boundary_count++;
1380                        origin = (boundary_count == 1) ? commit : NULL;
1381                        continue;
1382                }
1383
1384                if (ignore_if_in_upstream &&
1385                                has_commit_patch_id(commit, &ids))
1386                        continue;
1387
1388                nr++;
1389                list = xrealloc(list, nr * sizeof(list[0]));
1390                list[nr - 1] = commit;
1391        }
1392        if (nr == 0)
1393                /* nothing to do */
1394                return 0;
1395        total = nr;
1396        if (!keep_subject && auto_number && total > 1)
1397                numbered = 1;
1398        if (numbered)
1399                rev.total = total + start_number - 1;
1400        if (cover_letter == -1) {
1401                if (config_cover_letter == COVER_AUTO)
1402                        cover_letter = (total > 1);
1403                else
1404                        cover_letter = (config_cover_letter == COVER_ON);
1405        }
1406
1407        if (in_reply_to || thread || cover_letter)
1408                rev.ref_message_ids = xcalloc(1, sizeof(struct string_list));
1409        if (in_reply_to) {
1410                const char *msgid = clean_message_id(in_reply_to);
1411                string_list_append(rev.ref_message_ids, msgid);
1412        }
1413        rev.numbered_files = just_numbers;
1414        rev.patch_suffix = fmt_patch_suffix;
1415        if (cover_letter) {
1416                if (thread)
1417                        gen_message_id(&rev, "cover");
1418                make_cover_letter(&rev, use_stdout,
1419                                  origin, nr, list, branch_name, quiet);
1420                total++;
1421                start_number--;
1422        }
1423        rev.add_signoff = do_signoff;
1424        while (0 <= --nr) {
1425                int shown;
1426                commit = list[nr];
1427                rev.nr = total - nr + (start_number - 1);
1428                /* Make the second and subsequent mails replies to the first */
1429                if (thread) {
1430                        /* Have we already had a message ID? */
1431                        if (rev.message_id) {
1432                                /*
1433                                 * For deep threading: make every mail
1434                                 * a reply to the previous one, no
1435                                 * matter what other options are set.
1436                                 *
1437                                 * For shallow threading:
1438                                 *
1439                                 * Without --cover-letter and
1440                                 * --in-reply-to, make every mail a
1441                                 * reply to the one before.
1442                                 *
1443                                 * With --in-reply-to but no
1444                                 * --cover-letter, make every mail a
1445                                 * reply to the <reply-to>.
1446                                 *
1447                                 * With --cover-letter, make every
1448                                 * mail but the cover letter a reply
1449                                 * to the cover letter.  The cover
1450                                 * letter is a reply to the
1451                                 * --in-reply-to, if specified.
1452                                 */
1453                                if (thread == THREAD_SHALLOW
1454                                    && rev.ref_message_ids->nr > 0
1455                                    && (!cover_letter || rev.nr > 1))
1456                                        free(rev.message_id);
1457                                else
1458                                        string_list_append(rev.ref_message_ids,
1459                                                           rev.message_id);
1460                        }
1461                        gen_message_id(&rev, sha1_to_hex(commit->object.sha1));
1462                }
1463
1464                if (!use_stdout &&
1465                    reopen_stdout(rev.numbered_files ? NULL : commit, NULL, &rev, quiet))
1466                        die(_("Failed to create output files"));
1467                shown = log_tree_commit(&rev, commit);
1468                free(commit->buffer);
1469                commit->buffer = NULL;
1470
1471                /* We put one extra blank line between formatted
1472                 * patches and this flag is used by log-tree code
1473                 * to see if it needs to emit a LF before showing
1474                 * the log; when using one file per patch, we do
1475                 * not want the extra blank line.
1476                 */
1477                if (!use_stdout)
1478                        rev.shown_one = 0;
1479                if (shown) {
1480                        if (rev.mime_boundary)
1481                                printf("\n--%s%s--\n\n\n",
1482                                       mime_boundary_leader,
1483                                       rev.mime_boundary);
1484                        else
1485                                print_signature();
1486                }
1487                if (!use_stdout)
1488                        fclose(stdout);
1489        }
1490        free(list);
1491        free(branch_name);
1492        string_list_clear(&extra_to, 0);
1493        string_list_clear(&extra_cc, 0);
1494        string_list_clear(&extra_hdr, 0);
1495        if (ignore_if_in_upstream)
1496                free_patch_ids(&ids);
1497        return 0;
1498}
1499
1500static int add_pending_commit(const char *arg, struct rev_info *revs, int flags)
1501{
1502        unsigned char sha1[20];
1503        if (get_sha1(arg, sha1) == 0) {
1504                struct commit *commit = lookup_commit_reference(sha1);
1505                if (commit) {
1506                        commit->object.flags |= flags;
1507                        add_pending_object(revs, &commit->object, arg);
1508                        return 0;
1509                }
1510        }
1511        return -1;
1512}
1513
1514static const char * const cherry_usage[] = {
1515        N_("git cherry [-v] [<upstream> [<head> [<limit>]]]"),
1516        NULL
1517};
1518
1519static void print_commit(char sign, struct commit *commit, int verbose,
1520                         int abbrev)
1521{
1522        if (!verbose) {
1523                printf("%c %s\n", sign,
1524                       find_unique_abbrev(commit->object.sha1, abbrev));
1525        } else {
1526                struct strbuf buf = STRBUF_INIT;
1527                pp_commit_easy(CMIT_FMT_ONELINE, commit, &buf);
1528                printf("%c %s %s\n", sign,
1529                       find_unique_abbrev(commit->object.sha1, abbrev),
1530                       buf.buf);
1531                strbuf_release(&buf);
1532        }
1533}
1534
1535int cmd_cherry(int argc, const char **argv, const char *prefix)
1536{
1537        struct rev_info revs;
1538        struct patch_ids ids;
1539        struct commit *commit;
1540        struct commit_list *list = NULL;
1541        struct branch *current_branch;
1542        const char *upstream;
1543        const char *head = "HEAD";
1544        const char *limit = NULL;
1545        int verbose = 0, abbrev = 0;
1546
1547        struct option options[] = {
1548                OPT__ABBREV(&abbrev),
1549                OPT__VERBOSE(&verbose, N_("be verbose")),
1550                OPT_END()
1551        };
1552
1553        argc = parse_options(argc, argv, prefix, options, cherry_usage, 0);
1554
1555        switch (argc) {
1556        case 3:
1557                limit = argv[2];
1558                /* FALLTHROUGH */
1559        case 2:
1560                head = argv[1];
1561                /* FALLTHROUGH */
1562        case 1:
1563                upstream = argv[0];
1564                break;
1565        default:
1566                current_branch = branch_get(NULL);
1567                if (!current_branch || !current_branch->merge
1568                                        || !current_branch->merge[0]
1569                                        || !current_branch->merge[0]->dst) {
1570                        fprintf(stderr, _("Could not find a tracked"
1571                                        " remote branch, please"
1572                                        " specify <upstream> manually.\n"));
1573                        usage_with_options(cherry_usage, options);
1574                }
1575
1576                upstream = current_branch->merge[0]->dst;
1577        }
1578
1579        init_revisions(&revs, prefix);
1580        revs.max_parents = 1;
1581
1582        if (add_pending_commit(head, &revs, 0))
1583                die(_("Unknown commit %s"), head);
1584        if (add_pending_commit(upstream, &revs, UNINTERESTING))
1585                die(_("Unknown commit %s"), upstream);
1586
1587        /* Don't say anything if head and upstream are the same. */
1588        if (revs.pending.nr == 2) {
1589                struct object_array_entry *o = revs.pending.objects;
1590                if (hashcmp(o[0].item->sha1, o[1].item->sha1) == 0)
1591                        return 0;
1592        }
1593
1594        get_patch_ids(&revs, &ids);
1595
1596        if (limit && add_pending_commit(limit, &revs, UNINTERESTING))
1597                die(_("Unknown commit %s"), limit);
1598
1599        /* reverse the list of commits */
1600        if (prepare_revision_walk(&revs))
1601                die(_("revision walk setup failed"));
1602        while ((commit = get_revision(&revs)) != NULL) {
1603                commit_list_insert(commit, &list);
1604        }
1605
1606        while (list) {
1607                char sign = '+';
1608
1609                commit = list->item;
1610                if (has_commit_patch_id(commit, &ids))
1611                        sign = '-';
1612                print_commit(sign, commit, verbose, abbrev);
1613                list = list->next;
1614        }
1615
1616        free_patch_ids(&ids);
1617        return 0;
1618}