sequencer.con commit Merge branch 'sb/remove-unused-var-from-builtin-add' (fde61a0)
   1#include "cache.h"
   2#include "lockfile.h"
   3#include "sequencer.h"
   4#include "dir.h"
   5#include "object.h"
   6#include "commit.h"
   7#include "tag.h"
   8#include "run-command.h"
   9#include "exec_cmd.h"
  10#include "utf8.h"
  11#include "cache-tree.h"
  12#include "diff.h"
  13#include "revision.h"
  14#include "rerere.h"
  15#include "merge-recursive.h"
  16#include "refs.h"
  17#include "argv-array.h"
  18
  19#define GIT_REFLOG_ACTION "GIT_REFLOG_ACTION"
  20
  21const char sign_off_header[] = "Signed-off-by: ";
  22static const char cherry_picked_prefix[] = "(cherry picked from commit ";
  23
  24static int is_rfc2822_line(const char *buf, int len)
  25{
  26        int i;
  27
  28        for (i = 0; i < len; i++) {
  29                int ch = buf[i];
  30                if (ch == ':')
  31                        return 1;
  32                if (!isalnum(ch) && ch != '-')
  33                        break;
  34        }
  35
  36        return 0;
  37}
  38
  39static int is_cherry_picked_from_line(const char *buf, int len)
  40{
  41        /*
  42         * We only care that it looks roughly like (cherry picked from ...)
  43         */
  44        return len > strlen(cherry_picked_prefix) + 1 &&
  45                starts_with(buf, cherry_picked_prefix) && buf[len - 1] == ')';
  46}
  47
  48/*
  49 * Returns 0 for non-conforming footer
  50 * Returns 1 for conforming footer
  51 * Returns 2 when sob exists within conforming footer
  52 * Returns 3 when sob exists within conforming footer as last entry
  53 */
  54static int has_conforming_footer(struct strbuf *sb, struct strbuf *sob,
  55        int ignore_footer)
  56{
  57        char prev;
  58        int i, k;
  59        int len = sb->len - ignore_footer;
  60        const char *buf = sb->buf;
  61        int found_sob = 0;
  62
  63        /* footer must end with newline */
  64        if (!len || buf[len - 1] != '\n')
  65                return 0;
  66
  67        prev = '\0';
  68        for (i = len - 1; i > 0; i--) {
  69                char ch = buf[i];
  70                if (prev == '\n' && ch == '\n') /* paragraph break */
  71                        break;
  72                prev = ch;
  73        }
  74
  75        /* require at least one blank line */
  76        if (prev != '\n' || buf[i] != '\n')
  77                return 0;
  78
  79        /* advance to start of last paragraph */
  80        while (i < len - 1 && buf[i] == '\n')
  81                i++;
  82
  83        for (; i < len; i = k) {
  84                int found_rfc2822;
  85
  86                for (k = i; k < len && buf[k] != '\n'; k++)
  87                        ; /* do nothing */
  88                k++;
  89
  90                found_rfc2822 = is_rfc2822_line(buf + i, k - i - 1);
  91                if (found_rfc2822 && sob &&
  92                    !strncmp(buf + i, sob->buf, sob->len))
  93                        found_sob = k;
  94
  95                if (!(found_rfc2822 ||
  96                      is_cherry_picked_from_line(buf + i, k - i - 1)))
  97                        return 0;
  98        }
  99        if (found_sob == i)
 100                return 3;
 101        if (found_sob)
 102                return 2;
 103        return 1;
 104}
 105
 106static void remove_sequencer_state(void)
 107{
 108        struct strbuf seq_dir = STRBUF_INIT;
 109
 110        strbuf_addf(&seq_dir, "%s", git_path(SEQ_DIR));
 111        remove_dir_recursively(&seq_dir, 0);
 112        strbuf_release(&seq_dir);
 113}
 114
 115static const char *action_name(const struct replay_opts *opts)
 116{
 117        return opts->action == REPLAY_REVERT ? "revert" : "cherry-pick";
 118}
 119
 120struct commit_message {
 121        char *parent_label;
 122        const char *label;
 123        const char *subject;
 124        const char *message;
 125};
 126
 127static int get_message(struct commit *commit, struct commit_message *out)
 128{
 129        const char *abbrev, *subject;
 130        int abbrev_len, subject_len;
 131        char *q;
 132
 133        if (!git_commit_encoding)
 134                git_commit_encoding = "UTF-8";
 135
 136        out->message = logmsg_reencode(commit, NULL, git_commit_encoding);
 137        abbrev = find_unique_abbrev(commit->object.sha1, DEFAULT_ABBREV);
 138        abbrev_len = strlen(abbrev);
 139
 140        subject_len = find_commit_subject(out->message, &subject);
 141
 142        out->parent_label = xmalloc(strlen("parent of ") + abbrev_len +
 143                              strlen("... ") + subject_len + 1);
 144        q = out->parent_label;
 145        q = mempcpy(q, "parent of ", strlen("parent of "));
 146        out->label = q;
 147        q = mempcpy(q, abbrev, abbrev_len);
 148        q = mempcpy(q, "... ", strlen("... "));
 149        out->subject = q;
 150        q = mempcpy(q, subject, subject_len);
 151        *q = '\0';
 152        return 0;
 153}
 154
 155static void free_message(struct commit *commit, struct commit_message *msg)
 156{
 157        free(msg->parent_label);
 158        unuse_commit_buffer(commit, msg->message);
 159}
 160
 161static void write_cherry_pick_head(struct commit *commit, const char *pseudoref)
 162{
 163        const char *filename;
 164        int fd;
 165        struct strbuf buf = STRBUF_INIT;
 166
 167        strbuf_addf(&buf, "%s\n", sha1_to_hex(commit->object.sha1));
 168
 169        filename = git_path("%s", pseudoref);
 170        fd = open(filename, O_WRONLY | O_CREAT, 0666);
 171        if (fd < 0)
 172                die_errno(_("Could not open '%s' for writing"), filename);
 173        if (write_in_full(fd, buf.buf, buf.len) != buf.len || close(fd))
 174                die_errno(_("Could not write to '%s'"), filename);
 175        strbuf_release(&buf);
 176}
 177
 178static void print_advice(int show_hint, struct replay_opts *opts)
 179{
 180        char *msg = getenv("GIT_CHERRY_PICK_HELP");
 181
 182        if (msg) {
 183                fprintf(stderr, "%s\n", msg);
 184                /*
 185                 * A conflict has occurred but the porcelain
 186                 * (typically rebase --interactive) wants to take care
 187                 * of the commit itself so remove CHERRY_PICK_HEAD
 188                 */
 189                unlink(git_path("CHERRY_PICK_HEAD"));
 190                return;
 191        }
 192
 193        if (show_hint) {
 194                if (opts->no_commit)
 195                        advise(_("after resolving the conflicts, mark the corrected paths\n"
 196                                 "with 'git add <paths>' or 'git rm <paths>'"));
 197                else
 198                        advise(_("after resolving the conflicts, mark the corrected paths\n"
 199                                 "with 'git add <paths>' or 'git rm <paths>'\n"
 200                                 "and commit the result with 'git commit'"));
 201        }
 202}
 203
 204static void write_message(struct strbuf *msgbuf, const char *filename)
 205{
 206        static struct lock_file msg_file;
 207
 208        int msg_fd = hold_lock_file_for_update(&msg_file, filename,
 209                                               LOCK_DIE_ON_ERROR);
 210        if (write_in_full(msg_fd, msgbuf->buf, msgbuf->len) < 0)
 211                die_errno(_("Could not write to %s"), filename);
 212        strbuf_release(msgbuf);
 213        if (commit_lock_file(&msg_file) < 0)
 214                die(_("Error wrapping up %s"), filename);
 215}
 216
 217static struct tree *empty_tree(void)
 218{
 219        return lookup_tree(EMPTY_TREE_SHA1_BIN);
 220}
 221
 222static int error_dirty_index(struct replay_opts *opts)
 223{
 224        if (read_cache_unmerged())
 225                return error_resolve_conflict(action_name(opts));
 226
 227        /* Different translation strings for cherry-pick and revert */
 228        if (opts->action == REPLAY_PICK)
 229                error(_("Your local changes would be overwritten by cherry-pick."));
 230        else
 231                error(_("Your local changes would be overwritten by revert."));
 232
 233        if (advice_commit_before_merge)
 234                advise(_("Commit your changes or stash them to proceed."));
 235        return -1;
 236}
 237
 238static int fast_forward_to(const unsigned char *to, const unsigned char *from,
 239                        int unborn, struct replay_opts *opts)
 240{
 241        struct ref_transaction *transaction;
 242        struct strbuf sb = STRBUF_INIT;
 243        struct strbuf err = STRBUF_INIT;
 244
 245        read_cache();
 246        if (checkout_fast_forward(from, to, 1))
 247                exit(128); /* the callee should have complained already */
 248
 249        strbuf_addf(&sb, "%s: fast-forward", action_name(opts));
 250
 251        transaction = ref_transaction_begin(&err);
 252        if (!transaction ||
 253            ref_transaction_update(transaction, "HEAD",
 254                                   to, unborn ? null_sha1 : from,
 255                                   0, sb.buf, &err) ||
 256            ref_transaction_commit(transaction, &err)) {
 257                ref_transaction_free(transaction);
 258                error("%s", err.buf);
 259                strbuf_release(&sb);
 260                strbuf_release(&err);
 261                return -1;
 262        }
 263
 264        strbuf_release(&sb);
 265        strbuf_release(&err);
 266        ref_transaction_free(transaction);
 267        return 0;
 268}
 269
 270void append_conflicts_hint(struct strbuf *msgbuf)
 271{
 272        int i;
 273
 274        strbuf_addch(msgbuf, '\n');
 275        strbuf_commented_addf(msgbuf, "Conflicts:\n");
 276        for (i = 0; i < active_nr;) {
 277                const struct cache_entry *ce = active_cache[i++];
 278                if (ce_stage(ce)) {
 279                        strbuf_commented_addf(msgbuf, "\t%s\n", ce->name);
 280                        while (i < active_nr && !strcmp(ce->name,
 281                                                        active_cache[i]->name))
 282                                i++;
 283                }
 284        }
 285}
 286
 287static int do_recursive_merge(struct commit *base, struct commit *next,
 288                              const char *base_label, const char *next_label,
 289                              unsigned char *head, struct strbuf *msgbuf,
 290                              struct replay_opts *opts)
 291{
 292        struct merge_options o;
 293        struct tree *result, *next_tree, *base_tree, *head_tree;
 294        int clean;
 295        const char **xopt;
 296        static struct lock_file index_lock;
 297
 298        hold_locked_index(&index_lock, 1);
 299
 300        read_cache();
 301
 302        init_merge_options(&o);
 303        o.ancestor = base ? base_label : "(empty tree)";
 304        o.branch1 = "HEAD";
 305        o.branch2 = next ? next_label : "(empty tree)";
 306
 307        head_tree = parse_tree_indirect(head);
 308        next_tree = next ? next->tree : empty_tree();
 309        base_tree = base ? base->tree : empty_tree();
 310
 311        for (xopt = opts->xopts; xopt != opts->xopts + opts->xopts_nr; xopt++)
 312                parse_merge_opt(&o, *xopt);
 313
 314        clean = merge_trees(&o,
 315                            head_tree,
 316                            next_tree, base_tree, &result);
 317
 318        if (active_cache_changed &&
 319            write_locked_index(&the_index, &index_lock, COMMIT_LOCK))
 320                /* TRANSLATORS: %s will be "revert" or "cherry-pick" */
 321                die(_("%s: Unable to write new index file"), action_name(opts));
 322        rollback_lock_file(&index_lock);
 323
 324        if (opts->signoff)
 325                append_signoff(msgbuf, 0, 0);
 326
 327        if (!clean)
 328                append_conflicts_hint(msgbuf);
 329
 330        return !clean;
 331}
 332
 333static int is_index_unchanged(void)
 334{
 335        unsigned char head_sha1[20];
 336        struct commit *head_commit;
 337
 338        if (!resolve_ref_unsafe("HEAD", RESOLVE_REF_READING, head_sha1, NULL))
 339                return error(_("Could not resolve HEAD commit\n"));
 340
 341        head_commit = lookup_commit(head_sha1);
 342
 343        /*
 344         * If head_commit is NULL, check_commit, called from
 345         * lookup_commit, would have indicated that head_commit is not
 346         * a commit object already.  parse_commit() will return failure
 347         * without further complaints in such a case.  Otherwise, if
 348         * the commit is invalid, parse_commit() will complain.  So
 349         * there is nothing for us to say here.  Just return failure.
 350         */
 351        if (parse_commit(head_commit))
 352                return -1;
 353
 354        if (!active_cache_tree)
 355                active_cache_tree = cache_tree();
 356
 357        if (!cache_tree_fully_valid(active_cache_tree))
 358                if (cache_tree_update(&the_index, 0))
 359                        return error(_("Unable to update cache tree\n"));
 360
 361        return !hashcmp(active_cache_tree->sha1, head_commit->tree->object.sha1);
 362}
 363
 364/*
 365 * If we are cherry-pick, and if the merge did not result in
 366 * hand-editing, we will hit this commit and inherit the original
 367 * author date and name.
 368 * If we are revert, or if our cherry-pick results in a hand merge,
 369 * we had better say that the current user is responsible for that.
 370 */
 371static int run_git_commit(const char *defmsg, struct replay_opts *opts,
 372                          int allow_empty)
 373{
 374        struct argv_array array;
 375        int rc;
 376        const char *value;
 377
 378        argv_array_init(&array);
 379        argv_array_push(&array, "commit");
 380        argv_array_push(&array, "-n");
 381
 382        if (opts->gpg_sign)
 383                argv_array_pushf(&array, "-S%s", opts->gpg_sign);
 384        if (opts->signoff)
 385                argv_array_push(&array, "-s");
 386        if (!opts->edit) {
 387                argv_array_push(&array, "-F");
 388                argv_array_push(&array, defmsg);
 389                if (!opts->signoff &&
 390                    !opts->record_origin &&
 391                    git_config_get_value("commit.cleanup", &value))
 392                        argv_array_push(&array, "--cleanup=verbatim");
 393        }
 394
 395        if (allow_empty)
 396                argv_array_push(&array, "--allow-empty");
 397
 398        if (opts->allow_empty_message)
 399                argv_array_push(&array, "--allow-empty-message");
 400
 401        rc = run_command_v_opt(array.argv, RUN_GIT_CMD);
 402        argv_array_clear(&array);
 403        return rc;
 404}
 405
 406static int is_original_commit_empty(struct commit *commit)
 407{
 408        const unsigned char *ptree_sha1;
 409
 410        if (parse_commit(commit))
 411                return error(_("Could not parse commit %s\n"),
 412                             sha1_to_hex(commit->object.sha1));
 413        if (commit->parents) {
 414                struct commit *parent = commit->parents->item;
 415                if (parse_commit(parent))
 416                        return error(_("Could not parse parent commit %s\n"),
 417                                sha1_to_hex(parent->object.sha1));
 418                ptree_sha1 = parent->tree->object.sha1;
 419        } else {
 420                ptree_sha1 = EMPTY_TREE_SHA1_BIN; /* commit is root */
 421        }
 422
 423        return !hashcmp(ptree_sha1, commit->tree->object.sha1);
 424}
 425
 426/*
 427 * Do we run "git commit" with "--allow-empty"?
 428 */
 429static int allow_empty(struct replay_opts *opts, struct commit *commit)
 430{
 431        int index_unchanged, empty_commit;
 432
 433        /*
 434         * Three cases:
 435         *
 436         * (1) we do not allow empty at all and error out.
 437         *
 438         * (2) we allow ones that were initially empty, but
 439         * forbid the ones that become empty;
 440         *
 441         * (3) we allow both.
 442         */
 443        if (!opts->allow_empty)
 444                return 0; /* let "git commit" barf as necessary */
 445
 446        index_unchanged = is_index_unchanged();
 447        if (index_unchanged < 0)
 448                return index_unchanged;
 449        if (!index_unchanged)
 450                return 0; /* we do not have to say --allow-empty */
 451
 452        if (opts->keep_redundant_commits)
 453                return 1;
 454
 455        empty_commit = is_original_commit_empty(commit);
 456        if (empty_commit < 0)
 457                return empty_commit;
 458        if (!empty_commit)
 459                return 0;
 460        else
 461                return 1;
 462}
 463
 464static int do_pick_commit(struct commit *commit, struct replay_opts *opts)
 465{
 466        unsigned char head[20];
 467        struct commit *base, *next, *parent;
 468        const char *base_label, *next_label;
 469        struct commit_message msg = { NULL, NULL, NULL, NULL };
 470        char *defmsg = NULL;
 471        struct strbuf msgbuf = STRBUF_INIT;
 472        int res, unborn = 0, allow;
 473
 474        if (opts->no_commit) {
 475                /*
 476                 * We do not intend to commit immediately.  We just want to
 477                 * merge the differences in, so let's compute the tree
 478                 * that represents the "current" state for merge-recursive
 479                 * to work on.
 480                 */
 481                if (write_cache_as_tree(head, 0, NULL))
 482                        die (_("Your index file is unmerged."));
 483        } else {
 484                unborn = get_sha1("HEAD", head);
 485                if (unborn)
 486                        hashcpy(head, EMPTY_TREE_SHA1_BIN);
 487                if (index_differs_from(unborn ? EMPTY_TREE_SHA1_HEX : "HEAD", 0))
 488                        return error_dirty_index(opts);
 489        }
 490        discard_cache();
 491
 492        if (!commit->parents) {
 493                parent = NULL;
 494        }
 495        else if (commit->parents->next) {
 496                /* Reverting or cherry-picking a merge commit */
 497                int cnt;
 498                struct commit_list *p;
 499
 500                if (!opts->mainline)
 501                        return error(_("Commit %s is a merge but no -m option was given."),
 502                                sha1_to_hex(commit->object.sha1));
 503
 504                for (cnt = 1, p = commit->parents;
 505                     cnt != opts->mainline && p;
 506                     cnt++)
 507                        p = p->next;
 508                if (cnt != opts->mainline || !p)
 509                        return error(_("Commit %s does not have parent %d"),
 510                                sha1_to_hex(commit->object.sha1), opts->mainline);
 511                parent = p->item;
 512        } else if (0 < opts->mainline)
 513                return error(_("Mainline was specified but commit %s is not a merge."),
 514                        sha1_to_hex(commit->object.sha1));
 515        else
 516                parent = commit->parents->item;
 517
 518        if (opts->allow_ff &&
 519            ((parent && !hashcmp(parent->object.sha1, head)) ||
 520             (!parent && unborn)))
 521                return fast_forward_to(commit->object.sha1, head, unborn, opts);
 522
 523        if (parent && parse_commit(parent) < 0)
 524                /* TRANSLATORS: The first %s will be "revert" or
 525                   "cherry-pick", the second %s a SHA1 */
 526                return error(_("%s: cannot parse parent commit %s"),
 527                        action_name(opts), sha1_to_hex(parent->object.sha1));
 528
 529        if (get_message(commit, &msg) != 0)
 530                return error(_("Cannot get commit message for %s"),
 531                        sha1_to_hex(commit->object.sha1));
 532
 533        /*
 534         * "commit" is an existing commit.  We would want to apply
 535         * the difference it introduces since its first parent "prev"
 536         * on top of the current HEAD if we are cherry-pick.  Or the
 537         * reverse of it if we are revert.
 538         */
 539
 540        defmsg = git_pathdup("MERGE_MSG");
 541
 542        if (opts->action == REPLAY_REVERT) {
 543                base = commit;
 544                base_label = msg.label;
 545                next = parent;
 546                next_label = msg.parent_label;
 547                strbuf_addstr(&msgbuf, "Revert \"");
 548                strbuf_addstr(&msgbuf, msg.subject);
 549                strbuf_addstr(&msgbuf, "\"\n\nThis reverts commit ");
 550                strbuf_addstr(&msgbuf, sha1_to_hex(commit->object.sha1));
 551
 552                if (commit->parents && commit->parents->next) {
 553                        strbuf_addstr(&msgbuf, ", reversing\nchanges made to ");
 554                        strbuf_addstr(&msgbuf, sha1_to_hex(parent->object.sha1));
 555                }
 556                strbuf_addstr(&msgbuf, ".\n");
 557        } else {
 558                const char *p;
 559
 560                base = parent;
 561                base_label = msg.parent_label;
 562                next = commit;
 563                next_label = msg.label;
 564
 565                /*
 566                 * Append the commit log message to msgbuf; it starts
 567                 * after the tree, parent, author, committer
 568                 * information followed by "\n\n".
 569                 */
 570                p = strstr(msg.message, "\n\n");
 571                if (p) {
 572                        p += 2;
 573                        strbuf_addstr(&msgbuf, p);
 574                }
 575
 576                if (opts->record_origin) {
 577                        if (!has_conforming_footer(&msgbuf, NULL, 0))
 578                                strbuf_addch(&msgbuf, '\n');
 579                        strbuf_addstr(&msgbuf, cherry_picked_prefix);
 580                        strbuf_addstr(&msgbuf, sha1_to_hex(commit->object.sha1));
 581                        strbuf_addstr(&msgbuf, ")\n");
 582                }
 583        }
 584
 585        if (!opts->strategy || !strcmp(opts->strategy, "recursive") || opts->action == REPLAY_REVERT) {
 586                res = do_recursive_merge(base, next, base_label, next_label,
 587                                         head, &msgbuf, opts);
 588                write_message(&msgbuf, defmsg);
 589        } else {
 590                struct commit_list *common = NULL;
 591                struct commit_list *remotes = NULL;
 592
 593                write_message(&msgbuf, defmsg);
 594
 595                commit_list_insert(base, &common);
 596                commit_list_insert(next, &remotes);
 597                res = try_merge_command(opts->strategy, opts->xopts_nr, opts->xopts,
 598                                        common, sha1_to_hex(head), remotes);
 599                free_commit_list(common);
 600                free_commit_list(remotes);
 601        }
 602
 603        /*
 604         * If the merge was clean or if it failed due to conflict, we write
 605         * CHERRY_PICK_HEAD for the subsequent invocation of commit to use.
 606         * However, if the merge did not even start, then we don't want to
 607         * write it at all.
 608         */
 609        if (opts->action == REPLAY_PICK && !opts->no_commit && (res == 0 || res == 1))
 610                write_cherry_pick_head(commit, "CHERRY_PICK_HEAD");
 611        if (opts->action == REPLAY_REVERT && ((opts->no_commit && res == 0) || res == 1))
 612                write_cherry_pick_head(commit, "REVERT_HEAD");
 613
 614        if (res) {
 615                error(opts->action == REPLAY_REVERT
 616                      ? _("could not revert %s... %s")
 617                      : _("could not apply %s... %s"),
 618                      find_unique_abbrev(commit->object.sha1, DEFAULT_ABBREV),
 619                      msg.subject);
 620                print_advice(res == 1, opts);
 621                rerere(opts->allow_rerere_auto);
 622                goto leave;
 623        }
 624
 625        allow = allow_empty(opts, commit);
 626        if (allow < 0) {
 627                res = allow;
 628                goto leave;
 629        }
 630        if (!opts->no_commit)
 631                res = run_git_commit(defmsg, opts, allow);
 632
 633leave:
 634        free_message(commit, &msg);
 635        free(defmsg);
 636
 637        return res;
 638}
 639
 640static void prepare_revs(struct replay_opts *opts)
 641{
 642        /*
 643         * picking (but not reverting) ranges (but not individual revisions)
 644         * should be done in reverse
 645         */
 646        if (opts->action == REPLAY_PICK && !opts->revs->no_walk)
 647                opts->revs->reverse ^= 1;
 648
 649        if (prepare_revision_walk(opts->revs))
 650                die(_("revision walk setup failed"));
 651
 652        if (!opts->revs->commits)
 653                die(_("empty commit set passed"));
 654}
 655
 656static void read_and_refresh_cache(struct replay_opts *opts)
 657{
 658        static struct lock_file index_lock;
 659        int index_fd = hold_locked_index(&index_lock, 0);
 660        if (read_index_preload(&the_index, NULL) < 0)
 661                die(_("git %s: failed to read the index"), action_name(opts));
 662        refresh_index(&the_index, REFRESH_QUIET|REFRESH_UNMERGED, NULL, NULL, NULL);
 663        if (the_index.cache_changed && index_fd >= 0) {
 664                if (write_locked_index(&the_index, &index_lock, COMMIT_LOCK))
 665                        die(_("git %s: failed to refresh the index"), action_name(opts));
 666        }
 667        rollback_lock_file(&index_lock);
 668}
 669
 670static int format_todo(struct strbuf *buf, struct commit_list *todo_list,
 671                struct replay_opts *opts)
 672{
 673        struct commit_list *cur = NULL;
 674        const char *sha1_abbrev = NULL;
 675        const char *action_str = opts->action == REPLAY_REVERT ? "revert" : "pick";
 676        const char *subject;
 677        int subject_len;
 678
 679        for (cur = todo_list; cur; cur = cur->next) {
 680                const char *commit_buffer = get_commit_buffer(cur->item, NULL);
 681                sha1_abbrev = find_unique_abbrev(cur->item->object.sha1, DEFAULT_ABBREV);
 682                subject_len = find_commit_subject(commit_buffer, &subject);
 683                strbuf_addf(buf, "%s %s %.*s\n", action_str, sha1_abbrev,
 684                        subject_len, subject);
 685                unuse_commit_buffer(cur->item, commit_buffer);
 686        }
 687        return 0;
 688}
 689
 690static struct commit *parse_insn_line(char *bol, char *eol, struct replay_opts *opts)
 691{
 692        unsigned char commit_sha1[20];
 693        enum replay_action action;
 694        char *end_of_object_name;
 695        int saved, status, padding;
 696
 697        if (starts_with(bol, "pick")) {
 698                action = REPLAY_PICK;
 699                bol += strlen("pick");
 700        } else if (starts_with(bol, "revert")) {
 701                action = REPLAY_REVERT;
 702                bol += strlen("revert");
 703        } else
 704                return NULL;
 705
 706        /* Eat up extra spaces/ tabs before object name */
 707        padding = strspn(bol, " \t");
 708        if (!padding)
 709                return NULL;
 710        bol += padding;
 711
 712        end_of_object_name = bol + strcspn(bol, " \t\n");
 713        saved = *end_of_object_name;
 714        *end_of_object_name = '\0';
 715        status = get_sha1(bol, commit_sha1);
 716        *end_of_object_name = saved;
 717
 718        /*
 719         * Verify that the action matches up with the one in
 720         * opts; we don't support arbitrary instructions
 721         */
 722        if (action != opts->action) {
 723                const char *action_str;
 724                action_str = action == REPLAY_REVERT ? "revert" : "cherry-pick";
 725                error(_("Cannot %s during a %s"), action_str, action_name(opts));
 726                return NULL;
 727        }
 728
 729        if (status < 0)
 730                return NULL;
 731
 732        return lookup_commit_reference(commit_sha1);
 733}
 734
 735static int parse_insn_buffer(char *buf, struct commit_list **todo_list,
 736                        struct replay_opts *opts)
 737{
 738        struct commit_list **next = todo_list;
 739        struct commit *commit;
 740        char *p = buf;
 741        int i;
 742
 743        for (i = 1; *p; i++) {
 744                char *eol = strchrnul(p, '\n');
 745                commit = parse_insn_line(p, eol, opts);
 746                if (!commit)
 747                        return error(_("Could not parse line %d."), i);
 748                next = commit_list_append(commit, next);
 749                p = *eol ? eol + 1 : eol;
 750        }
 751        if (!*todo_list)
 752                return error(_("No commits parsed."));
 753        return 0;
 754}
 755
 756static void read_populate_todo(struct commit_list **todo_list,
 757                        struct replay_opts *opts)
 758{
 759        const char *todo_file = git_path(SEQ_TODO_FILE);
 760        struct strbuf buf = STRBUF_INIT;
 761        int fd, res;
 762
 763        fd = open(todo_file, O_RDONLY);
 764        if (fd < 0)
 765                die_errno(_("Could not open %s"), todo_file);
 766        if (strbuf_read(&buf, fd, 0) < 0) {
 767                close(fd);
 768                strbuf_release(&buf);
 769                die(_("Could not read %s."), todo_file);
 770        }
 771        close(fd);
 772
 773        res = parse_insn_buffer(buf.buf, todo_list, opts);
 774        strbuf_release(&buf);
 775        if (res)
 776                die(_("Unusable instruction sheet: %s"), todo_file);
 777}
 778
 779static int populate_opts_cb(const char *key, const char *value, void *data)
 780{
 781        struct replay_opts *opts = data;
 782        int error_flag = 1;
 783
 784        if (!value)
 785                error_flag = 0;
 786        else if (!strcmp(key, "options.no-commit"))
 787                opts->no_commit = git_config_bool_or_int(key, value, &error_flag);
 788        else if (!strcmp(key, "options.edit"))
 789                opts->edit = git_config_bool_or_int(key, value, &error_flag);
 790        else if (!strcmp(key, "options.signoff"))
 791                opts->signoff = git_config_bool_or_int(key, value, &error_flag);
 792        else if (!strcmp(key, "options.record-origin"))
 793                opts->record_origin = git_config_bool_or_int(key, value, &error_flag);
 794        else if (!strcmp(key, "options.allow-ff"))
 795                opts->allow_ff = git_config_bool_or_int(key, value, &error_flag);
 796        else if (!strcmp(key, "options.mainline"))
 797                opts->mainline = git_config_int(key, value);
 798        else if (!strcmp(key, "options.strategy"))
 799                git_config_string(&opts->strategy, key, value);
 800        else if (!strcmp(key, "options.gpg-sign"))
 801                git_config_string(&opts->gpg_sign, key, value);
 802        else if (!strcmp(key, "options.strategy-option")) {
 803                ALLOC_GROW(opts->xopts, opts->xopts_nr + 1, opts->xopts_alloc);
 804                opts->xopts[opts->xopts_nr++] = xstrdup(value);
 805        } else
 806                return error(_("Invalid key: %s"), key);
 807
 808        if (!error_flag)
 809                return error(_("Invalid value for %s: %s"), key, value);
 810
 811        return 0;
 812}
 813
 814static void read_populate_opts(struct replay_opts **opts_ptr)
 815{
 816        const char *opts_file = git_path(SEQ_OPTS_FILE);
 817
 818        if (!file_exists(opts_file))
 819                return;
 820        if (git_config_from_file(populate_opts_cb, opts_file, *opts_ptr) < 0)
 821                die(_("Malformed options sheet: %s"), opts_file);
 822}
 823
 824static void walk_revs_populate_todo(struct commit_list **todo_list,
 825                                struct replay_opts *opts)
 826{
 827        struct commit *commit;
 828        struct commit_list **next;
 829
 830        prepare_revs(opts);
 831
 832        next = todo_list;
 833        while ((commit = get_revision(opts->revs)))
 834                next = commit_list_append(commit, next);
 835}
 836
 837static int create_seq_dir(void)
 838{
 839        const char *seq_dir = git_path(SEQ_DIR);
 840
 841        if (file_exists(seq_dir)) {
 842                error(_("a cherry-pick or revert is already in progress"));
 843                advise(_("try \"git cherry-pick (--continue | --quit | --abort)\""));
 844                return -1;
 845        }
 846        else if (mkdir(seq_dir, 0777) < 0)
 847                die_errno(_("Could not create sequencer directory %s"), seq_dir);
 848        return 0;
 849}
 850
 851static void save_head(const char *head)
 852{
 853        const char *head_file = git_path(SEQ_HEAD_FILE);
 854        static struct lock_file head_lock;
 855        struct strbuf buf = STRBUF_INIT;
 856        int fd;
 857
 858        fd = hold_lock_file_for_update(&head_lock, head_file, LOCK_DIE_ON_ERROR);
 859        strbuf_addf(&buf, "%s\n", head);
 860        if (write_in_full(fd, buf.buf, buf.len) < 0)
 861                die_errno(_("Could not write to %s"), head_file);
 862        if (commit_lock_file(&head_lock) < 0)
 863                die(_("Error wrapping up %s."), head_file);
 864}
 865
 866static int reset_for_rollback(const unsigned char *sha1)
 867{
 868        const char *argv[4];    /* reset --merge <arg> + NULL */
 869        argv[0] = "reset";
 870        argv[1] = "--merge";
 871        argv[2] = sha1_to_hex(sha1);
 872        argv[3] = NULL;
 873        return run_command_v_opt(argv, RUN_GIT_CMD);
 874}
 875
 876static int rollback_single_pick(void)
 877{
 878        unsigned char head_sha1[20];
 879
 880        if (!file_exists(git_path("CHERRY_PICK_HEAD")) &&
 881            !file_exists(git_path("REVERT_HEAD")))
 882                return error(_("no cherry-pick or revert in progress"));
 883        if (read_ref_full("HEAD", 0, head_sha1, NULL))
 884                return error(_("cannot resolve HEAD"));
 885        if (is_null_sha1(head_sha1))
 886                return error(_("cannot abort from a branch yet to be born"));
 887        return reset_for_rollback(head_sha1);
 888}
 889
 890static int sequencer_rollback(struct replay_opts *opts)
 891{
 892        const char *filename;
 893        FILE *f;
 894        unsigned char sha1[20];
 895        struct strbuf buf = STRBUF_INIT;
 896
 897        filename = git_path(SEQ_HEAD_FILE);
 898        f = fopen(filename, "r");
 899        if (!f && errno == ENOENT) {
 900                /*
 901                 * There is no multiple-cherry-pick in progress.
 902                 * If CHERRY_PICK_HEAD or REVERT_HEAD indicates
 903                 * a single-cherry-pick in progress, abort that.
 904                 */
 905                return rollback_single_pick();
 906        }
 907        if (!f)
 908                return error(_("cannot open %s: %s"), filename,
 909                                                strerror(errno));
 910        if (strbuf_getline(&buf, f, '\n')) {
 911                error(_("cannot read %s: %s"), filename, ferror(f) ?
 912                        strerror(errno) : _("unexpected end of file"));
 913                fclose(f);
 914                goto fail;
 915        }
 916        fclose(f);
 917        if (get_sha1_hex(buf.buf, sha1) || buf.buf[40] != '\0') {
 918                error(_("stored pre-cherry-pick HEAD file '%s' is corrupt"),
 919                        filename);
 920                goto fail;
 921        }
 922        if (reset_for_rollback(sha1))
 923                goto fail;
 924        remove_sequencer_state();
 925        strbuf_release(&buf);
 926        return 0;
 927fail:
 928        strbuf_release(&buf);
 929        return -1;
 930}
 931
 932static void save_todo(struct commit_list *todo_list, struct replay_opts *opts)
 933{
 934        const char *todo_file = git_path(SEQ_TODO_FILE);
 935        static struct lock_file todo_lock;
 936        struct strbuf buf = STRBUF_INIT;
 937        int fd;
 938
 939        fd = hold_lock_file_for_update(&todo_lock, todo_file, LOCK_DIE_ON_ERROR);
 940        if (format_todo(&buf, todo_list, opts) < 0)
 941                die(_("Could not format %s."), todo_file);
 942        if (write_in_full(fd, buf.buf, buf.len) < 0) {
 943                strbuf_release(&buf);
 944                die_errno(_("Could not write to %s"), todo_file);
 945        }
 946        if (commit_lock_file(&todo_lock) < 0) {
 947                strbuf_release(&buf);
 948                die(_("Error wrapping up %s."), todo_file);
 949        }
 950        strbuf_release(&buf);
 951}
 952
 953static void save_opts(struct replay_opts *opts)
 954{
 955        const char *opts_file = git_path(SEQ_OPTS_FILE);
 956
 957        if (opts->no_commit)
 958                git_config_set_in_file(opts_file, "options.no-commit", "true");
 959        if (opts->edit)
 960                git_config_set_in_file(opts_file, "options.edit", "true");
 961        if (opts->signoff)
 962                git_config_set_in_file(opts_file, "options.signoff", "true");
 963        if (opts->record_origin)
 964                git_config_set_in_file(opts_file, "options.record-origin", "true");
 965        if (opts->allow_ff)
 966                git_config_set_in_file(opts_file, "options.allow-ff", "true");
 967        if (opts->mainline) {
 968                struct strbuf buf = STRBUF_INIT;
 969                strbuf_addf(&buf, "%d", opts->mainline);
 970                git_config_set_in_file(opts_file, "options.mainline", buf.buf);
 971                strbuf_release(&buf);
 972        }
 973        if (opts->strategy)
 974                git_config_set_in_file(opts_file, "options.strategy", opts->strategy);
 975        if (opts->gpg_sign)
 976                git_config_set_in_file(opts_file, "options.gpg-sign", opts->gpg_sign);
 977        if (opts->xopts) {
 978                int i;
 979                for (i = 0; i < opts->xopts_nr; i++)
 980                        git_config_set_multivar_in_file(opts_file,
 981                                                        "options.strategy-option",
 982                                                        opts->xopts[i], "^$", 0);
 983        }
 984}
 985
 986static int pick_commits(struct commit_list *todo_list, struct replay_opts *opts)
 987{
 988        struct commit_list *cur;
 989        int res;
 990
 991        setenv(GIT_REFLOG_ACTION, action_name(opts), 0);
 992        if (opts->allow_ff)
 993                assert(!(opts->signoff || opts->no_commit ||
 994                                opts->record_origin || opts->edit));
 995        read_and_refresh_cache(opts);
 996
 997        for (cur = todo_list; cur; cur = cur->next) {
 998                save_todo(cur, opts);
 999                res = do_pick_commit(cur->item, opts);
1000                if (res)
1001                        return res;
1002        }
1003
1004        /*
1005         * Sequence of picks finished successfully; cleanup by
1006         * removing the .git/sequencer directory
1007         */
1008        remove_sequencer_state();
1009        return 0;
1010}
1011
1012static int continue_single_pick(void)
1013{
1014        const char *argv[] = { "commit", NULL };
1015
1016        if (!file_exists(git_path("CHERRY_PICK_HEAD")) &&
1017            !file_exists(git_path("REVERT_HEAD")))
1018                return error(_("no cherry-pick or revert in progress"));
1019        return run_command_v_opt(argv, RUN_GIT_CMD);
1020}
1021
1022static int sequencer_continue(struct replay_opts *opts)
1023{
1024        struct commit_list *todo_list = NULL;
1025
1026        if (!file_exists(git_path(SEQ_TODO_FILE)))
1027                return continue_single_pick();
1028        read_populate_opts(&opts);
1029        read_populate_todo(&todo_list, opts);
1030
1031        /* Verify that the conflict has been resolved */
1032        if (file_exists(git_path("CHERRY_PICK_HEAD")) ||
1033            file_exists(git_path("REVERT_HEAD"))) {
1034                int ret = continue_single_pick();
1035                if (ret)
1036                        return ret;
1037        }
1038        if (index_differs_from("HEAD", 0))
1039                return error_dirty_index(opts);
1040        todo_list = todo_list->next;
1041        return pick_commits(todo_list, opts);
1042}
1043
1044static int single_pick(struct commit *cmit, struct replay_opts *opts)
1045{
1046        setenv(GIT_REFLOG_ACTION, action_name(opts), 0);
1047        return do_pick_commit(cmit, opts);
1048}
1049
1050int sequencer_pick_revisions(struct replay_opts *opts)
1051{
1052        struct commit_list *todo_list = NULL;
1053        unsigned char sha1[20];
1054        int i;
1055
1056        if (opts->subcommand == REPLAY_NONE)
1057                assert(opts->revs);
1058
1059        read_and_refresh_cache(opts);
1060
1061        /*
1062         * Decide what to do depending on the arguments; a fresh
1063         * cherry-pick should be handled differently from an existing
1064         * one that is being continued
1065         */
1066        if (opts->subcommand == REPLAY_REMOVE_STATE) {
1067                remove_sequencer_state();
1068                return 0;
1069        }
1070        if (opts->subcommand == REPLAY_ROLLBACK)
1071                return sequencer_rollback(opts);
1072        if (opts->subcommand == REPLAY_CONTINUE)
1073                return sequencer_continue(opts);
1074
1075        for (i = 0; i < opts->revs->pending.nr; i++) {
1076                unsigned char sha1[20];
1077                const char *name = opts->revs->pending.objects[i].name;
1078
1079                /* This happens when using --stdin. */
1080                if (!strlen(name))
1081                        continue;
1082
1083                if (!get_sha1(name, sha1)) {
1084                        if (!lookup_commit_reference_gently(sha1, 1)) {
1085                                enum object_type type = sha1_object_info(sha1, NULL);
1086                                die(_("%s: can't cherry-pick a %s"), name, typename(type));
1087                        }
1088                } else
1089                        die(_("%s: bad revision"), name);
1090        }
1091
1092        /*
1093         * If we were called as "git cherry-pick <commit>", just
1094         * cherry-pick/revert it, set CHERRY_PICK_HEAD /
1095         * REVERT_HEAD, and don't touch the sequencer state.
1096         * This means it is possible to cherry-pick in the middle
1097         * of a cherry-pick sequence.
1098         */
1099        if (opts->revs->cmdline.nr == 1 &&
1100            opts->revs->cmdline.rev->whence == REV_CMD_REV &&
1101            opts->revs->no_walk &&
1102            !opts->revs->cmdline.rev->flags) {
1103                struct commit *cmit;
1104                if (prepare_revision_walk(opts->revs))
1105                        die(_("revision walk setup failed"));
1106                cmit = get_revision(opts->revs);
1107                if (!cmit || get_revision(opts->revs))
1108                        die("BUG: expected exactly one commit from walk");
1109                return single_pick(cmit, opts);
1110        }
1111
1112        /*
1113         * Start a new cherry-pick/ revert sequence; but
1114         * first, make sure that an existing one isn't in
1115         * progress
1116         */
1117
1118        walk_revs_populate_todo(&todo_list, opts);
1119        if (create_seq_dir() < 0)
1120                return -1;
1121        if (get_sha1("HEAD", sha1)) {
1122                if (opts->action == REPLAY_REVERT)
1123                        return error(_("Can't revert as initial commit"));
1124                return error(_("Can't cherry-pick into empty head"));
1125        }
1126        save_head(sha1_to_hex(sha1));
1127        save_opts(opts);
1128        return pick_commits(todo_list, opts);
1129}
1130
1131void append_signoff(struct strbuf *msgbuf, int ignore_footer, unsigned flag)
1132{
1133        unsigned no_dup_sob = flag & APPEND_SIGNOFF_DEDUP;
1134        struct strbuf sob = STRBUF_INIT;
1135        int has_footer;
1136
1137        strbuf_addstr(&sob, sign_off_header);
1138        strbuf_addstr(&sob, fmt_name(getenv("GIT_COMMITTER_NAME"),
1139                                getenv("GIT_COMMITTER_EMAIL")));
1140        strbuf_addch(&sob, '\n');
1141
1142        /*
1143         * If the whole message buffer is equal to the sob, pretend that we
1144         * found a conforming footer with a matching sob
1145         */
1146        if (msgbuf->len - ignore_footer == sob.len &&
1147            !strncmp(msgbuf->buf, sob.buf, sob.len))
1148                has_footer = 3;
1149        else
1150                has_footer = has_conforming_footer(msgbuf, &sob, ignore_footer);
1151
1152        if (!has_footer) {
1153                const char *append_newlines = NULL;
1154                size_t len = msgbuf->len - ignore_footer;
1155
1156                if (!len) {
1157                        /*
1158                         * The buffer is completely empty.  Leave foom for
1159                         * the title and body to be filled in by the user.
1160                         */
1161                        append_newlines = "\n\n";
1162                } else if (msgbuf->buf[len - 1] != '\n') {
1163                        /*
1164                         * Incomplete line.  Complete the line and add a
1165                         * blank one so that there is an empty line between
1166                         * the message body and the sob.
1167                         */
1168                        append_newlines = "\n\n";
1169                } else if (len == 1) {
1170                        /*
1171                         * Buffer contains a single newline.  Add another
1172                         * so that we leave room for the title and body.
1173                         */
1174                        append_newlines = "\n";
1175                } else if (msgbuf->buf[len - 2] != '\n') {
1176                        /*
1177                         * Buffer ends with a single newline.  Add another
1178                         * so that there is an empty line between the message
1179                         * body and the sob.
1180                         */
1181                        append_newlines = "\n";
1182                } /* else, the buffer already ends with two newlines. */
1183
1184                if (append_newlines)
1185                        strbuf_splice(msgbuf, msgbuf->len - ignore_footer, 0,
1186                                append_newlines, strlen(append_newlines));
1187        }
1188
1189        if (has_footer != 3 && (!no_dup_sob || has_footer != 2))
1190                strbuf_splice(msgbuf, msgbuf->len - ignore_footer, 0,
1191                                sob.buf, sob.len);
1192
1193        strbuf_release(&sob);
1194}