sequencer.con commit Merge branch 'rs/get-tagged-oid' (cf861cd)
   1#include "cache.h"
   2#include "config.h"
   3#include "lockfile.h"
   4#include "dir.h"
   5#include "object-store.h"
   6#include "object.h"
   7#include "commit.h"
   8#include "sequencer.h"
   9#include "tag.h"
  10#include "run-command.h"
  11#include "exec-cmd.h"
  12#include "utf8.h"
  13#include "cache-tree.h"
  14#include "diff.h"
  15#include "revision.h"
  16#include "rerere.h"
  17#include "merge-recursive.h"
  18#include "refs.h"
  19#include "argv-array.h"
  20#include "quote.h"
  21#include "trailer.h"
  22#include "log-tree.h"
  23#include "wt-status.h"
  24#include "hashmap.h"
  25#include "notes-utils.h"
  26#include "sigchain.h"
  27#include "unpack-trees.h"
  28#include "worktree.h"
  29#include "oidmap.h"
  30#include "oidset.h"
  31#include "commit-slab.h"
  32#include "alias.h"
  33#include "commit-reach.h"
  34#include "rebase-interactive.h"
  35
  36#define GIT_REFLOG_ACTION "GIT_REFLOG_ACTION"
  37
  38static const char sign_off_header[] = "Signed-off-by: ";
  39static const char cherry_picked_prefix[] = "(cherry picked from commit ";
  40
  41GIT_PATH_FUNC(git_path_commit_editmsg, "COMMIT_EDITMSG")
  42
  43GIT_PATH_FUNC(git_path_seq_dir, "sequencer")
  44
  45static GIT_PATH_FUNC(git_path_todo_file, "sequencer/todo")
  46static GIT_PATH_FUNC(git_path_opts_file, "sequencer/opts")
  47static GIT_PATH_FUNC(git_path_head_file, "sequencer/head")
  48static GIT_PATH_FUNC(git_path_abort_safety_file, "sequencer/abort-safety")
  49
  50static GIT_PATH_FUNC(rebase_path, "rebase-merge")
  51/*
  52 * The file containing rebase commands, comments, and empty lines.
  53 * This file is created by "git rebase -i" then edited by the user. As
  54 * the lines are processed, they are removed from the front of this
  55 * file and written to the tail of 'done'.
  56 */
  57GIT_PATH_FUNC(rebase_path_todo, "rebase-merge/git-rebase-todo")
  58GIT_PATH_FUNC(rebase_path_todo_backup, "rebase-merge/git-rebase-todo.backup")
  59
  60/*
  61 * The rebase command lines that have already been processed. A line
  62 * is moved here when it is first handled, before any associated user
  63 * actions.
  64 */
  65static GIT_PATH_FUNC(rebase_path_done, "rebase-merge/done")
  66/*
  67 * The file to keep track of how many commands were already processed (e.g.
  68 * for the prompt).
  69 */
  70static GIT_PATH_FUNC(rebase_path_msgnum, "rebase-merge/msgnum")
  71/*
  72 * The file to keep track of how many commands are to be processed in total
  73 * (e.g. for the prompt).
  74 */
  75static GIT_PATH_FUNC(rebase_path_msgtotal, "rebase-merge/end")
  76/*
  77 * The commit message that is planned to be used for any changes that
  78 * need to be committed following a user interaction.
  79 */
  80static GIT_PATH_FUNC(rebase_path_message, "rebase-merge/message")
  81/*
  82 * The file into which is accumulated the suggested commit message for
  83 * squash/fixup commands. When the first of a series of squash/fixups
  84 * is seen, the file is created and the commit message from the
  85 * previous commit and from the first squash/fixup commit are written
  86 * to it. The commit message for each subsequent squash/fixup commit
  87 * is appended to the file as it is processed.
  88 */
  89static GIT_PATH_FUNC(rebase_path_squash_msg, "rebase-merge/message-squash")
  90/*
  91 * If the current series of squash/fixups has not yet included a squash
  92 * command, then this file exists and holds the commit message of the
  93 * original "pick" commit.  (If the series ends without a "squash"
  94 * command, then this can be used as the commit message of the combined
  95 * commit without opening the editor.)
  96 */
  97static GIT_PATH_FUNC(rebase_path_fixup_msg, "rebase-merge/message-fixup")
  98/*
  99 * This file contains the list fixup/squash commands that have been
 100 * accumulated into message-fixup or message-squash so far.
 101 */
 102static GIT_PATH_FUNC(rebase_path_current_fixups, "rebase-merge/current-fixups")
 103/*
 104 * A script to set the GIT_AUTHOR_NAME, GIT_AUTHOR_EMAIL, and
 105 * GIT_AUTHOR_DATE that will be used for the commit that is currently
 106 * being rebased.
 107 */
 108static GIT_PATH_FUNC(rebase_path_author_script, "rebase-merge/author-script")
 109/*
 110 * When an "edit" rebase command is being processed, the SHA1 of the
 111 * commit to be edited is recorded in this file.  When "git rebase
 112 * --continue" is executed, if there are any staged changes then they
 113 * will be amended to the HEAD commit, but only provided the HEAD
 114 * commit is still the commit to be edited.  When any other rebase
 115 * command is processed, this file is deleted.
 116 */
 117static GIT_PATH_FUNC(rebase_path_amend, "rebase-merge/amend")
 118/*
 119 * When we stop at a given patch via the "edit" command, this file contains
 120 * the abbreviated commit name of the corresponding patch.
 121 */
 122static GIT_PATH_FUNC(rebase_path_stopped_sha, "rebase-merge/stopped-sha")
 123/*
 124 * For the post-rewrite hook, we make a list of rewritten commits and
 125 * their new sha1s.  The rewritten-pending list keeps the sha1s of
 126 * commits that have been processed, but not committed yet,
 127 * e.g. because they are waiting for a 'squash' command.
 128 */
 129static GIT_PATH_FUNC(rebase_path_rewritten_list, "rebase-merge/rewritten-list")
 130static GIT_PATH_FUNC(rebase_path_rewritten_pending,
 131        "rebase-merge/rewritten-pending")
 132
 133/*
 134 * The path of the file containig the OID of the "squash onto" commit, i.e.
 135 * the dummy commit used for `reset [new root]`.
 136 */
 137static GIT_PATH_FUNC(rebase_path_squash_onto, "rebase-merge/squash-onto")
 138
 139/*
 140 * The path of the file listing refs that need to be deleted after the rebase
 141 * finishes. This is used by the `label` command to record the need for cleanup.
 142 */
 143static GIT_PATH_FUNC(rebase_path_refs_to_delete, "rebase-merge/refs-to-delete")
 144
 145/*
 146 * The following files are written by git-rebase just after parsing the
 147 * command-line.
 148 */
 149static GIT_PATH_FUNC(rebase_path_gpg_sign_opt, "rebase-merge/gpg_sign_opt")
 150static GIT_PATH_FUNC(rebase_path_orig_head, "rebase-merge/orig-head")
 151static GIT_PATH_FUNC(rebase_path_verbose, "rebase-merge/verbose")
 152static GIT_PATH_FUNC(rebase_path_quiet, "rebase-merge/quiet")
 153static GIT_PATH_FUNC(rebase_path_signoff, "rebase-merge/signoff")
 154static GIT_PATH_FUNC(rebase_path_head_name, "rebase-merge/head-name")
 155static GIT_PATH_FUNC(rebase_path_onto, "rebase-merge/onto")
 156static GIT_PATH_FUNC(rebase_path_autostash, "rebase-merge/autostash")
 157static GIT_PATH_FUNC(rebase_path_strategy, "rebase-merge/strategy")
 158static GIT_PATH_FUNC(rebase_path_strategy_opts, "rebase-merge/strategy_opts")
 159static GIT_PATH_FUNC(rebase_path_allow_rerere_autoupdate, "rebase-merge/allow_rerere_autoupdate")
 160static GIT_PATH_FUNC(rebase_path_reschedule_failed_exec, "rebase-merge/reschedule-failed-exec")
 161
 162static int git_sequencer_config(const char *k, const char *v, void *cb)
 163{
 164        struct replay_opts *opts = cb;
 165        int status;
 166
 167        if (!strcmp(k, "commit.cleanup")) {
 168                const char *s;
 169
 170                status = git_config_string(&s, k, v);
 171                if (status)
 172                        return status;
 173
 174                if (!strcmp(s, "verbatim")) {
 175                        opts->default_msg_cleanup = COMMIT_MSG_CLEANUP_NONE;
 176                        opts->explicit_cleanup = 1;
 177                } else if (!strcmp(s, "whitespace")) {
 178                        opts->default_msg_cleanup = COMMIT_MSG_CLEANUP_SPACE;
 179                        opts->explicit_cleanup = 1;
 180                } else if (!strcmp(s, "strip")) {
 181                        opts->default_msg_cleanup = COMMIT_MSG_CLEANUP_ALL;
 182                        opts->explicit_cleanup = 1;
 183                } else if (!strcmp(s, "scissors")) {
 184                        opts->default_msg_cleanup = COMMIT_MSG_CLEANUP_SCISSORS;
 185                        opts->explicit_cleanup = 1;
 186                } else {
 187                        warning(_("invalid commit message cleanup mode '%s'"),
 188                                  s);
 189                }
 190
 191                free((char *)s);
 192                return status;
 193        }
 194
 195        if (!strcmp(k, "commit.gpgsign")) {
 196                opts->gpg_sign = git_config_bool(k, v) ? xstrdup("") : NULL;
 197                return 0;
 198        }
 199
 200        status = git_gpg_config(k, v, NULL);
 201        if (status)
 202                return status;
 203
 204        return git_diff_basic_config(k, v, NULL);
 205}
 206
 207void sequencer_init_config(struct replay_opts *opts)
 208{
 209        opts->default_msg_cleanup = COMMIT_MSG_CLEANUP_NONE;
 210        git_config(git_sequencer_config, opts);
 211}
 212
 213static inline int is_rebase_i(const struct replay_opts *opts)
 214{
 215        return opts->action == REPLAY_INTERACTIVE_REBASE;
 216}
 217
 218static const char *get_dir(const struct replay_opts *opts)
 219{
 220        if (is_rebase_i(opts))
 221                return rebase_path();
 222        return git_path_seq_dir();
 223}
 224
 225static const char *get_todo_path(const struct replay_opts *opts)
 226{
 227        if (is_rebase_i(opts))
 228                return rebase_path_todo();
 229        return git_path_todo_file();
 230}
 231
 232/*
 233 * Returns 0 for non-conforming footer
 234 * Returns 1 for conforming footer
 235 * Returns 2 when sob exists within conforming footer
 236 * Returns 3 when sob exists within conforming footer as last entry
 237 */
 238static int has_conforming_footer(struct strbuf *sb, struct strbuf *sob,
 239        size_t ignore_footer)
 240{
 241        struct process_trailer_options opts = PROCESS_TRAILER_OPTIONS_INIT;
 242        struct trailer_info info;
 243        size_t i;
 244        int found_sob = 0, found_sob_last = 0;
 245
 246        opts.no_divider = 1;
 247
 248        trailer_info_get(&info, sb->buf, &opts);
 249
 250        if (info.trailer_start == info.trailer_end)
 251                return 0;
 252
 253        for (i = 0; i < info.trailer_nr; i++)
 254                if (sob && !strncmp(info.trailers[i], sob->buf, sob->len)) {
 255                        found_sob = 1;
 256                        if (i == info.trailer_nr - 1)
 257                                found_sob_last = 1;
 258                }
 259
 260        trailer_info_release(&info);
 261
 262        if (found_sob_last)
 263                return 3;
 264        if (found_sob)
 265                return 2;
 266        return 1;
 267}
 268
 269static const char *gpg_sign_opt_quoted(struct replay_opts *opts)
 270{
 271        static struct strbuf buf = STRBUF_INIT;
 272
 273        strbuf_reset(&buf);
 274        if (opts->gpg_sign)
 275                sq_quotef(&buf, "-S%s", opts->gpg_sign);
 276        return buf.buf;
 277}
 278
 279int sequencer_remove_state(struct replay_opts *opts)
 280{
 281        struct strbuf buf = STRBUF_INIT;
 282        int i, ret = 0;
 283
 284        if (is_rebase_i(opts) &&
 285            strbuf_read_file(&buf, rebase_path_refs_to_delete(), 0) > 0) {
 286                char *p = buf.buf;
 287                while (*p) {
 288                        char *eol = strchr(p, '\n');
 289                        if (eol)
 290                                *eol = '\0';
 291                        if (delete_ref("(rebase -i) cleanup", p, NULL, 0) < 0) {
 292                                warning(_("could not delete '%s'"), p);
 293                                ret = -1;
 294                        }
 295                        if (!eol)
 296                                break;
 297                        p = eol + 1;
 298                }
 299        }
 300
 301        free(opts->gpg_sign);
 302        free(opts->strategy);
 303        for (i = 0; i < opts->xopts_nr; i++)
 304                free(opts->xopts[i]);
 305        free(opts->xopts);
 306        strbuf_release(&opts->current_fixups);
 307
 308        strbuf_reset(&buf);
 309        strbuf_addstr(&buf, get_dir(opts));
 310        if (remove_dir_recursively(&buf, 0))
 311                ret = error(_("could not remove '%s'"), buf.buf);
 312        strbuf_release(&buf);
 313
 314        return ret;
 315}
 316
 317static const char *action_name(const struct replay_opts *opts)
 318{
 319        switch (opts->action) {
 320        case REPLAY_REVERT:
 321                return N_("revert");
 322        case REPLAY_PICK:
 323                return N_("cherry-pick");
 324        case REPLAY_INTERACTIVE_REBASE:
 325                return N_("rebase -i");
 326        }
 327        die(_("unknown action: %d"), opts->action);
 328}
 329
 330struct commit_message {
 331        char *parent_label;
 332        char *label;
 333        char *subject;
 334        const char *message;
 335};
 336
 337static const char *short_commit_name(struct commit *commit)
 338{
 339        return find_unique_abbrev(&commit->object.oid, DEFAULT_ABBREV);
 340}
 341
 342static int get_message(struct commit *commit, struct commit_message *out)
 343{
 344        const char *abbrev, *subject;
 345        int subject_len;
 346
 347        out->message = logmsg_reencode(commit, NULL, get_commit_output_encoding());
 348        abbrev = short_commit_name(commit);
 349
 350        subject_len = find_commit_subject(out->message, &subject);
 351
 352        out->subject = xmemdupz(subject, subject_len);
 353        out->label = xstrfmt("%s... %s", abbrev, out->subject);
 354        out->parent_label = xstrfmt("parent of %s", out->label);
 355
 356        return 0;
 357}
 358
 359static void free_message(struct commit *commit, struct commit_message *msg)
 360{
 361        free(msg->parent_label);
 362        free(msg->label);
 363        free(msg->subject);
 364        unuse_commit_buffer(commit, msg->message);
 365}
 366
 367static void print_advice(struct repository *r, int show_hint,
 368                         struct replay_opts *opts)
 369{
 370        char *msg = getenv("GIT_CHERRY_PICK_HELP");
 371
 372        if (msg) {
 373                fprintf(stderr, "%s\n", msg);
 374                /*
 375                 * A conflict has occurred but the porcelain
 376                 * (typically rebase --interactive) wants to take care
 377                 * of the commit itself so remove CHERRY_PICK_HEAD
 378                 */
 379                unlink(git_path_cherry_pick_head(r));
 380                return;
 381        }
 382
 383        if (show_hint) {
 384                if (opts->no_commit)
 385                        advise(_("after resolving the conflicts, mark the corrected paths\n"
 386                                 "with 'git add <paths>' or 'git rm <paths>'"));
 387                else
 388                        advise(_("after resolving the conflicts, mark the corrected paths\n"
 389                                 "with 'git add <paths>' or 'git rm <paths>'\n"
 390                                 "and commit the result with 'git commit'"));
 391        }
 392}
 393
 394static int write_message(const void *buf, size_t len, const char *filename,
 395                         int append_eol)
 396{
 397        struct lock_file msg_file = LOCK_INIT;
 398
 399        int msg_fd = hold_lock_file_for_update(&msg_file, filename, 0);
 400        if (msg_fd < 0)
 401                return error_errno(_("could not lock '%s'"), filename);
 402        if (write_in_full(msg_fd, buf, len) < 0) {
 403                error_errno(_("could not write to '%s'"), filename);
 404                rollback_lock_file(&msg_file);
 405                return -1;
 406        }
 407        if (append_eol && write(msg_fd, "\n", 1) < 0) {
 408                error_errno(_("could not write eol to '%s'"), filename);
 409                rollback_lock_file(&msg_file);
 410                return -1;
 411        }
 412        if (commit_lock_file(&msg_file) < 0)
 413                return error(_("failed to finalize '%s'"), filename);
 414
 415        return 0;
 416}
 417
 418/*
 419 * Reads a file that was presumably written by a shell script, i.e. with an
 420 * end-of-line marker that needs to be stripped.
 421 *
 422 * Note that only the last end-of-line marker is stripped, consistent with the
 423 * behavior of "$(cat path)" in a shell script.
 424 *
 425 * Returns 1 if the file was read, 0 if it could not be read or does not exist.
 426 */
 427static int read_oneliner(struct strbuf *buf,
 428        const char *path, int skip_if_empty)
 429{
 430        int orig_len = buf->len;
 431
 432        if (!file_exists(path))
 433                return 0;
 434
 435        if (strbuf_read_file(buf, path, 0) < 0) {
 436                warning_errno(_("could not read '%s'"), path);
 437                return 0;
 438        }
 439
 440        if (buf->len > orig_len && buf->buf[buf->len - 1] == '\n') {
 441                if (--buf->len > orig_len && buf->buf[buf->len - 1] == '\r')
 442                        --buf->len;
 443                buf->buf[buf->len] = '\0';
 444        }
 445
 446        if (skip_if_empty && buf->len == orig_len)
 447                return 0;
 448
 449        return 1;
 450}
 451
 452static struct tree *empty_tree(struct repository *r)
 453{
 454        return lookup_tree(r, the_hash_algo->empty_tree);
 455}
 456
 457static int error_dirty_index(struct repository *repo, struct replay_opts *opts)
 458{
 459        if (repo_read_index_unmerged(repo))
 460                return error_resolve_conflict(_(action_name(opts)));
 461
 462        error(_("your local changes would be overwritten by %s."),
 463                _(action_name(opts)));
 464
 465        if (advice_commit_before_merge)
 466                advise(_("commit your changes or stash them to proceed."));
 467        return -1;
 468}
 469
 470static void update_abort_safety_file(void)
 471{
 472        struct object_id head;
 473
 474        /* Do nothing on a single-pick */
 475        if (!file_exists(git_path_seq_dir()))
 476                return;
 477
 478        if (!get_oid("HEAD", &head))
 479                write_file(git_path_abort_safety_file(), "%s", oid_to_hex(&head));
 480        else
 481                write_file(git_path_abort_safety_file(), "%s", "");
 482}
 483
 484static int fast_forward_to(struct repository *r,
 485                           const struct object_id *to,
 486                           const struct object_id *from,
 487                           int unborn,
 488                           struct replay_opts *opts)
 489{
 490        struct ref_transaction *transaction;
 491        struct strbuf sb = STRBUF_INIT;
 492        struct strbuf err = STRBUF_INIT;
 493
 494        repo_read_index(r);
 495        if (checkout_fast_forward(r, from, to, 1))
 496                return -1; /* the callee should have complained already */
 497
 498        strbuf_addf(&sb, _("%s: fast-forward"), _(action_name(opts)));
 499
 500        transaction = ref_transaction_begin(&err);
 501        if (!transaction ||
 502            ref_transaction_update(transaction, "HEAD",
 503                                   to, unborn && !is_rebase_i(opts) ?
 504                                   &null_oid : from,
 505                                   0, sb.buf, &err) ||
 506            ref_transaction_commit(transaction, &err)) {
 507                ref_transaction_free(transaction);
 508                error("%s", err.buf);
 509                strbuf_release(&sb);
 510                strbuf_release(&err);
 511                return -1;
 512        }
 513
 514        strbuf_release(&sb);
 515        strbuf_release(&err);
 516        ref_transaction_free(transaction);
 517        update_abort_safety_file();
 518        return 0;
 519}
 520
 521enum commit_msg_cleanup_mode get_cleanup_mode(const char *cleanup_arg,
 522        int use_editor)
 523{
 524        if (!cleanup_arg || !strcmp(cleanup_arg, "default"))
 525                return use_editor ? COMMIT_MSG_CLEANUP_ALL :
 526                                    COMMIT_MSG_CLEANUP_SPACE;
 527        else if (!strcmp(cleanup_arg, "verbatim"))
 528                return COMMIT_MSG_CLEANUP_NONE;
 529        else if (!strcmp(cleanup_arg, "whitespace"))
 530                return COMMIT_MSG_CLEANUP_SPACE;
 531        else if (!strcmp(cleanup_arg, "strip"))
 532                return COMMIT_MSG_CLEANUP_ALL;
 533        else if (!strcmp(cleanup_arg, "scissors"))
 534                return use_editor ? COMMIT_MSG_CLEANUP_SCISSORS :
 535                                    COMMIT_MSG_CLEANUP_SPACE;
 536        else
 537                die(_("Invalid cleanup mode %s"), cleanup_arg);
 538}
 539
 540/*
 541 * NB using int rather than enum cleanup_mode to stop clang's
 542 * -Wtautological-constant-out-of-range-compare complaining that the comparison
 543 * is always true.
 544 */
 545static const char *describe_cleanup_mode(int cleanup_mode)
 546{
 547        static const char *modes[] = { "whitespace",
 548                                       "verbatim",
 549                                       "scissors",
 550                                       "strip" };
 551
 552        if (cleanup_mode < ARRAY_SIZE(modes))
 553                return modes[cleanup_mode];
 554
 555        BUG("invalid cleanup_mode provided (%d)", cleanup_mode);
 556}
 557
 558void append_conflicts_hint(struct index_state *istate,
 559        struct strbuf *msgbuf, enum commit_msg_cleanup_mode cleanup_mode)
 560{
 561        int i;
 562
 563        if (cleanup_mode == COMMIT_MSG_CLEANUP_SCISSORS) {
 564                strbuf_addch(msgbuf, '\n');
 565                wt_status_append_cut_line(msgbuf);
 566                strbuf_addch(msgbuf, comment_line_char);
 567        }
 568
 569        strbuf_addch(msgbuf, '\n');
 570        strbuf_commented_addf(msgbuf, "Conflicts:\n");
 571        for (i = 0; i < istate->cache_nr;) {
 572                const struct cache_entry *ce = istate->cache[i++];
 573                if (ce_stage(ce)) {
 574                        strbuf_commented_addf(msgbuf, "\t%s\n", ce->name);
 575                        while (i < istate->cache_nr &&
 576                               !strcmp(ce->name, istate->cache[i]->name))
 577                                i++;
 578                }
 579        }
 580}
 581
 582static int do_recursive_merge(struct repository *r,
 583                              struct commit *base, struct commit *next,
 584                              const char *base_label, const char *next_label,
 585                              struct object_id *head, struct strbuf *msgbuf,
 586                              struct replay_opts *opts)
 587{
 588        struct merge_options o;
 589        struct tree *result, *next_tree, *base_tree, *head_tree;
 590        int clean;
 591        char **xopt;
 592        struct lock_file index_lock = LOCK_INIT;
 593
 594        if (repo_hold_locked_index(r, &index_lock, LOCK_REPORT_ON_ERROR) < 0)
 595                return -1;
 596
 597        repo_read_index(r);
 598
 599        init_merge_options(&o, r);
 600        o.ancestor = base ? base_label : "(empty tree)";
 601        o.branch1 = "HEAD";
 602        o.branch2 = next ? next_label : "(empty tree)";
 603        if (is_rebase_i(opts))
 604                o.buffer_output = 2;
 605        o.show_rename_progress = 1;
 606
 607        head_tree = parse_tree_indirect(head);
 608        next_tree = next ? get_commit_tree(next) : empty_tree(r);
 609        base_tree = base ? get_commit_tree(base) : empty_tree(r);
 610
 611        for (xopt = opts->xopts; xopt != opts->xopts + opts->xopts_nr; xopt++)
 612                parse_merge_opt(&o, *xopt);
 613
 614        clean = merge_trees(&o,
 615                            head_tree,
 616                            next_tree, base_tree, &result);
 617        if (is_rebase_i(opts) && clean <= 0)
 618                fputs(o.obuf.buf, stdout);
 619        strbuf_release(&o.obuf);
 620        diff_warn_rename_limit("merge.renamelimit", o.needed_rename_limit, 0);
 621        if (clean < 0) {
 622                rollback_lock_file(&index_lock);
 623                return clean;
 624        }
 625
 626        if (write_locked_index(r->index, &index_lock,
 627                               COMMIT_LOCK | SKIP_IF_UNCHANGED))
 628                /*
 629                 * TRANSLATORS: %s will be "revert", "cherry-pick" or
 630                 * "rebase -i".
 631                 */
 632                return error(_("%s: Unable to write new index file"),
 633                        _(action_name(opts)));
 634
 635        if (!clean)
 636                append_conflicts_hint(r->index, msgbuf,
 637                                      opts->default_msg_cleanup);
 638
 639        return !clean;
 640}
 641
 642static struct object_id *get_cache_tree_oid(struct index_state *istate)
 643{
 644        if (!istate->cache_tree)
 645                istate->cache_tree = cache_tree();
 646
 647        if (!cache_tree_fully_valid(istate->cache_tree))
 648                if (cache_tree_update(istate, 0)) {
 649                        error(_("unable to update cache tree"));
 650                        return NULL;
 651                }
 652
 653        return &istate->cache_tree->oid;
 654}
 655
 656static int is_index_unchanged(struct repository *r)
 657{
 658        struct object_id head_oid, *cache_tree_oid;
 659        struct commit *head_commit;
 660        struct index_state *istate = r->index;
 661
 662        if (!resolve_ref_unsafe("HEAD", RESOLVE_REF_READING, &head_oid, NULL))
 663                return error(_("could not resolve HEAD commit"));
 664
 665        head_commit = lookup_commit(r, &head_oid);
 666
 667        /*
 668         * If head_commit is NULL, check_commit, called from
 669         * lookup_commit, would have indicated that head_commit is not
 670         * a commit object already.  parse_commit() will return failure
 671         * without further complaints in such a case.  Otherwise, if
 672         * the commit is invalid, parse_commit() will complain.  So
 673         * there is nothing for us to say here.  Just return failure.
 674         */
 675        if (parse_commit(head_commit))
 676                return -1;
 677
 678        if (!(cache_tree_oid = get_cache_tree_oid(istate)))
 679                return -1;
 680
 681        return oideq(cache_tree_oid, get_commit_tree_oid(head_commit));
 682}
 683
 684static int write_author_script(const char *message)
 685{
 686        struct strbuf buf = STRBUF_INIT;
 687        const char *eol;
 688        int res;
 689
 690        for (;;)
 691                if (!*message || starts_with(message, "\n")) {
 692missing_author:
 693                        /* Missing 'author' line? */
 694                        unlink(rebase_path_author_script());
 695                        return 0;
 696                } else if (skip_prefix(message, "author ", &message))
 697                        break;
 698                else if ((eol = strchr(message, '\n')))
 699                        message = eol + 1;
 700                else
 701                        goto missing_author;
 702
 703        strbuf_addstr(&buf, "GIT_AUTHOR_NAME='");
 704        while (*message && *message != '\n' && *message != '\r')
 705                if (skip_prefix(message, " <", &message))
 706                        break;
 707                else if (*message != '\'')
 708                        strbuf_addch(&buf, *(message++));
 709                else
 710                        strbuf_addf(&buf, "'\\%c'", *(message++));
 711        strbuf_addstr(&buf, "'\nGIT_AUTHOR_EMAIL='");
 712        while (*message && *message != '\n' && *message != '\r')
 713                if (skip_prefix(message, "> ", &message))
 714                        break;
 715                else if (*message != '\'')
 716                        strbuf_addch(&buf, *(message++));
 717                else
 718                        strbuf_addf(&buf, "'\\%c'", *(message++));
 719        strbuf_addstr(&buf, "'\nGIT_AUTHOR_DATE='@");
 720        while (*message && *message != '\n' && *message != '\r')
 721                if (*message != '\'')
 722                        strbuf_addch(&buf, *(message++));
 723                else
 724                        strbuf_addf(&buf, "'\\%c'", *(message++));
 725        strbuf_addch(&buf, '\'');
 726        res = write_message(buf.buf, buf.len, rebase_path_author_script(), 1);
 727        strbuf_release(&buf);
 728        return res;
 729}
 730
 731/**
 732 * Take a series of KEY='VALUE' lines where VALUE part is
 733 * sq-quoted, and append <KEY, VALUE> at the end of the string list
 734 */
 735static int parse_key_value_squoted(char *buf, struct string_list *list)
 736{
 737        while (*buf) {
 738                struct string_list_item *item;
 739                char *np;
 740                char *cp = strchr(buf, '=');
 741                if (!cp) {
 742                        np = strchrnul(buf, '\n');
 743                        return error(_("no key present in '%.*s'"),
 744                                     (int) (np - buf), buf);
 745                }
 746                np = strchrnul(cp, '\n');
 747                *cp++ = '\0';
 748                item = string_list_append(list, buf);
 749
 750                buf = np + (*np == '\n');
 751                *np = '\0';
 752                cp = sq_dequote(cp);
 753                if (!cp)
 754                        return error(_("unable to dequote value of '%s'"),
 755                                     item->string);
 756                item->util = xstrdup(cp);
 757        }
 758        return 0;
 759}
 760
 761/**
 762 * Reads and parses the state directory's "author-script" file, and sets name,
 763 * email and date accordingly.
 764 * Returns 0 on success, -1 if the file could not be parsed.
 765 *
 766 * The author script is of the format:
 767 *
 768 *      GIT_AUTHOR_NAME='$author_name'
 769 *      GIT_AUTHOR_EMAIL='$author_email'
 770 *      GIT_AUTHOR_DATE='$author_date'
 771 *
 772 * where $author_name, $author_email and $author_date are quoted. We are strict
 773 * with our parsing, as the file was meant to be eval'd in the now-removed
 774 * git-am.sh/git-rebase--interactive.sh scripts, and thus if the file differs
 775 * from what this function expects, it is better to bail out than to do
 776 * something that the user does not expect.
 777 */
 778int read_author_script(const char *path, char **name, char **email, char **date,
 779                       int allow_missing)
 780{
 781        struct strbuf buf = STRBUF_INIT;
 782        struct string_list kv = STRING_LIST_INIT_DUP;
 783        int retval = -1; /* assume failure */
 784        int i, name_i = -2, email_i = -2, date_i = -2, err = 0;
 785
 786        if (strbuf_read_file(&buf, path, 256) <= 0) {
 787                strbuf_release(&buf);
 788                if (errno == ENOENT && allow_missing)
 789                        return 0;
 790                else
 791                        return error_errno(_("could not open '%s' for reading"),
 792                                           path);
 793        }
 794
 795        if (parse_key_value_squoted(buf.buf, &kv))
 796                goto finish;
 797
 798        for (i = 0; i < kv.nr; i++) {
 799                if (!strcmp(kv.items[i].string, "GIT_AUTHOR_NAME")) {
 800                        if (name_i != -2)
 801                                name_i = error(_("'GIT_AUTHOR_NAME' already given"));
 802                        else
 803                                name_i = i;
 804                } else if (!strcmp(kv.items[i].string, "GIT_AUTHOR_EMAIL")) {
 805                        if (email_i != -2)
 806                                email_i = error(_("'GIT_AUTHOR_EMAIL' already given"));
 807                        else
 808                                email_i = i;
 809                } else if (!strcmp(kv.items[i].string, "GIT_AUTHOR_DATE")) {
 810                        if (date_i != -2)
 811                                date_i = error(_("'GIT_AUTHOR_DATE' already given"));
 812                        else
 813                                date_i = i;
 814                } else {
 815                        err = error(_("unknown variable '%s'"),
 816                                    kv.items[i].string);
 817                }
 818        }
 819        if (name_i == -2)
 820                error(_("missing 'GIT_AUTHOR_NAME'"));
 821        if (email_i == -2)
 822                error(_("missing 'GIT_AUTHOR_EMAIL'"));
 823        if (date_i == -2)
 824                error(_("missing 'GIT_AUTHOR_DATE'"));
 825        if (date_i < 0 || email_i < 0 || date_i < 0 || err)
 826                goto finish;
 827        *name = kv.items[name_i].util;
 828        *email = kv.items[email_i].util;
 829        *date = kv.items[date_i].util;
 830        retval = 0;
 831finish:
 832        string_list_clear(&kv, !!retval);
 833        strbuf_release(&buf);
 834        return retval;
 835}
 836
 837/*
 838 * Read a GIT_AUTHOR_NAME, GIT_AUTHOR_EMAIL AND GIT_AUTHOR_DATE from a
 839 * file with shell quoting into struct argv_array. Returns -1 on
 840 * error, 0 otherwise.
 841 */
 842static int read_env_script(struct argv_array *env)
 843{
 844        char *name, *email, *date;
 845
 846        if (read_author_script(rebase_path_author_script(),
 847                               &name, &email, &date, 0))
 848                return -1;
 849
 850        argv_array_pushf(env, "GIT_AUTHOR_NAME=%s", name);
 851        argv_array_pushf(env, "GIT_AUTHOR_EMAIL=%s", email);
 852        argv_array_pushf(env, "GIT_AUTHOR_DATE=%s", date);
 853        free(name);
 854        free(email);
 855        free(date);
 856
 857        return 0;
 858}
 859
 860static char *get_author(const char *message)
 861{
 862        size_t len;
 863        const char *a;
 864
 865        a = find_commit_header(message, "author", &len);
 866        if (a)
 867                return xmemdupz(a, len);
 868
 869        return NULL;
 870}
 871
 872/* Read author-script and return an ident line (author <email> timestamp) */
 873static const char *read_author_ident(struct strbuf *buf)
 874{
 875        struct strbuf out = STRBUF_INIT;
 876        char *name, *email, *date;
 877
 878        if (read_author_script(rebase_path_author_script(),
 879                               &name, &email, &date, 0))
 880                return NULL;
 881
 882        /* validate date since fmt_ident() will die() on bad value */
 883        if (parse_date(date, &out)){
 884                warning(_("invalid date format '%s' in '%s'"),
 885                        date, rebase_path_author_script());
 886                strbuf_release(&out);
 887                return NULL;
 888        }
 889
 890        strbuf_reset(&out);
 891        strbuf_addstr(&out, fmt_ident(name, email, WANT_AUTHOR_IDENT, date, 0));
 892        strbuf_swap(buf, &out);
 893        strbuf_release(&out);
 894        free(name);
 895        free(email);
 896        free(date);
 897        return buf->buf;
 898}
 899
 900static const char staged_changes_advice[] =
 901N_("you have staged changes in your working tree\n"
 902"If these changes are meant to be squashed into the previous commit, run:\n"
 903"\n"
 904"  git commit --amend %s\n"
 905"\n"
 906"If they are meant to go into a new commit, run:\n"
 907"\n"
 908"  git commit %s\n"
 909"\n"
 910"In both cases, once you're done, continue with:\n"
 911"\n"
 912"  git rebase --continue\n");
 913
 914#define ALLOW_EMPTY (1<<0)
 915#define EDIT_MSG    (1<<1)
 916#define AMEND_MSG   (1<<2)
 917#define CLEANUP_MSG (1<<3)
 918#define VERIFY_MSG  (1<<4)
 919#define CREATE_ROOT_COMMIT (1<<5)
 920
 921static int run_command_silent_on_success(struct child_process *cmd)
 922{
 923        struct strbuf buf = STRBUF_INIT;
 924        int rc;
 925
 926        cmd->stdout_to_stderr = 1;
 927        rc = pipe_command(cmd,
 928                          NULL, 0,
 929                          NULL, 0,
 930                          &buf, 0);
 931
 932        if (rc)
 933                fputs(buf.buf, stderr);
 934        strbuf_release(&buf);
 935        return rc;
 936}
 937
 938/*
 939 * If we are cherry-pick, and if the merge did not result in
 940 * hand-editing, we will hit this commit and inherit the original
 941 * author date and name.
 942 *
 943 * If we are revert, or if our cherry-pick results in a hand merge,
 944 * we had better say that the current user is responsible for that.
 945 *
 946 * An exception is when run_git_commit() is called during an
 947 * interactive rebase: in that case, we will want to retain the
 948 * author metadata.
 949 */
 950static int run_git_commit(struct repository *r,
 951                          const char *defmsg,
 952                          struct replay_opts *opts,
 953                          unsigned int flags)
 954{
 955        struct child_process cmd = CHILD_PROCESS_INIT;
 956
 957        if ((flags & CREATE_ROOT_COMMIT) && !(flags & AMEND_MSG)) {
 958                struct strbuf msg = STRBUF_INIT, script = STRBUF_INIT;
 959                const char *author = NULL;
 960                struct object_id root_commit, *cache_tree_oid;
 961                int res = 0;
 962
 963                if (is_rebase_i(opts)) {
 964                        author = read_author_ident(&script);
 965                        if (!author) {
 966                                strbuf_release(&script);
 967                                return -1;
 968                        }
 969                }
 970
 971                if (!defmsg)
 972                        BUG("root commit without message");
 973
 974                if (!(cache_tree_oid = get_cache_tree_oid(r->index)))
 975                        res = -1;
 976
 977                if (!res)
 978                        res = strbuf_read_file(&msg, defmsg, 0);
 979
 980                if (res <= 0)
 981                        res = error_errno(_("could not read '%s'"), defmsg);
 982                else
 983                        res = commit_tree(msg.buf, msg.len, cache_tree_oid,
 984                                          NULL, &root_commit, author,
 985                                          opts->gpg_sign);
 986
 987                strbuf_release(&msg);
 988                strbuf_release(&script);
 989                if (!res) {
 990                        update_ref(NULL, "CHERRY_PICK_HEAD", &root_commit, NULL,
 991                                   REF_NO_DEREF, UPDATE_REFS_MSG_ON_ERR);
 992                        res = update_ref(NULL, "HEAD", &root_commit, NULL, 0,
 993                                         UPDATE_REFS_MSG_ON_ERR);
 994                }
 995                return res < 0 ? error(_("writing root commit")) : 0;
 996        }
 997
 998        cmd.git_cmd = 1;
 999
1000        if (is_rebase_i(opts) && read_env_script(&cmd.env_array)) {
1001                const char *gpg_opt = gpg_sign_opt_quoted(opts);
1002
1003                return error(_(staged_changes_advice),
1004                             gpg_opt, gpg_opt);
1005        }
1006
1007        argv_array_push(&cmd.args, "commit");
1008
1009        if (!(flags & VERIFY_MSG))
1010                argv_array_push(&cmd.args, "-n");
1011        if ((flags & AMEND_MSG))
1012                argv_array_push(&cmd.args, "--amend");
1013        if (opts->gpg_sign)
1014                argv_array_pushf(&cmd.args, "-S%s", opts->gpg_sign);
1015        if (defmsg)
1016                argv_array_pushl(&cmd.args, "-F", defmsg, NULL);
1017        else if (!(flags & EDIT_MSG))
1018                argv_array_pushl(&cmd.args, "-C", "HEAD", NULL);
1019        if ((flags & CLEANUP_MSG))
1020                argv_array_push(&cmd.args, "--cleanup=strip");
1021        if ((flags & EDIT_MSG))
1022                argv_array_push(&cmd.args, "-e");
1023        else if (!(flags & CLEANUP_MSG) &&
1024                 !opts->signoff && !opts->record_origin &&
1025                 !opts->explicit_cleanup)
1026                argv_array_push(&cmd.args, "--cleanup=verbatim");
1027
1028        if ((flags & ALLOW_EMPTY))
1029                argv_array_push(&cmd.args, "--allow-empty");
1030
1031        if (!(flags & EDIT_MSG))
1032                argv_array_push(&cmd.args, "--allow-empty-message");
1033
1034        if (is_rebase_i(opts) && !(flags & EDIT_MSG))
1035                return run_command_silent_on_success(&cmd);
1036        else
1037                return run_command(&cmd);
1038}
1039
1040static int rest_is_empty(const struct strbuf *sb, int start)
1041{
1042        int i, eol;
1043        const char *nl;
1044
1045        /* Check if the rest is just whitespace and Signed-off-by's. */
1046        for (i = start; i < sb->len; i++) {
1047                nl = memchr(sb->buf + i, '\n', sb->len - i);
1048                if (nl)
1049                        eol = nl - sb->buf;
1050                else
1051                        eol = sb->len;
1052
1053                if (strlen(sign_off_header) <= eol - i &&
1054                    starts_with(sb->buf + i, sign_off_header)) {
1055                        i = eol;
1056                        continue;
1057                }
1058                while (i < eol)
1059                        if (!isspace(sb->buf[i++]))
1060                                return 0;
1061        }
1062
1063        return 1;
1064}
1065
1066void cleanup_message(struct strbuf *msgbuf,
1067        enum commit_msg_cleanup_mode cleanup_mode, int verbose)
1068{
1069        if (verbose || /* Truncate the message just before the diff, if any. */
1070            cleanup_mode == COMMIT_MSG_CLEANUP_SCISSORS)
1071                strbuf_setlen(msgbuf, wt_status_locate_end(msgbuf->buf, msgbuf->len));
1072        if (cleanup_mode != COMMIT_MSG_CLEANUP_NONE)
1073                strbuf_stripspace(msgbuf, cleanup_mode == COMMIT_MSG_CLEANUP_ALL);
1074}
1075
1076/*
1077 * Find out if the message in the strbuf contains only whitespace and
1078 * Signed-off-by lines.
1079 */
1080int message_is_empty(const struct strbuf *sb,
1081                     enum commit_msg_cleanup_mode cleanup_mode)
1082{
1083        if (cleanup_mode == COMMIT_MSG_CLEANUP_NONE && sb->len)
1084                return 0;
1085        return rest_is_empty(sb, 0);
1086}
1087
1088/*
1089 * See if the user edited the message in the editor or left what
1090 * was in the template intact
1091 */
1092int template_untouched(const struct strbuf *sb, const char *template_file,
1093                       enum commit_msg_cleanup_mode cleanup_mode)
1094{
1095        struct strbuf tmpl = STRBUF_INIT;
1096        const char *start;
1097
1098        if (cleanup_mode == COMMIT_MSG_CLEANUP_NONE && sb->len)
1099                return 0;
1100
1101        if (!template_file || strbuf_read_file(&tmpl, template_file, 0) <= 0)
1102                return 0;
1103
1104        strbuf_stripspace(&tmpl, cleanup_mode == COMMIT_MSG_CLEANUP_ALL);
1105        if (!skip_prefix(sb->buf, tmpl.buf, &start))
1106                start = sb->buf;
1107        strbuf_release(&tmpl);
1108        return rest_is_empty(sb, start - sb->buf);
1109}
1110
1111int update_head_with_reflog(const struct commit *old_head,
1112                            const struct object_id *new_head,
1113                            const char *action, const struct strbuf *msg,
1114                            struct strbuf *err)
1115{
1116        struct ref_transaction *transaction;
1117        struct strbuf sb = STRBUF_INIT;
1118        const char *nl;
1119        int ret = 0;
1120
1121        if (action) {
1122                strbuf_addstr(&sb, action);
1123                strbuf_addstr(&sb, ": ");
1124        }
1125
1126        nl = strchr(msg->buf, '\n');
1127        if (nl) {
1128                strbuf_add(&sb, msg->buf, nl + 1 - msg->buf);
1129        } else {
1130                strbuf_addbuf(&sb, msg);
1131                strbuf_addch(&sb, '\n');
1132        }
1133
1134        transaction = ref_transaction_begin(err);
1135        if (!transaction ||
1136            ref_transaction_update(transaction, "HEAD", new_head,
1137                                   old_head ? &old_head->object.oid : &null_oid,
1138                                   0, sb.buf, err) ||
1139            ref_transaction_commit(transaction, err)) {
1140                ret = -1;
1141        }
1142        ref_transaction_free(transaction);
1143        strbuf_release(&sb);
1144
1145        return ret;
1146}
1147
1148static int run_rewrite_hook(const struct object_id *oldoid,
1149                            const struct object_id *newoid)
1150{
1151        struct child_process proc = CHILD_PROCESS_INIT;
1152        const char *argv[3];
1153        int code;
1154        struct strbuf sb = STRBUF_INIT;
1155
1156        argv[0] = find_hook("post-rewrite");
1157        if (!argv[0])
1158                return 0;
1159
1160        argv[1] = "amend";
1161        argv[2] = NULL;
1162
1163        proc.argv = argv;
1164        proc.in = -1;
1165        proc.stdout_to_stderr = 1;
1166        proc.trace2_hook_name = "post-rewrite";
1167
1168        code = start_command(&proc);
1169        if (code)
1170                return code;
1171        strbuf_addf(&sb, "%s %s\n", oid_to_hex(oldoid), oid_to_hex(newoid));
1172        sigchain_push(SIGPIPE, SIG_IGN);
1173        write_in_full(proc.in, sb.buf, sb.len);
1174        close(proc.in);
1175        strbuf_release(&sb);
1176        sigchain_pop(SIGPIPE);
1177        return finish_command(&proc);
1178}
1179
1180void commit_post_rewrite(struct repository *r,
1181                         const struct commit *old_head,
1182                         const struct object_id *new_head)
1183{
1184        struct notes_rewrite_cfg *cfg;
1185
1186        cfg = init_copy_notes_for_rewrite("amend");
1187        if (cfg) {
1188                /* we are amending, so old_head is not NULL */
1189                copy_note_for_rewrite(cfg, &old_head->object.oid, new_head);
1190                finish_copy_notes_for_rewrite(r, cfg, "Notes added by 'git commit --amend'");
1191        }
1192        run_rewrite_hook(&old_head->object.oid, new_head);
1193}
1194
1195static int run_prepare_commit_msg_hook(struct repository *r,
1196                                       struct strbuf *msg,
1197                                       const char *commit)
1198{
1199        struct argv_array hook_env = ARGV_ARRAY_INIT;
1200        int ret;
1201        const char *name;
1202
1203        name = git_path_commit_editmsg();
1204        if (write_message(msg->buf, msg->len, name, 0))
1205                return -1;
1206
1207        argv_array_pushf(&hook_env, "GIT_INDEX_FILE=%s", r->index_file);
1208        argv_array_push(&hook_env, "GIT_EDITOR=:");
1209        if (commit)
1210                ret = run_hook_le(hook_env.argv, "prepare-commit-msg", name,
1211                                  "commit", commit, NULL);
1212        else
1213                ret = run_hook_le(hook_env.argv, "prepare-commit-msg", name,
1214                                  "message", NULL);
1215        if (ret)
1216                ret = error(_("'prepare-commit-msg' hook failed"));
1217        argv_array_clear(&hook_env);
1218
1219        return ret;
1220}
1221
1222static const char implicit_ident_advice_noconfig[] =
1223N_("Your name and email address were configured automatically based\n"
1224"on your username and hostname. Please check that they are accurate.\n"
1225"You can suppress this message by setting them explicitly. Run the\n"
1226"following command and follow the instructions in your editor to edit\n"
1227"your configuration file:\n"
1228"\n"
1229"    git config --global --edit\n"
1230"\n"
1231"After doing this, you may fix the identity used for this commit with:\n"
1232"\n"
1233"    git commit --amend --reset-author\n");
1234
1235static const char implicit_ident_advice_config[] =
1236N_("Your name and email address were configured automatically based\n"
1237"on your username and hostname. Please check that they are accurate.\n"
1238"You can suppress this message by setting them explicitly:\n"
1239"\n"
1240"    git config --global user.name \"Your Name\"\n"
1241"    git config --global user.email you@example.com\n"
1242"\n"
1243"After doing this, you may fix the identity used for this commit with:\n"
1244"\n"
1245"    git commit --amend --reset-author\n");
1246
1247static const char *implicit_ident_advice(void)
1248{
1249        char *user_config = expand_user_path("~/.gitconfig", 0);
1250        char *xdg_config = xdg_config_home("config");
1251        int config_exists = file_exists(user_config) || file_exists(xdg_config);
1252
1253        free(user_config);
1254        free(xdg_config);
1255
1256        if (config_exists)
1257                return _(implicit_ident_advice_config);
1258        else
1259                return _(implicit_ident_advice_noconfig);
1260
1261}
1262
1263void print_commit_summary(struct repository *r,
1264                          const char *prefix,
1265                          const struct object_id *oid,
1266                          unsigned int flags)
1267{
1268        struct rev_info rev;
1269        struct commit *commit;
1270        struct strbuf format = STRBUF_INIT;
1271        const char *head;
1272        struct pretty_print_context pctx = {0};
1273        struct strbuf author_ident = STRBUF_INIT;
1274        struct strbuf committer_ident = STRBUF_INIT;
1275
1276        commit = lookup_commit(r, oid);
1277        if (!commit)
1278                die(_("couldn't look up newly created commit"));
1279        if (parse_commit(commit))
1280                die(_("could not parse newly created commit"));
1281
1282        strbuf_addstr(&format, "format:%h] %s");
1283
1284        format_commit_message(commit, "%an <%ae>", &author_ident, &pctx);
1285        format_commit_message(commit, "%cn <%ce>", &committer_ident, &pctx);
1286        if (strbuf_cmp(&author_ident, &committer_ident)) {
1287                strbuf_addstr(&format, "\n Author: ");
1288                strbuf_addbuf_percentquote(&format, &author_ident);
1289        }
1290        if (flags & SUMMARY_SHOW_AUTHOR_DATE) {
1291                struct strbuf date = STRBUF_INIT;
1292
1293                format_commit_message(commit, "%ad", &date, &pctx);
1294                strbuf_addstr(&format, "\n Date: ");
1295                strbuf_addbuf_percentquote(&format, &date);
1296                strbuf_release(&date);
1297        }
1298        if (!committer_ident_sufficiently_given()) {
1299                strbuf_addstr(&format, "\n Committer: ");
1300                strbuf_addbuf_percentquote(&format, &committer_ident);
1301                if (advice_implicit_identity) {
1302                        strbuf_addch(&format, '\n');
1303                        strbuf_addstr(&format, implicit_ident_advice());
1304                }
1305        }
1306        strbuf_release(&author_ident);
1307        strbuf_release(&committer_ident);
1308
1309        repo_init_revisions(r, &rev, prefix);
1310        setup_revisions(0, NULL, &rev, NULL);
1311
1312        rev.diff = 1;
1313        rev.diffopt.output_format =
1314                DIFF_FORMAT_SHORTSTAT | DIFF_FORMAT_SUMMARY;
1315
1316        rev.verbose_header = 1;
1317        rev.show_root_diff = 1;
1318        get_commit_format(format.buf, &rev);
1319        rev.always_show_header = 0;
1320        rev.diffopt.detect_rename = DIFF_DETECT_RENAME;
1321        rev.diffopt.break_opt = 0;
1322        diff_setup_done(&rev.diffopt);
1323
1324        head = resolve_ref_unsafe("HEAD", 0, NULL, NULL);
1325        if (!head)
1326                die_errno(_("unable to resolve HEAD after creating commit"));
1327        if (!strcmp(head, "HEAD"))
1328                head = _("detached HEAD");
1329        else
1330                skip_prefix(head, "refs/heads/", &head);
1331        printf("[%s%s ", head, (flags & SUMMARY_INITIAL_COMMIT) ?
1332                                                _(" (root-commit)") : "");
1333
1334        if (!log_tree_commit(&rev, commit)) {
1335                rev.always_show_header = 1;
1336                rev.use_terminator = 1;
1337                log_tree_commit(&rev, commit);
1338        }
1339
1340        strbuf_release(&format);
1341}
1342
1343static int parse_head(struct repository *r, struct commit **head)
1344{
1345        struct commit *current_head;
1346        struct object_id oid;
1347
1348        if (get_oid("HEAD", &oid)) {
1349                current_head = NULL;
1350        } else {
1351                current_head = lookup_commit_reference(r, &oid);
1352                if (!current_head)
1353                        return error(_("could not parse HEAD"));
1354                if (!oideq(&oid, &current_head->object.oid)) {
1355                        warning(_("HEAD %s is not a commit!"),
1356                                oid_to_hex(&oid));
1357                }
1358                if (parse_commit(current_head))
1359                        return error(_("could not parse HEAD commit"));
1360        }
1361        *head = current_head;
1362
1363        return 0;
1364}
1365
1366/*
1367 * Try to commit without forking 'git commit'. In some cases we need
1368 * to run 'git commit' to display an error message
1369 *
1370 * Returns:
1371 *  -1 - error unable to commit
1372 *   0 - success
1373 *   1 - run 'git commit'
1374 */
1375static int try_to_commit(struct repository *r,
1376                         struct strbuf *msg, const char *author,
1377                         struct replay_opts *opts, unsigned int flags,
1378                         struct object_id *oid)
1379{
1380        struct object_id tree;
1381        struct commit *current_head;
1382        struct commit_list *parents = NULL;
1383        struct commit_extra_header *extra = NULL;
1384        struct strbuf err = STRBUF_INIT;
1385        struct strbuf commit_msg = STRBUF_INIT;
1386        char *amend_author = NULL;
1387        const char *hook_commit = NULL;
1388        enum commit_msg_cleanup_mode cleanup;
1389        int res = 0;
1390
1391        if (parse_head(r, &current_head))
1392                return -1;
1393
1394        if (flags & AMEND_MSG) {
1395                const char *exclude_gpgsig[] = { "gpgsig", NULL };
1396                const char *out_enc = get_commit_output_encoding();
1397                const char *message = logmsg_reencode(current_head, NULL,
1398                                                      out_enc);
1399
1400                if (!msg) {
1401                        const char *orig_message = NULL;
1402
1403                        find_commit_subject(message, &orig_message);
1404                        msg = &commit_msg;
1405                        strbuf_addstr(msg, orig_message);
1406                        hook_commit = "HEAD";
1407                }
1408                author = amend_author = get_author(message);
1409                unuse_commit_buffer(current_head, message);
1410                if (!author) {
1411                        res = error(_("unable to parse commit author"));
1412                        goto out;
1413                }
1414                parents = copy_commit_list(current_head->parents);
1415                extra = read_commit_extra_headers(current_head, exclude_gpgsig);
1416        } else if (current_head) {
1417                commit_list_insert(current_head, &parents);
1418        }
1419
1420        if (write_index_as_tree(&tree, r->index, r->index_file, 0, NULL)) {
1421                res = error(_("git write-tree failed to write a tree"));
1422                goto out;
1423        }
1424
1425        if (!(flags & ALLOW_EMPTY) && oideq(current_head ?
1426                                            get_commit_tree_oid(current_head) :
1427                                            the_hash_algo->empty_tree, &tree)) {
1428                res = 1; /* run 'git commit' to display error message */
1429                goto out;
1430        }
1431
1432        if (find_hook("prepare-commit-msg")) {
1433                res = run_prepare_commit_msg_hook(r, msg, hook_commit);
1434                if (res)
1435                        goto out;
1436                if (strbuf_read_file(&commit_msg, git_path_commit_editmsg(),
1437                                     2048) < 0) {
1438                        res = error_errno(_("unable to read commit message "
1439                                              "from '%s'"),
1440                                            git_path_commit_editmsg());
1441                        goto out;
1442                }
1443                msg = &commit_msg;
1444        }
1445
1446        if (flags & CLEANUP_MSG)
1447                cleanup = COMMIT_MSG_CLEANUP_ALL;
1448        else if ((opts->signoff || opts->record_origin) &&
1449                 !opts->explicit_cleanup)
1450                cleanup = COMMIT_MSG_CLEANUP_SPACE;
1451        else
1452                cleanup = opts->default_msg_cleanup;
1453
1454        if (cleanup != COMMIT_MSG_CLEANUP_NONE)
1455                strbuf_stripspace(msg, cleanup == COMMIT_MSG_CLEANUP_ALL);
1456        if ((flags & EDIT_MSG) && message_is_empty(msg, cleanup)) {
1457                res = 1; /* run 'git commit' to display error message */
1458                goto out;
1459        }
1460
1461        reset_ident_date();
1462
1463        if (commit_tree_extended(msg->buf, msg->len, &tree, parents,
1464                                 oid, author, opts->gpg_sign, extra)) {
1465                res = error(_("failed to write commit object"));
1466                goto out;
1467        }
1468
1469        if (update_head_with_reflog(current_head, oid,
1470                                    getenv("GIT_REFLOG_ACTION"), msg, &err)) {
1471                res = error("%s", err.buf);
1472                goto out;
1473        }
1474
1475        if (flags & AMEND_MSG)
1476                commit_post_rewrite(r, current_head, oid);
1477
1478out:
1479        free_commit_extra_headers(extra);
1480        strbuf_release(&err);
1481        strbuf_release(&commit_msg);
1482        free(amend_author);
1483
1484        return res;
1485}
1486
1487static int do_commit(struct repository *r,
1488                     const char *msg_file, const char *author,
1489                     struct replay_opts *opts, unsigned int flags)
1490{
1491        int res = 1;
1492
1493        if (!(flags & EDIT_MSG) && !(flags & VERIFY_MSG) &&
1494            !(flags & CREATE_ROOT_COMMIT)) {
1495                struct object_id oid;
1496                struct strbuf sb = STRBUF_INIT;
1497
1498                if (msg_file && strbuf_read_file(&sb, msg_file, 2048) < 0)
1499                        return error_errno(_("unable to read commit message "
1500                                             "from '%s'"),
1501                                           msg_file);
1502
1503                res = try_to_commit(r, msg_file ? &sb : NULL,
1504                                    author, opts, flags, &oid);
1505                strbuf_release(&sb);
1506                if (!res) {
1507                        unlink(git_path_cherry_pick_head(r));
1508                        unlink(git_path_merge_msg(r));
1509                        if (!is_rebase_i(opts))
1510                                print_commit_summary(r, NULL, &oid,
1511                                                SUMMARY_SHOW_AUTHOR_DATE);
1512                        return res;
1513                }
1514        }
1515        if (res == 1)
1516                return run_git_commit(r, msg_file, opts, flags);
1517
1518        return res;
1519}
1520
1521static int is_original_commit_empty(struct commit *commit)
1522{
1523        const struct object_id *ptree_oid;
1524
1525        if (parse_commit(commit))
1526                return error(_("could not parse commit %s"),
1527                             oid_to_hex(&commit->object.oid));
1528        if (commit->parents) {
1529                struct commit *parent = commit->parents->item;
1530                if (parse_commit(parent))
1531                        return error(_("could not parse parent commit %s"),
1532                                oid_to_hex(&parent->object.oid));
1533                ptree_oid = get_commit_tree_oid(parent);
1534        } else {
1535                ptree_oid = the_hash_algo->empty_tree; /* commit is root */
1536        }
1537
1538        return oideq(ptree_oid, get_commit_tree_oid(commit));
1539}
1540
1541/*
1542 * Do we run "git commit" with "--allow-empty"?
1543 */
1544static int allow_empty(struct repository *r,
1545                       struct replay_opts *opts,
1546                       struct commit *commit)
1547{
1548        int index_unchanged, empty_commit;
1549
1550        /*
1551         * Three cases:
1552         *
1553         * (1) we do not allow empty at all and error out.
1554         *
1555         * (2) we allow ones that were initially empty, but
1556         * forbid the ones that become empty;
1557         *
1558         * (3) we allow both.
1559         */
1560        if (!opts->allow_empty)
1561                return 0; /* let "git commit" barf as necessary */
1562
1563        index_unchanged = is_index_unchanged(r);
1564        if (index_unchanged < 0)
1565                return index_unchanged;
1566        if (!index_unchanged)
1567                return 0; /* we do not have to say --allow-empty */
1568
1569        if (opts->keep_redundant_commits)
1570                return 1;
1571
1572        empty_commit = is_original_commit_empty(commit);
1573        if (empty_commit < 0)
1574                return empty_commit;
1575        if (!empty_commit)
1576                return 0;
1577        else
1578                return 1;
1579}
1580
1581static struct {
1582        char c;
1583        const char *str;
1584} todo_command_info[] = {
1585        { 'p', "pick" },
1586        { 0,   "revert" },
1587        { 'e', "edit" },
1588        { 'r', "reword" },
1589        { 'f', "fixup" },
1590        { 's', "squash" },
1591        { 'x', "exec" },
1592        { 'b', "break" },
1593        { 'l', "label" },
1594        { 't', "reset" },
1595        { 'm', "merge" },
1596        { 0,   "noop" },
1597        { 'd', "drop" },
1598        { 0,   NULL }
1599};
1600
1601static const char *command_to_string(const enum todo_command command)
1602{
1603        if (command < TODO_COMMENT)
1604                return todo_command_info[command].str;
1605        die(_("unknown command: %d"), command);
1606}
1607
1608static char command_to_char(const enum todo_command command)
1609{
1610        if (command < TODO_COMMENT && todo_command_info[command].c)
1611                return todo_command_info[command].c;
1612        return comment_line_char;
1613}
1614
1615static int is_noop(const enum todo_command command)
1616{
1617        return TODO_NOOP <= command;
1618}
1619
1620static int is_fixup(enum todo_command command)
1621{
1622        return command == TODO_FIXUP || command == TODO_SQUASH;
1623}
1624
1625/* Does this command create a (non-merge) commit? */
1626static int is_pick_or_similar(enum todo_command command)
1627{
1628        switch (command) {
1629        case TODO_PICK:
1630        case TODO_REVERT:
1631        case TODO_EDIT:
1632        case TODO_REWORD:
1633        case TODO_FIXUP:
1634        case TODO_SQUASH:
1635                return 1;
1636        default:
1637                return 0;
1638        }
1639}
1640
1641static int update_squash_messages(struct repository *r,
1642                                  enum todo_command command,
1643                                  struct commit *commit,
1644                                  struct replay_opts *opts)
1645{
1646        struct strbuf buf = STRBUF_INIT;
1647        int res;
1648        const char *message, *body;
1649
1650        if (opts->current_fixup_count > 0) {
1651                struct strbuf header = STRBUF_INIT;
1652                char *eol;
1653
1654                if (strbuf_read_file(&buf, rebase_path_squash_msg(), 9) <= 0)
1655                        return error(_("could not read '%s'"),
1656                                rebase_path_squash_msg());
1657
1658                eol = buf.buf[0] != comment_line_char ?
1659                        buf.buf : strchrnul(buf.buf, '\n');
1660
1661                strbuf_addf(&header, "%c ", comment_line_char);
1662                strbuf_addf(&header, _("This is a combination of %d commits."),
1663                            opts->current_fixup_count + 2);
1664                strbuf_splice(&buf, 0, eol - buf.buf, header.buf, header.len);
1665                strbuf_release(&header);
1666        } else {
1667                struct object_id head;
1668                struct commit *head_commit;
1669                const char *head_message, *body;
1670
1671                if (get_oid("HEAD", &head))
1672                        return error(_("need a HEAD to fixup"));
1673                if (!(head_commit = lookup_commit_reference(r, &head)))
1674                        return error(_("could not read HEAD"));
1675                if (!(head_message = get_commit_buffer(head_commit, NULL)))
1676                        return error(_("could not read HEAD's commit message"));
1677
1678                find_commit_subject(head_message, &body);
1679                if (write_message(body, strlen(body),
1680                                  rebase_path_fixup_msg(), 0)) {
1681                        unuse_commit_buffer(head_commit, head_message);
1682                        return error(_("cannot write '%s'"),
1683                                     rebase_path_fixup_msg());
1684                }
1685
1686                strbuf_addf(&buf, "%c ", comment_line_char);
1687                strbuf_addf(&buf, _("This is a combination of %d commits."), 2);
1688                strbuf_addf(&buf, "\n%c ", comment_line_char);
1689                strbuf_addstr(&buf, _("This is the 1st commit message:"));
1690                strbuf_addstr(&buf, "\n\n");
1691                strbuf_addstr(&buf, body);
1692
1693                unuse_commit_buffer(head_commit, head_message);
1694        }
1695
1696        if (!(message = get_commit_buffer(commit, NULL)))
1697                return error(_("could not read commit message of %s"),
1698                             oid_to_hex(&commit->object.oid));
1699        find_commit_subject(message, &body);
1700
1701        if (command == TODO_SQUASH) {
1702                unlink(rebase_path_fixup_msg());
1703                strbuf_addf(&buf, "\n%c ", comment_line_char);
1704                strbuf_addf(&buf, _("This is the commit message #%d:"),
1705                            ++opts->current_fixup_count + 1);
1706                strbuf_addstr(&buf, "\n\n");
1707                strbuf_addstr(&buf, body);
1708        } else if (command == TODO_FIXUP) {
1709                strbuf_addf(&buf, "\n%c ", comment_line_char);
1710                strbuf_addf(&buf, _("The commit message #%d will be skipped:"),
1711                            ++opts->current_fixup_count + 1);
1712                strbuf_addstr(&buf, "\n\n");
1713                strbuf_add_commented_lines(&buf, body, strlen(body));
1714        } else
1715                return error(_("unknown command: %d"), command);
1716        unuse_commit_buffer(commit, message);
1717
1718        res = write_message(buf.buf, buf.len, rebase_path_squash_msg(), 0);
1719        strbuf_release(&buf);
1720
1721        if (!res) {
1722                strbuf_addf(&opts->current_fixups, "%s%s %s",
1723                            opts->current_fixups.len ? "\n" : "",
1724                            command_to_string(command),
1725                            oid_to_hex(&commit->object.oid));
1726                res = write_message(opts->current_fixups.buf,
1727                                    opts->current_fixups.len,
1728                                    rebase_path_current_fixups(), 0);
1729        }
1730
1731        return res;
1732}
1733
1734static void flush_rewritten_pending(void)
1735{
1736        struct strbuf buf = STRBUF_INIT;
1737        struct object_id newoid;
1738        FILE *out;
1739
1740        if (strbuf_read_file(&buf, rebase_path_rewritten_pending(), (GIT_MAX_HEXSZ + 1) * 2) > 0 &&
1741            !get_oid("HEAD", &newoid) &&
1742            (out = fopen_or_warn(rebase_path_rewritten_list(), "a"))) {
1743                char *bol = buf.buf, *eol;
1744
1745                while (*bol) {
1746                        eol = strchrnul(bol, '\n');
1747                        fprintf(out, "%.*s %s\n", (int)(eol - bol),
1748                                        bol, oid_to_hex(&newoid));
1749                        if (!*eol)
1750                                break;
1751                        bol = eol + 1;
1752                }
1753                fclose(out);
1754                unlink(rebase_path_rewritten_pending());
1755        }
1756        strbuf_release(&buf);
1757}
1758
1759static void record_in_rewritten(struct object_id *oid,
1760                enum todo_command next_command)
1761{
1762        FILE *out = fopen_or_warn(rebase_path_rewritten_pending(), "a");
1763
1764        if (!out)
1765                return;
1766
1767        fprintf(out, "%s\n", oid_to_hex(oid));
1768        fclose(out);
1769
1770        if (!is_fixup(next_command))
1771                flush_rewritten_pending();
1772}
1773
1774static int do_pick_commit(struct repository *r,
1775                          enum todo_command command,
1776                          struct commit *commit,
1777                          struct replay_opts *opts,
1778                          int final_fixup)
1779{
1780        unsigned int flags = opts->edit ? EDIT_MSG : 0;
1781        const char *msg_file = opts->edit ? NULL : git_path_merge_msg(r);
1782        struct object_id head;
1783        struct commit *base, *next, *parent;
1784        const char *base_label, *next_label;
1785        char *author = NULL;
1786        struct commit_message msg = { NULL, NULL, NULL, NULL };
1787        struct strbuf msgbuf = STRBUF_INIT;
1788        int res, unborn = 0, allow;
1789
1790        if (opts->no_commit) {
1791                /*
1792                 * We do not intend to commit immediately.  We just want to
1793                 * merge the differences in, so let's compute the tree
1794                 * that represents the "current" state for merge-recursive
1795                 * to work on.
1796                 */
1797                if (write_index_as_tree(&head, r->index, r->index_file, 0, NULL))
1798                        return error(_("your index file is unmerged."));
1799        } else {
1800                unborn = get_oid("HEAD", &head);
1801                /* Do we want to generate a root commit? */
1802                if (is_pick_or_similar(command) && opts->have_squash_onto &&
1803                    oideq(&head, &opts->squash_onto)) {
1804                        if (is_fixup(command))
1805                                return error(_("cannot fixup root commit"));
1806                        flags |= CREATE_ROOT_COMMIT;
1807                        unborn = 1;
1808                } else if (unborn)
1809                        oidcpy(&head, the_hash_algo->empty_tree);
1810                if (index_differs_from(r, unborn ? empty_tree_oid_hex() : "HEAD",
1811                                       NULL, 0))
1812                        return error_dirty_index(r, opts);
1813        }
1814        discard_index(r->index);
1815
1816        if (!commit->parents)
1817                parent = NULL;
1818        else if (commit->parents->next) {
1819                /* Reverting or cherry-picking a merge commit */
1820                int cnt;
1821                struct commit_list *p;
1822
1823                if (!opts->mainline)
1824                        return error(_("commit %s is a merge but no -m option was given."),
1825                                oid_to_hex(&commit->object.oid));
1826
1827                for (cnt = 1, p = commit->parents;
1828                     cnt != opts->mainline && p;
1829                     cnt++)
1830                        p = p->next;
1831                if (cnt != opts->mainline || !p)
1832                        return error(_("commit %s does not have parent %d"),
1833                                oid_to_hex(&commit->object.oid), opts->mainline);
1834                parent = p->item;
1835        } else if (1 < opts->mainline)
1836                /*
1837                 *  Non-first parent explicitly specified as mainline for
1838                 *  non-merge commit
1839                 */
1840                return error(_("commit %s does not have parent %d"),
1841                             oid_to_hex(&commit->object.oid), opts->mainline);
1842        else
1843                parent = commit->parents->item;
1844
1845        if (get_message(commit, &msg) != 0)
1846                return error(_("cannot get commit message for %s"),
1847                        oid_to_hex(&commit->object.oid));
1848
1849        if (opts->allow_ff && !is_fixup(command) &&
1850            ((parent && oideq(&parent->object.oid, &head)) ||
1851             (!parent && unborn))) {
1852                if (is_rebase_i(opts))
1853                        write_author_script(msg.message);
1854                res = fast_forward_to(r, &commit->object.oid, &head, unborn,
1855                        opts);
1856                if (res || command != TODO_REWORD)
1857                        goto leave;
1858                flags |= EDIT_MSG | AMEND_MSG | VERIFY_MSG;
1859                msg_file = NULL;
1860                goto fast_forward_edit;
1861        }
1862        if (parent && parse_commit(parent) < 0)
1863                /* TRANSLATORS: The first %s will be a "todo" command like
1864                   "revert" or "pick", the second %s a SHA1. */
1865                return error(_("%s: cannot parse parent commit %s"),
1866                        command_to_string(command),
1867                        oid_to_hex(&parent->object.oid));
1868
1869        /*
1870         * "commit" is an existing commit.  We would want to apply
1871         * the difference it introduces since its first parent "prev"
1872         * on top of the current HEAD if we are cherry-pick.  Or the
1873         * reverse of it if we are revert.
1874         */
1875
1876        if (command == TODO_REVERT) {
1877                base = commit;
1878                base_label = msg.label;
1879                next = parent;
1880                next_label = msg.parent_label;
1881                strbuf_addstr(&msgbuf, "Revert \"");
1882                strbuf_addstr(&msgbuf, msg.subject);
1883                strbuf_addstr(&msgbuf, "\"\n\nThis reverts commit ");
1884                strbuf_addstr(&msgbuf, oid_to_hex(&commit->object.oid));
1885
1886                if (commit->parents && commit->parents->next) {
1887                        strbuf_addstr(&msgbuf, ", reversing\nchanges made to ");
1888                        strbuf_addstr(&msgbuf, oid_to_hex(&parent->object.oid));
1889                }
1890                strbuf_addstr(&msgbuf, ".\n");
1891        } else {
1892                const char *p;
1893
1894                base = parent;
1895                base_label = msg.parent_label;
1896                next = commit;
1897                next_label = msg.label;
1898
1899                /* Append the commit log message to msgbuf. */
1900                if (find_commit_subject(msg.message, &p))
1901                        strbuf_addstr(&msgbuf, p);
1902
1903                if (opts->record_origin) {
1904                        strbuf_complete_line(&msgbuf);
1905                        if (!has_conforming_footer(&msgbuf, NULL, 0))
1906                                strbuf_addch(&msgbuf, '\n');
1907                        strbuf_addstr(&msgbuf, cherry_picked_prefix);
1908                        strbuf_addstr(&msgbuf, oid_to_hex(&commit->object.oid));
1909                        strbuf_addstr(&msgbuf, ")\n");
1910                }
1911                if (!is_fixup(command))
1912                        author = get_author(msg.message);
1913        }
1914
1915        if (command == TODO_REWORD)
1916                flags |= EDIT_MSG | VERIFY_MSG;
1917        else if (is_fixup(command)) {
1918                if (update_squash_messages(r, command, commit, opts))
1919                        return -1;
1920                flags |= AMEND_MSG;
1921                if (!final_fixup)
1922                        msg_file = rebase_path_squash_msg();
1923                else if (file_exists(rebase_path_fixup_msg())) {
1924                        flags |= CLEANUP_MSG;
1925                        msg_file = rebase_path_fixup_msg();
1926                } else {
1927                        const char *dest = git_path_squash_msg(r);
1928                        unlink(dest);
1929                        if (copy_file(dest, rebase_path_squash_msg(), 0666))
1930                                return error(_("could not rename '%s' to '%s'"),
1931                                             rebase_path_squash_msg(), dest);
1932                        unlink(git_path_merge_msg(r));
1933                        msg_file = dest;
1934                        flags |= EDIT_MSG;
1935                }
1936        }
1937
1938        if (opts->signoff && !is_fixup(command))
1939                append_signoff(&msgbuf, 0, 0);
1940
1941        if (is_rebase_i(opts) && write_author_script(msg.message) < 0)
1942                res = -1;
1943        else if (!opts->strategy || !strcmp(opts->strategy, "recursive") || command == TODO_REVERT) {
1944                res = do_recursive_merge(r, base, next, base_label, next_label,
1945                                         &head, &msgbuf, opts);
1946                if (res < 0)
1947                        goto leave;
1948
1949                res |= write_message(msgbuf.buf, msgbuf.len,
1950                                     git_path_merge_msg(r), 0);
1951        } else {
1952                struct commit_list *common = NULL;
1953                struct commit_list *remotes = NULL;
1954
1955                res = write_message(msgbuf.buf, msgbuf.len,
1956                                    git_path_merge_msg(r), 0);
1957
1958                commit_list_insert(base, &common);
1959                commit_list_insert(next, &remotes);
1960                res |= try_merge_command(r, opts->strategy,
1961                                         opts->xopts_nr, (const char **)opts->xopts,
1962                                        common, oid_to_hex(&head), remotes);
1963                free_commit_list(common);
1964                free_commit_list(remotes);
1965        }
1966        strbuf_release(&msgbuf);
1967
1968        /*
1969         * If the merge was clean or if it failed due to conflict, we write
1970         * CHERRY_PICK_HEAD for the subsequent invocation of commit to use.
1971         * However, if the merge did not even start, then we don't want to
1972         * write it at all.
1973         */
1974        if (command == TODO_PICK && !opts->no_commit && (res == 0 || res == 1) &&
1975            update_ref(NULL, "CHERRY_PICK_HEAD", &commit->object.oid, NULL,
1976                       REF_NO_DEREF, UPDATE_REFS_MSG_ON_ERR))
1977                res = -1;
1978        if (command == TODO_REVERT && ((opts->no_commit && res == 0) || res == 1) &&
1979            update_ref(NULL, "REVERT_HEAD", &commit->object.oid, NULL,
1980                       REF_NO_DEREF, UPDATE_REFS_MSG_ON_ERR))
1981                res = -1;
1982
1983        if (res) {
1984                error(command == TODO_REVERT
1985                      ? _("could not revert %s... %s")
1986                      : _("could not apply %s... %s"),
1987                      short_commit_name(commit), msg.subject);
1988                print_advice(r, res == 1, opts);
1989                repo_rerere(r, opts->allow_rerere_auto);
1990                goto leave;
1991        }
1992
1993        allow = allow_empty(r, opts, commit);
1994        if (allow < 0) {
1995                res = allow;
1996                goto leave;
1997        } else if (allow)
1998                flags |= ALLOW_EMPTY;
1999        if (!opts->no_commit) {
2000fast_forward_edit:
2001                if (author || command == TODO_REVERT || (flags & AMEND_MSG))
2002                        res = do_commit(r, msg_file, author, opts, flags);
2003                else
2004                        res = error(_("unable to parse commit author"));
2005        }
2006
2007        if (!res && final_fixup) {
2008                unlink(rebase_path_fixup_msg());
2009                unlink(rebase_path_squash_msg());
2010                unlink(rebase_path_current_fixups());
2011                strbuf_reset(&opts->current_fixups);
2012                opts->current_fixup_count = 0;
2013        }
2014
2015leave:
2016        free_message(commit, &msg);
2017        free(author);
2018        update_abort_safety_file();
2019
2020        return res;
2021}
2022
2023static int prepare_revs(struct replay_opts *opts)
2024{
2025        /*
2026         * picking (but not reverting) ranges (but not individual revisions)
2027         * should be done in reverse
2028         */
2029        if (opts->action == REPLAY_PICK && !opts->revs->no_walk)
2030                opts->revs->reverse ^= 1;
2031
2032        if (prepare_revision_walk(opts->revs))
2033                return error(_("revision walk setup failed"));
2034
2035        return 0;
2036}
2037
2038static int read_and_refresh_cache(struct repository *r,
2039                                  struct replay_opts *opts)
2040{
2041        struct lock_file index_lock = LOCK_INIT;
2042        int index_fd = repo_hold_locked_index(r, &index_lock, 0);
2043        if (repo_read_index(r) < 0) {
2044                rollback_lock_file(&index_lock);
2045                return error(_("git %s: failed to read the index"),
2046                        _(action_name(opts)));
2047        }
2048        refresh_index(r->index, REFRESH_QUIET|REFRESH_UNMERGED, NULL, NULL, NULL);
2049        if (index_fd >= 0) {
2050                if (write_locked_index(r->index, &index_lock,
2051                                       COMMIT_LOCK | SKIP_IF_UNCHANGED)) {
2052                        return error(_("git %s: failed to refresh the index"),
2053                                _(action_name(opts)));
2054                }
2055        }
2056        return 0;
2057}
2058
2059enum todo_item_flags {
2060        TODO_EDIT_MERGE_MSG = 1
2061};
2062
2063void todo_list_release(struct todo_list *todo_list)
2064{
2065        strbuf_release(&todo_list->buf);
2066        FREE_AND_NULL(todo_list->items);
2067        todo_list->nr = todo_list->alloc = 0;
2068}
2069
2070static struct todo_item *append_new_todo(struct todo_list *todo_list)
2071{
2072        ALLOC_GROW(todo_list->items, todo_list->nr + 1, todo_list->alloc);
2073        return todo_list->items + todo_list->nr++;
2074}
2075
2076const char *todo_item_get_arg(struct todo_list *todo_list,
2077                              struct todo_item *item)
2078{
2079        return todo_list->buf.buf + item->arg_offset;
2080}
2081
2082static int is_command(enum todo_command command, const char **bol)
2083{
2084        const char *str = todo_command_info[command].str;
2085        const char nick = todo_command_info[command].c;
2086        const char *p = *bol + 1;
2087
2088        return skip_prefix(*bol, str, bol) ||
2089                ((nick && **bol == nick) &&
2090                 (*p == ' ' || *p == '\t' || *p == '\n' || *p == '\r' || !*p) &&
2091                 (*bol = p));
2092}
2093
2094static int parse_insn_line(struct repository *r, struct todo_item *item,
2095                           const char *buf, const char *bol, char *eol)
2096{
2097        struct object_id commit_oid;
2098        char *end_of_object_name;
2099        int i, saved, status, padding;
2100
2101        item->flags = 0;
2102
2103        /* left-trim */
2104        bol += strspn(bol, " \t");
2105
2106        if (bol == eol || *bol == '\r' || *bol == comment_line_char) {
2107                item->command = TODO_COMMENT;
2108                item->commit = NULL;
2109                item->arg_offset = bol - buf;
2110                item->arg_len = eol - bol;
2111                return 0;
2112        }
2113
2114        for (i = 0; i < TODO_COMMENT; i++)
2115                if (is_command(i, &bol)) {
2116                        item->command = i;
2117                        break;
2118                }
2119        if (i >= TODO_COMMENT)
2120                return -1;
2121
2122        /* Eat up extra spaces/ tabs before object name */
2123        padding = strspn(bol, " \t");
2124        bol += padding;
2125
2126        if (item->command == TODO_NOOP || item->command == TODO_BREAK) {
2127                if (bol != eol)
2128                        return error(_("%s does not accept arguments: '%s'"),
2129                                     command_to_string(item->command), bol);
2130                item->commit = NULL;
2131                item->arg_offset = bol - buf;
2132                item->arg_len = eol - bol;
2133                return 0;
2134        }
2135
2136        if (!padding)
2137                return error(_("missing arguments for %s"),
2138                             command_to_string(item->command));
2139
2140        if (item->command == TODO_EXEC || item->command == TODO_LABEL ||
2141            item->command == TODO_RESET) {
2142                item->commit = NULL;
2143                item->arg_offset = bol - buf;
2144                item->arg_len = (int)(eol - bol);
2145                return 0;
2146        }
2147
2148        if (item->command == TODO_MERGE) {
2149                if (skip_prefix(bol, "-C", &bol))
2150                        bol += strspn(bol, " \t");
2151                else if (skip_prefix(bol, "-c", &bol)) {
2152                        bol += strspn(bol, " \t");
2153                        item->flags |= TODO_EDIT_MERGE_MSG;
2154                } else {
2155                        item->flags |= TODO_EDIT_MERGE_MSG;
2156                        item->commit = NULL;
2157                        item->arg_offset = bol - buf;
2158                        item->arg_len = (int)(eol - bol);
2159                        return 0;
2160                }
2161        }
2162
2163        end_of_object_name = (char *) bol + strcspn(bol, " \t\n");
2164        saved = *end_of_object_name;
2165        *end_of_object_name = '\0';
2166        status = get_oid(bol, &commit_oid);
2167        *end_of_object_name = saved;
2168
2169        bol = end_of_object_name + strspn(end_of_object_name, " \t");
2170        item->arg_offset = bol - buf;
2171        item->arg_len = (int)(eol - bol);
2172
2173        if (status < 0)
2174                return error(_("could not parse '%.*s'"),
2175                             (int)(end_of_object_name - bol), bol);
2176
2177        item->commit = lookup_commit_reference(r, &commit_oid);
2178        return !item->commit;
2179}
2180
2181int sequencer_get_last_command(struct repository *r, enum replay_action *action)
2182{
2183        const char *todo_file, *bol;
2184        struct strbuf buf = STRBUF_INIT;
2185        int ret = 0;
2186
2187        todo_file = git_path_todo_file();
2188        if (strbuf_read_file(&buf, todo_file, 0) < 0) {
2189                if (errno == ENOENT || errno == ENOTDIR)
2190                        return -1;
2191                else
2192                        return error_errno("unable to open '%s'", todo_file);
2193        }
2194        bol = buf.buf + strspn(buf.buf, " \t\r\n");
2195        if (is_command(TODO_PICK, &bol) && (*bol == ' ' || *bol == '\t'))
2196                *action = REPLAY_PICK;
2197        else if (is_command(TODO_REVERT, &bol) &&
2198                 (*bol == ' ' || *bol == '\t'))
2199                *action = REPLAY_REVERT;
2200        else
2201                ret = -1;
2202
2203        strbuf_release(&buf);
2204
2205        return ret;
2206}
2207
2208int todo_list_parse_insn_buffer(struct repository *r, char *buf,
2209                                struct todo_list *todo_list)
2210{
2211        struct todo_item *item;
2212        char *p = buf, *next_p;
2213        int i, res = 0, fixup_okay = file_exists(rebase_path_done());
2214
2215        todo_list->current = todo_list->nr = 0;
2216
2217        for (i = 1; *p; i++, p = next_p) {
2218                char *eol = strchrnul(p, '\n');
2219
2220                next_p = *eol ? eol + 1 /* skip LF */ : eol;
2221
2222                if (p != eol && eol[-1] == '\r')
2223                        eol--; /* strip Carriage Return */
2224
2225                item = append_new_todo(todo_list);
2226                item->offset_in_buf = p - todo_list->buf.buf;
2227                if (parse_insn_line(r, item, buf, p, eol)) {
2228                        res = error(_("invalid line %d: %.*s"),
2229                                i, (int)(eol - p), p);
2230                        item->command = TODO_COMMENT + 1;
2231                        item->arg_offset = p - buf;
2232                        item->arg_len = (int)(eol - p);
2233                        item->commit = NULL;
2234                }
2235
2236                if (fixup_okay)
2237                        ; /* do nothing */
2238                else if (is_fixup(item->command))
2239                        return error(_("cannot '%s' without a previous commit"),
2240                                command_to_string(item->command));
2241                else if (!is_noop(item->command))
2242                        fixup_okay = 1;
2243        }
2244
2245        return res;
2246}
2247
2248static int count_commands(struct todo_list *todo_list)
2249{
2250        int count = 0, i;
2251
2252        for (i = 0; i < todo_list->nr; i++)
2253                if (todo_list->items[i].command != TODO_COMMENT)
2254                        count++;
2255
2256        return count;
2257}
2258
2259static int get_item_line_offset(struct todo_list *todo_list, int index)
2260{
2261        return index < todo_list->nr ?
2262                todo_list->items[index].offset_in_buf : todo_list->buf.len;
2263}
2264
2265static const char *get_item_line(struct todo_list *todo_list, int index)
2266{
2267        return todo_list->buf.buf + get_item_line_offset(todo_list, index);
2268}
2269
2270static int get_item_line_length(struct todo_list *todo_list, int index)
2271{
2272        return get_item_line_offset(todo_list, index + 1)
2273                -  get_item_line_offset(todo_list, index);
2274}
2275
2276static ssize_t strbuf_read_file_or_whine(struct strbuf *sb, const char *path)
2277{
2278        int fd;
2279        ssize_t len;
2280
2281        fd = open(path, O_RDONLY);
2282        if (fd < 0)
2283                return error_errno(_("could not open '%s'"), path);
2284        len = strbuf_read(sb, fd, 0);
2285        close(fd);
2286        if (len < 0)
2287                return error(_("could not read '%s'."), path);
2288        return len;
2289}
2290
2291static int have_finished_the_last_pick(void)
2292{
2293        struct strbuf buf = STRBUF_INIT;
2294        const char *eol;
2295        const char *todo_path = git_path_todo_file();
2296        int ret = 0;
2297
2298        if (strbuf_read_file(&buf, todo_path, 0) < 0) {
2299                if (errno == ENOENT) {
2300                        return 0;
2301                } else {
2302                        error_errno("unable to open '%s'", todo_path);
2303                        return 0;
2304                }
2305        }
2306        /* If there is only one line then we are done */
2307        eol = strchr(buf.buf, '\n');
2308        if (!eol || !eol[1])
2309                ret = 1;
2310
2311        strbuf_release(&buf);
2312
2313        return ret;
2314}
2315
2316void sequencer_post_commit_cleanup(struct repository *r, int verbose)
2317{
2318        struct replay_opts opts = REPLAY_OPTS_INIT;
2319        int need_cleanup = 0;
2320
2321        if (file_exists(git_path_cherry_pick_head(r))) {
2322                if (!unlink(git_path_cherry_pick_head(r)) && verbose)
2323                        warning(_("cancelling a cherry picking in progress"));
2324                opts.action = REPLAY_PICK;
2325                need_cleanup = 1;
2326        }
2327
2328        if (file_exists(git_path_revert_head(r))) {
2329                if (!unlink(git_path_revert_head(r)) && verbose)
2330                        warning(_("cancelling a revert in progress"));
2331                opts.action = REPLAY_REVERT;
2332                need_cleanup = 1;
2333        }
2334
2335        if (!need_cleanup)
2336                return;
2337
2338        if (!have_finished_the_last_pick())
2339                return;
2340
2341        sequencer_remove_state(&opts);
2342}
2343
2344static int read_populate_todo(struct repository *r,
2345                              struct todo_list *todo_list,
2346                              struct replay_opts *opts)
2347{
2348        struct stat st;
2349        const char *todo_file = get_todo_path(opts);
2350        int res;
2351
2352        strbuf_reset(&todo_list->buf);
2353        if (strbuf_read_file_or_whine(&todo_list->buf, todo_file) < 0)
2354                return -1;
2355
2356        res = stat(todo_file, &st);
2357        if (res)
2358                return error(_("could not stat '%s'"), todo_file);
2359        fill_stat_data(&todo_list->stat, &st);
2360
2361        res = todo_list_parse_insn_buffer(r, todo_list->buf.buf, todo_list);
2362        if (res) {
2363                if (is_rebase_i(opts))
2364                        return error(_("please fix this using "
2365                                       "'git rebase --edit-todo'."));
2366                return error(_("unusable instruction sheet: '%s'"), todo_file);
2367        }
2368
2369        if (!todo_list->nr &&
2370            (!is_rebase_i(opts) || !file_exists(rebase_path_done())))
2371                return error(_("no commits parsed."));
2372
2373        if (!is_rebase_i(opts)) {
2374                enum todo_command valid =
2375                        opts->action == REPLAY_PICK ? TODO_PICK : TODO_REVERT;
2376                int i;
2377
2378                for (i = 0; i < todo_list->nr; i++)
2379                        if (valid == todo_list->items[i].command)
2380                                continue;
2381                        else if (valid == TODO_PICK)
2382                                return error(_("cannot cherry-pick during a revert."));
2383                        else
2384                                return error(_("cannot revert during a cherry-pick."));
2385        }
2386
2387        if (is_rebase_i(opts)) {
2388                struct todo_list done = TODO_LIST_INIT;
2389                FILE *f = fopen_or_warn(rebase_path_msgtotal(), "w");
2390
2391                if (strbuf_read_file(&done.buf, rebase_path_done(), 0) > 0 &&
2392                    !todo_list_parse_insn_buffer(r, done.buf.buf, &done))
2393                        todo_list->done_nr = count_commands(&done);
2394                else
2395                        todo_list->done_nr = 0;
2396
2397                todo_list->total_nr = todo_list->done_nr
2398                        + count_commands(todo_list);
2399                todo_list_release(&done);
2400
2401                if (f) {
2402                        fprintf(f, "%d\n", todo_list->total_nr);
2403                        fclose(f);
2404                }
2405        }
2406
2407        return 0;
2408}
2409
2410static int git_config_string_dup(char **dest,
2411                                 const char *var, const char *value)
2412{
2413        if (!value)
2414                return config_error_nonbool(var);
2415        free(*dest);
2416        *dest = xstrdup(value);
2417        return 0;
2418}
2419
2420static int populate_opts_cb(const char *key, const char *value, void *data)
2421{
2422        struct replay_opts *opts = data;
2423        int error_flag = 1;
2424
2425        if (!value)
2426                error_flag = 0;
2427        else if (!strcmp(key, "options.no-commit"))
2428                opts->no_commit = git_config_bool_or_int(key, value, &error_flag);
2429        else if (!strcmp(key, "options.edit"))
2430                opts->edit = git_config_bool_or_int(key, value, &error_flag);
2431        else if (!strcmp(key, "options.allow-empty"))
2432                opts->allow_empty =
2433                        git_config_bool_or_int(key, value, &error_flag);
2434        else if (!strcmp(key, "options.allow-empty-message"))
2435                opts->allow_empty_message =
2436                        git_config_bool_or_int(key, value, &error_flag);
2437        else if (!strcmp(key, "options.keep-redundant-commits"))
2438                opts->keep_redundant_commits =
2439                        git_config_bool_or_int(key, value, &error_flag);
2440        else if (!strcmp(key, "options.signoff"))
2441                opts->signoff = git_config_bool_or_int(key, value, &error_flag);
2442        else if (!strcmp(key, "options.record-origin"))
2443                opts->record_origin = git_config_bool_or_int(key, value, &error_flag);
2444        else if (!strcmp(key, "options.allow-ff"))
2445                opts->allow_ff = git_config_bool_or_int(key, value, &error_flag);
2446        else if (!strcmp(key, "options.mainline"))
2447                opts->mainline = git_config_int(key, value);
2448        else if (!strcmp(key, "options.strategy"))
2449                git_config_string_dup(&opts->strategy, key, value);
2450        else if (!strcmp(key, "options.gpg-sign"))
2451                git_config_string_dup(&opts->gpg_sign, key, value);
2452        else if (!strcmp(key, "options.strategy-option")) {
2453                ALLOC_GROW(opts->xopts, opts->xopts_nr + 1, opts->xopts_alloc);
2454                opts->xopts[opts->xopts_nr++] = xstrdup(value);
2455        } else if (!strcmp(key, "options.allow-rerere-auto"))
2456                opts->allow_rerere_auto =
2457                        git_config_bool_or_int(key, value, &error_flag) ?
2458                                RERERE_AUTOUPDATE : RERERE_NOAUTOUPDATE;
2459        else if (!strcmp(key, "options.default-msg-cleanup")) {
2460                opts->explicit_cleanup = 1;
2461                opts->default_msg_cleanup = get_cleanup_mode(value, 1);
2462        } else
2463                return error(_("invalid key: %s"), key);
2464
2465        if (!error_flag)
2466                return error(_("invalid value for %s: %s"), key, value);
2467
2468        return 0;
2469}
2470
2471void parse_strategy_opts(struct replay_opts *opts, char *raw_opts)
2472{
2473        int i;
2474        char *strategy_opts_string = raw_opts;
2475
2476        if (*strategy_opts_string == ' ')
2477                strategy_opts_string++;
2478
2479        opts->xopts_nr = split_cmdline(strategy_opts_string,
2480                                       (const char ***)&opts->xopts);
2481        for (i = 0; i < opts->xopts_nr; i++) {
2482                const char *arg = opts->xopts[i];
2483
2484                skip_prefix(arg, "--", &arg);
2485                opts->xopts[i] = xstrdup(arg);
2486        }
2487}
2488
2489static void read_strategy_opts(struct replay_opts *opts, struct strbuf *buf)
2490{
2491        strbuf_reset(buf);
2492        if (!read_oneliner(buf, rebase_path_strategy(), 0))
2493                return;
2494        opts->strategy = strbuf_detach(buf, NULL);
2495        if (!read_oneliner(buf, rebase_path_strategy_opts(), 0))
2496                return;
2497
2498        parse_strategy_opts(opts, buf->buf);
2499}
2500
2501static int read_populate_opts(struct replay_opts *opts)
2502{
2503        if (is_rebase_i(opts)) {
2504                struct strbuf buf = STRBUF_INIT;
2505
2506                if (read_oneliner(&buf, rebase_path_gpg_sign_opt(), 1)) {
2507                        if (!starts_with(buf.buf, "-S"))
2508                                strbuf_reset(&buf);
2509                        else {
2510                                free(opts->gpg_sign);
2511                                opts->gpg_sign = xstrdup(buf.buf + 2);
2512                        }
2513                        strbuf_reset(&buf);
2514                }
2515
2516                if (read_oneliner(&buf, rebase_path_allow_rerere_autoupdate(), 1)) {
2517                        if (!strcmp(buf.buf, "--rerere-autoupdate"))
2518                                opts->allow_rerere_auto = RERERE_AUTOUPDATE;
2519                        else if (!strcmp(buf.buf, "--no-rerere-autoupdate"))
2520                                opts->allow_rerere_auto = RERERE_NOAUTOUPDATE;
2521                        strbuf_reset(&buf);
2522                }
2523
2524                if (file_exists(rebase_path_verbose()))
2525                        opts->verbose = 1;
2526
2527                if (file_exists(rebase_path_quiet()))
2528                        opts->quiet = 1;
2529
2530                if (file_exists(rebase_path_signoff())) {
2531                        opts->allow_ff = 0;
2532                        opts->signoff = 1;
2533                }
2534
2535                if (file_exists(rebase_path_reschedule_failed_exec()))
2536                        opts->reschedule_failed_exec = 1;
2537
2538                read_strategy_opts(opts, &buf);
2539                strbuf_release(&buf);
2540
2541                if (read_oneliner(&opts->current_fixups,
2542                                  rebase_path_current_fixups(), 1)) {
2543                        const char *p = opts->current_fixups.buf;
2544                        opts->current_fixup_count = 1;
2545                        while ((p = strchr(p, '\n'))) {
2546                                opts->current_fixup_count++;
2547                                p++;
2548                        }
2549                }
2550
2551                if (read_oneliner(&buf, rebase_path_squash_onto(), 0)) {
2552                        if (get_oid_hex(buf.buf, &opts->squash_onto) < 0)
2553                                return error(_("unusable squash-onto"));
2554                        opts->have_squash_onto = 1;
2555                }
2556
2557                return 0;
2558        }
2559
2560        if (!file_exists(git_path_opts_file()))
2561                return 0;
2562        /*
2563         * The function git_parse_source(), called from git_config_from_file(),
2564         * may die() in case of a syntactically incorrect file. We do not care
2565         * about this case, though, because we wrote that file ourselves, so we
2566         * are pretty certain that it is syntactically correct.
2567         */
2568        if (git_config_from_file(populate_opts_cb, git_path_opts_file(), opts) < 0)
2569                return error(_("malformed options sheet: '%s'"),
2570                        git_path_opts_file());
2571        return 0;
2572}
2573
2574static void write_strategy_opts(struct replay_opts *opts)
2575{
2576        int i;
2577        struct strbuf buf = STRBUF_INIT;
2578
2579        for (i = 0; i < opts->xopts_nr; ++i)
2580                strbuf_addf(&buf, " --%s", opts->xopts[i]);
2581
2582        write_file(rebase_path_strategy_opts(), "%s\n", buf.buf);
2583        strbuf_release(&buf);
2584}
2585
2586int write_basic_state(struct replay_opts *opts, const char *head_name,
2587                      struct commit *onto, const char *orig_head)
2588{
2589        const char *quiet = getenv("GIT_QUIET");
2590
2591        if (head_name)
2592                write_file(rebase_path_head_name(), "%s\n", head_name);
2593        if (onto)
2594                write_file(rebase_path_onto(), "%s\n",
2595                           oid_to_hex(&onto->object.oid));
2596        if (orig_head)
2597                write_file(rebase_path_orig_head(), "%s\n", orig_head);
2598
2599        if (quiet)
2600                write_file(rebase_path_quiet(), "%s\n", quiet);
2601        if (opts->verbose)
2602                write_file(rebase_path_verbose(), "%s", "");
2603        if (opts->strategy)
2604                write_file(rebase_path_strategy(), "%s\n", opts->strategy);
2605        if (opts->xopts_nr > 0)
2606                write_strategy_opts(opts);
2607
2608        if (opts->allow_rerere_auto == RERERE_AUTOUPDATE)
2609                write_file(rebase_path_allow_rerere_autoupdate(), "--rerere-autoupdate\n");
2610        else if (opts->allow_rerere_auto == RERERE_NOAUTOUPDATE)
2611                write_file(rebase_path_allow_rerere_autoupdate(), "--no-rerere-autoupdate\n");
2612
2613        if (opts->gpg_sign)
2614                write_file(rebase_path_gpg_sign_opt(), "-S%s\n", opts->gpg_sign);
2615        if (opts->signoff)
2616                write_file(rebase_path_signoff(), "--signoff\n");
2617        if (opts->reschedule_failed_exec)
2618                write_file(rebase_path_reschedule_failed_exec(), "%s", "");
2619
2620        return 0;
2621}
2622
2623static int walk_revs_populate_todo(struct todo_list *todo_list,
2624                                struct replay_opts *opts)
2625{
2626        enum todo_command command = opts->action == REPLAY_PICK ?
2627                TODO_PICK : TODO_REVERT;
2628        const char *command_string = todo_command_info[command].str;
2629        struct commit *commit;
2630
2631        if (prepare_revs(opts))
2632                return -1;
2633
2634        while ((commit = get_revision(opts->revs))) {
2635                struct todo_item *item = append_new_todo(todo_list);
2636                const char *commit_buffer = get_commit_buffer(commit, NULL);
2637                const char *subject;
2638                int subject_len;
2639
2640                item->command = command;
2641                item->commit = commit;
2642                item->arg_offset = 0;
2643                item->arg_len = 0;
2644                item->offset_in_buf = todo_list->buf.len;
2645                subject_len = find_commit_subject(commit_buffer, &subject);
2646                strbuf_addf(&todo_list->buf, "%s %s %.*s\n", command_string,
2647                        short_commit_name(commit), subject_len, subject);
2648                unuse_commit_buffer(commit, commit_buffer);
2649        }
2650
2651        if (!todo_list->nr)
2652                return error(_("empty commit set passed"));
2653
2654        return 0;
2655}
2656
2657static int create_seq_dir(struct repository *r)
2658{
2659        enum replay_action action;
2660        const char *in_progress_error = NULL;
2661        const char *in_progress_advice = NULL;
2662        unsigned int advise_skip = file_exists(git_path_revert_head(r)) ||
2663                                file_exists(git_path_cherry_pick_head(r));
2664
2665        if (!sequencer_get_last_command(r, &action)) {
2666                switch (action) {
2667                case REPLAY_REVERT:
2668                        in_progress_error = _("revert is already in progress");
2669                        in_progress_advice =
2670                        _("try \"git revert (--continue | %s--abort | --quit)\"");
2671                        break;
2672                case REPLAY_PICK:
2673                        in_progress_error = _("cherry-pick is already in progress");
2674                        in_progress_advice =
2675                        _("try \"git cherry-pick (--continue | %s--abort | --quit)\"");
2676                        break;
2677                default:
2678                        BUG("unexpected action in create_seq_dir");
2679                }
2680        }
2681        if (in_progress_error) {
2682                error("%s", in_progress_error);
2683                if (advice_sequencer_in_use)
2684                        advise(in_progress_advice,
2685                                advise_skip ? "--skip | " : "");
2686                return -1;
2687        }
2688        if (mkdir(git_path_seq_dir(), 0777) < 0)
2689                return error_errno(_("could not create sequencer directory '%s'"),
2690                                   git_path_seq_dir());
2691
2692        return 0;
2693}
2694
2695static int save_head(const char *head)
2696{
2697        struct lock_file head_lock = LOCK_INIT;
2698        struct strbuf buf = STRBUF_INIT;
2699        int fd;
2700        ssize_t written;
2701
2702        fd = hold_lock_file_for_update(&head_lock, git_path_head_file(), 0);
2703        if (fd < 0)
2704                return error_errno(_("could not lock HEAD"));
2705        strbuf_addf(&buf, "%s\n", head);
2706        written = write_in_full(fd, buf.buf, buf.len);
2707        strbuf_release(&buf);
2708        if (written < 0) {
2709                error_errno(_("could not write to '%s'"), git_path_head_file());
2710                rollback_lock_file(&head_lock);
2711                return -1;
2712        }
2713        if (commit_lock_file(&head_lock) < 0)
2714                return error(_("failed to finalize '%s'"), git_path_head_file());
2715        return 0;
2716}
2717
2718static int rollback_is_safe(void)
2719{
2720        struct strbuf sb = STRBUF_INIT;
2721        struct object_id expected_head, actual_head;
2722
2723        if (strbuf_read_file(&sb, git_path_abort_safety_file(), 0) >= 0) {
2724                strbuf_trim(&sb);
2725                if (get_oid_hex(sb.buf, &expected_head)) {
2726                        strbuf_release(&sb);
2727                        die(_("could not parse %s"), git_path_abort_safety_file());
2728                }
2729                strbuf_release(&sb);
2730        }
2731        else if (errno == ENOENT)
2732                oidclr(&expected_head);
2733        else
2734                die_errno(_("could not read '%s'"), git_path_abort_safety_file());
2735
2736        if (get_oid("HEAD", &actual_head))
2737                oidclr(&actual_head);
2738
2739        return oideq(&actual_head, &expected_head);
2740}
2741
2742static int reset_merge(const struct object_id *oid)
2743{
2744        int ret;
2745        struct argv_array argv = ARGV_ARRAY_INIT;
2746
2747        argv_array_pushl(&argv, "reset", "--merge", NULL);
2748
2749        if (!is_null_oid(oid))
2750                argv_array_push(&argv, oid_to_hex(oid));
2751
2752        ret = run_command_v_opt(argv.argv, RUN_GIT_CMD);
2753        argv_array_clear(&argv);
2754
2755        return ret;
2756}
2757
2758static int rollback_single_pick(struct repository *r)
2759{
2760        struct object_id head_oid;
2761
2762        if (!file_exists(git_path_cherry_pick_head(r)) &&
2763            !file_exists(git_path_revert_head(r)))
2764                return error(_("no cherry-pick or revert in progress"));
2765        if (read_ref_full("HEAD", 0, &head_oid, NULL))
2766                return error(_("cannot resolve HEAD"));
2767        if (is_null_oid(&head_oid))
2768                return error(_("cannot abort from a branch yet to be born"));
2769        return reset_merge(&head_oid);
2770}
2771
2772static int skip_single_pick(void)
2773{
2774        struct object_id head;
2775
2776        if (read_ref_full("HEAD", 0, &head, NULL))
2777                return error(_("cannot resolve HEAD"));
2778        return reset_merge(&head);
2779}
2780
2781int sequencer_rollback(struct repository *r, struct replay_opts *opts)
2782{
2783        FILE *f;
2784        struct object_id oid;
2785        struct strbuf buf = STRBUF_INIT;
2786        const char *p;
2787
2788        f = fopen(git_path_head_file(), "r");
2789        if (!f && errno == ENOENT) {
2790                /*
2791                 * There is no multiple-cherry-pick in progress.
2792                 * If CHERRY_PICK_HEAD or REVERT_HEAD indicates
2793                 * a single-cherry-pick in progress, abort that.
2794                 */
2795                return rollback_single_pick(r);
2796        }
2797        if (!f)
2798                return error_errno(_("cannot open '%s'"), git_path_head_file());
2799        if (strbuf_getline_lf(&buf, f)) {
2800                error(_("cannot read '%s': %s"), git_path_head_file(),
2801                      ferror(f) ?  strerror(errno) : _("unexpected end of file"));
2802                fclose(f);
2803                goto fail;
2804        }
2805        fclose(f);
2806        if (parse_oid_hex(buf.buf, &oid, &p) || *p != '\0') {
2807                error(_("stored pre-cherry-pick HEAD file '%s' is corrupt"),
2808                        git_path_head_file());
2809                goto fail;
2810        }
2811        if (is_null_oid(&oid)) {
2812                error(_("cannot abort from a branch yet to be born"));
2813                goto fail;
2814        }
2815
2816        if (!rollback_is_safe()) {
2817                /* Do not error, just do not rollback */
2818                warning(_("You seem to have moved HEAD. "
2819                          "Not rewinding, check your HEAD!"));
2820        } else
2821        if (reset_merge(&oid))
2822                goto fail;
2823        strbuf_release(&buf);
2824        return sequencer_remove_state(opts);
2825fail:
2826        strbuf_release(&buf);
2827        return -1;
2828}
2829
2830int sequencer_skip(struct repository *r, struct replay_opts *opts)
2831{
2832        enum replay_action action = -1;
2833        sequencer_get_last_command(r, &action);
2834
2835        /*
2836         * Check whether the subcommand requested to skip the commit is actually
2837         * in progress and that it's safe to skip the commit.
2838         *
2839         * opts->action tells us which subcommand requested to skip the commit.
2840         * If the corresponding .git/<ACTION>_HEAD exists, we know that the
2841         * action is in progress and we can skip the commit.
2842         *
2843         * Otherwise we check that the last instruction was related to the
2844         * particular subcommand we're trying to execute and barf if that's not
2845         * the case.
2846         *
2847         * Finally we check that the rollback is "safe", i.e., has the HEAD
2848         * moved? In this case, it doesn't make sense to "reset the merge" and
2849         * "skip the commit" as the user already handled this by committing. But
2850         * we'd not want to barf here, instead give advice on how to proceed. We
2851         * only need to check that when .git/<ACTION>_HEAD doesn't exist because
2852         * it gets removed when the user commits, so if it still exists we're
2853         * sure the user can't have committed before.
2854         */
2855        switch (opts->action) {
2856        case REPLAY_REVERT:
2857                if (!file_exists(git_path_revert_head(r))) {
2858                        if (action != REPLAY_REVERT)
2859                                return error(_("no revert in progress"));
2860                        if (!rollback_is_safe())
2861                                goto give_advice;
2862                }
2863                break;
2864        case REPLAY_PICK:
2865                if (!file_exists(git_path_cherry_pick_head(r))) {
2866                        if (action != REPLAY_PICK)
2867                                return error(_("no cherry-pick in progress"));
2868                        if (!rollback_is_safe())
2869                                goto give_advice;
2870                }
2871                break;
2872        default:
2873                BUG("unexpected action in sequencer_skip");
2874        }
2875
2876        if (skip_single_pick())
2877                return error(_("failed to skip the commit"));
2878        if (!is_directory(git_path_seq_dir()))
2879                return 0;
2880
2881        return sequencer_continue(r, opts);
2882
2883give_advice:
2884        error(_("there is nothing to skip"));
2885
2886        if (advice_resolve_conflict) {
2887                advise(_("have you committed already?\n"
2888                         "try \"git %s --continue\""),
2889                         action == REPLAY_REVERT ? "revert" : "cherry-pick");
2890        }
2891        return -1;
2892}
2893
2894static int save_todo(struct todo_list *todo_list, struct replay_opts *opts)
2895{
2896        struct lock_file todo_lock = LOCK_INIT;
2897        const char *todo_path = get_todo_path(opts);
2898        int next = todo_list->current, offset, fd;
2899
2900        /*
2901         * rebase -i writes "git-rebase-todo" without the currently executing
2902         * command, appending it to "done" instead.
2903         */
2904        if (is_rebase_i(opts))
2905                next++;
2906
2907        fd = hold_lock_file_for_update(&todo_lock, todo_path, 0);
2908        if (fd < 0)
2909                return error_errno(_("could not lock '%s'"), todo_path);
2910        offset = get_item_line_offset(todo_list, next);
2911        if (write_in_full(fd, todo_list->buf.buf + offset,
2912                        todo_list->buf.len - offset) < 0)
2913                return error_errno(_("could not write to '%s'"), todo_path);
2914        if (commit_lock_file(&todo_lock) < 0)
2915                return error(_("failed to finalize '%s'"), todo_path);
2916
2917        if (is_rebase_i(opts) && next > 0) {
2918                const char *done = rebase_path_done();
2919                int fd = open(done, O_CREAT | O_WRONLY | O_APPEND, 0666);
2920                int ret = 0;
2921
2922                if (fd < 0)
2923                        return 0;
2924                if (write_in_full(fd, get_item_line(todo_list, next - 1),
2925                                  get_item_line_length(todo_list, next - 1))
2926                    < 0)
2927                        ret = error_errno(_("could not write to '%s'"), done);
2928                if (close(fd) < 0)
2929                        ret = error_errno(_("failed to finalize '%s'"), done);
2930                return ret;
2931        }
2932        return 0;
2933}
2934
2935static int save_opts(struct replay_opts *opts)
2936{
2937        const char *opts_file = git_path_opts_file();
2938        int res = 0;
2939
2940        if (opts->no_commit)
2941                res |= git_config_set_in_file_gently(opts_file,
2942                                        "options.no-commit", "true");
2943        if (opts->edit)
2944                res |= git_config_set_in_file_gently(opts_file,
2945                                        "options.edit", "true");
2946        if (opts->allow_empty)
2947                res |= git_config_set_in_file_gently(opts_file,
2948                                        "options.allow-empty", "true");
2949        if (opts->allow_empty_message)
2950                res |= git_config_set_in_file_gently(opts_file,
2951                                "options.allow-empty-message", "true");
2952        if (opts->keep_redundant_commits)
2953                res |= git_config_set_in_file_gently(opts_file,
2954                                "options.keep-redundant-commits", "true");
2955        if (opts->signoff)
2956                res |= git_config_set_in_file_gently(opts_file,
2957                                        "options.signoff", "true");
2958        if (opts->record_origin)
2959                res |= git_config_set_in_file_gently(opts_file,
2960                                        "options.record-origin", "true");
2961        if (opts->allow_ff)
2962                res |= git_config_set_in_file_gently(opts_file,
2963                                        "options.allow-ff", "true");
2964        if (opts->mainline) {
2965                struct strbuf buf = STRBUF_INIT;
2966                strbuf_addf(&buf, "%d", opts->mainline);
2967                res |= git_config_set_in_file_gently(opts_file,
2968                                        "options.mainline", buf.buf);
2969                strbuf_release(&buf);
2970        }
2971        if (opts->strategy)
2972                res |= git_config_set_in_file_gently(opts_file,
2973                                        "options.strategy", opts->strategy);
2974        if (opts->gpg_sign)
2975                res |= git_config_set_in_file_gently(opts_file,
2976                                        "options.gpg-sign", opts->gpg_sign);
2977        if (opts->xopts) {
2978                int i;
2979                for (i = 0; i < opts->xopts_nr; i++)
2980                        res |= git_config_set_multivar_in_file_gently(opts_file,
2981                                        "options.strategy-option",
2982                                        opts->xopts[i], "^$", 0);
2983        }
2984        if (opts->allow_rerere_auto)
2985                res |= git_config_set_in_file_gently(opts_file,
2986                                "options.allow-rerere-auto",
2987                                opts->allow_rerere_auto == RERERE_AUTOUPDATE ?
2988                                "true" : "false");
2989
2990        if (opts->explicit_cleanup)
2991                res |= git_config_set_in_file_gently(opts_file,
2992                                "options.default-msg-cleanup",
2993                                describe_cleanup_mode(opts->default_msg_cleanup));
2994        return res;
2995}
2996
2997static int make_patch(struct repository *r,
2998                      struct commit *commit,
2999                      struct replay_opts *opts)
3000{
3001        struct strbuf buf = STRBUF_INIT;
3002        struct rev_info log_tree_opt;
3003        const char *subject, *p;
3004        int res = 0;
3005
3006        p = short_commit_name(commit);
3007        if (write_message(p, strlen(p), rebase_path_stopped_sha(), 1) < 0)
3008                return -1;
3009        if (update_ref("rebase", "REBASE_HEAD", &commit->object.oid,
3010                       NULL, REF_NO_DEREF, UPDATE_REFS_MSG_ON_ERR))
3011                res |= error(_("could not update %s"), "REBASE_HEAD");
3012
3013        strbuf_addf(&buf, "%s/patch", get_dir(opts));
3014        memset(&log_tree_opt, 0, sizeof(log_tree_opt));
3015        repo_init_revisions(r, &log_tree_opt, NULL);
3016        log_tree_opt.abbrev = 0;
3017        log_tree_opt.diff = 1;
3018        log_tree_opt.diffopt.output_format = DIFF_FORMAT_PATCH;
3019        log_tree_opt.disable_stdin = 1;
3020        log_tree_opt.no_commit_id = 1;
3021        log_tree_opt.diffopt.file = fopen(buf.buf, "w");
3022        log_tree_opt.diffopt.use_color = GIT_COLOR_NEVER;
3023        if (!log_tree_opt.diffopt.file)
3024                res |= error_errno(_("could not open '%s'"), buf.buf);
3025        else {
3026                res |= log_tree_commit(&log_tree_opt, commit);
3027                fclose(log_tree_opt.diffopt.file);
3028        }
3029        strbuf_reset(&buf);
3030
3031        strbuf_addf(&buf, "%s/message", get_dir(opts));
3032        if (!file_exists(buf.buf)) {
3033                const char *commit_buffer = get_commit_buffer(commit, NULL);
3034                find_commit_subject(commit_buffer, &subject);
3035                res |= write_message(subject, strlen(subject), buf.buf, 1);
3036                unuse_commit_buffer(commit, commit_buffer);
3037        }
3038        strbuf_release(&buf);
3039
3040        return res;
3041}
3042
3043static int intend_to_amend(void)
3044{
3045        struct object_id head;
3046        char *p;
3047
3048        if (get_oid("HEAD", &head))
3049                return error(_("cannot read HEAD"));
3050
3051        p = oid_to_hex(&head);
3052        return write_message(p, strlen(p), rebase_path_amend(), 1);
3053}
3054
3055static int error_with_patch(struct repository *r,
3056                            struct commit *commit,
3057                            const char *subject, int subject_len,
3058                            struct replay_opts *opts,
3059                            int exit_code, int to_amend)
3060{
3061        if (commit) {
3062                if (make_patch(r, commit, opts))
3063                        return -1;
3064        } else if (copy_file(rebase_path_message(),
3065                             git_path_merge_msg(r), 0666))
3066                return error(_("unable to copy '%s' to '%s'"),
3067                             git_path_merge_msg(r), rebase_path_message());
3068
3069        if (to_amend) {
3070                if (intend_to_amend())
3071                        return -1;
3072
3073                fprintf(stderr,
3074                        _("You can amend the commit now, with\n"
3075                          "\n"
3076                          "  git commit --amend %s\n"
3077                          "\n"
3078                          "Once you are satisfied with your changes, run\n"
3079                          "\n"
3080                          "  git rebase --continue\n"),
3081                        gpg_sign_opt_quoted(opts));
3082        } else if (exit_code) {
3083                if (commit)
3084                        fprintf_ln(stderr, _("Could not apply %s... %.*s"),
3085                                   short_commit_name(commit), subject_len, subject);
3086                else
3087                        /*
3088                         * We don't have the hash of the parent so
3089                         * just print the line from the todo file.
3090                         */
3091                        fprintf_ln(stderr, _("Could not merge %.*s"),
3092                                   subject_len, subject);
3093        }
3094
3095        return exit_code;
3096}
3097
3098static int error_failed_squash(struct repository *r,
3099                               struct commit *commit,
3100                               struct replay_opts *opts,
3101                               int subject_len,
3102                               const char *subject)
3103{
3104        if (copy_file(rebase_path_message(), rebase_path_squash_msg(), 0666))
3105                return error(_("could not copy '%s' to '%s'"),
3106                        rebase_path_squash_msg(), rebase_path_message());
3107        unlink(git_path_merge_msg(r));
3108        if (copy_file(git_path_merge_msg(r), rebase_path_message(), 0666))
3109                return error(_("could not copy '%s' to '%s'"),
3110                             rebase_path_message(),
3111                             git_path_merge_msg(r));
3112        return error_with_patch(r, commit, subject, subject_len, opts, 1, 0);
3113}
3114
3115static int do_exec(struct repository *r, const char *command_line)
3116{
3117        struct argv_array child_env = ARGV_ARRAY_INIT;
3118        const char *child_argv[] = { NULL, NULL };
3119        int dirty, status;
3120
3121        fprintf(stderr, "Executing: %s\n", command_line);
3122        child_argv[0] = command_line;
3123        argv_array_pushf(&child_env, "GIT_DIR=%s", absolute_path(get_git_dir()));
3124        argv_array_pushf(&child_env, "GIT_WORK_TREE=%s",
3125                         absolute_path(get_git_work_tree()));
3126        status = run_command_v_opt_cd_env(child_argv, RUN_USING_SHELL, NULL,
3127                                          child_env.argv);
3128
3129        /* force re-reading of the cache */
3130        if (discard_index(r->index) < 0 || repo_read_index(r) < 0)
3131                return error(_("could not read index"));
3132
3133        dirty = require_clean_work_tree(r, "rebase", NULL, 1, 1);
3134
3135        if (status) {
3136                warning(_("execution failed: %s\n%s"
3137                          "You can fix the problem, and then run\n"
3138                          "\n"
3139                          "  git rebase --continue\n"
3140                          "\n"),
3141                        command_line,
3142                        dirty ? N_("and made changes to the index and/or the "
3143                                "working tree\n") : "");
3144                if (status == 127)
3145                        /* command not found */
3146                        status = 1;
3147        } else if (dirty) {
3148                warning(_("execution succeeded: %s\nbut "
3149                          "left changes to the index and/or the working tree\n"
3150                          "Commit or stash your changes, and then run\n"
3151                          "\n"
3152                          "  git rebase --continue\n"
3153                          "\n"), command_line);
3154                status = 1;
3155        }
3156
3157        argv_array_clear(&child_env);
3158
3159        return status;
3160}
3161
3162static int safe_append(const char *filename, const char *fmt, ...)
3163{
3164        va_list ap;
3165        struct lock_file lock = LOCK_INIT;
3166        int fd = hold_lock_file_for_update(&lock, filename,
3167                                           LOCK_REPORT_ON_ERROR);
3168        struct strbuf buf = STRBUF_INIT;
3169
3170        if (fd < 0)
3171                return -1;
3172
3173        if (strbuf_read_file(&buf, filename, 0) < 0 && errno != ENOENT) {
3174                error_errno(_("could not read '%s'"), filename);
3175                rollback_lock_file(&lock);
3176                return -1;
3177        }
3178        strbuf_complete(&buf, '\n');
3179        va_start(ap, fmt);
3180        strbuf_vaddf(&buf, fmt, ap);
3181        va_end(ap);
3182
3183        if (write_in_full(fd, buf.buf, buf.len) < 0) {
3184                error_errno(_("could not write to '%s'"), filename);
3185                strbuf_release(&buf);
3186                rollback_lock_file(&lock);
3187                return -1;
3188        }
3189        if (commit_lock_file(&lock) < 0) {
3190                strbuf_release(&buf);
3191                rollback_lock_file(&lock);
3192                return error(_("failed to finalize '%s'"), filename);
3193        }
3194
3195        strbuf_release(&buf);
3196        return 0;
3197}
3198
3199static int do_label(struct repository *r, const char *name, int len)
3200{
3201        struct ref_store *refs = get_main_ref_store(r);
3202        struct ref_transaction *transaction;
3203        struct strbuf ref_name = STRBUF_INIT, err = STRBUF_INIT;
3204        struct strbuf msg = STRBUF_INIT;
3205        int ret = 0;
3206        struct object_id head_oid;
3207
3208        if (len == 1 && *name == '#')
3209                return error(_("illegal label name: '%.*s'"), len, name);
3210
3211        strbuf_addf(&ref_name, "refs/rewritten/%.*s", len, name);
3212        strbuf_addf(&msg, "rebase -i (label) '%.*s'", len, name);
3213
3214        transaction = ref_store_transaction_begin(refs, &err);
3215        if (!transaction) {
3216                error("%s", err.buf);
3217                ret = -1;
3218        } else if (get_oid("HEAD", &head_oid)) {
3219                error(_("could not read HEAD"));
3220                ret = -1;
3221        } else if (ref_transaction_update(transaction, ref_name.buf, &head_oid,
3222                                          NULL, 0, msg.buf, &err) < 0 ||
3223                   ref_transaction_commit(transaction, &err)) {
3224                error("%s", err.buf);
3225                ret = -1;
3226        }
3227        ref_transaction_free(transaction);
3228        strbuf_release(&err);
3229        strbuf_release(&msg);
3230
3231        if (!ret)
3232                ret = safe_append(rebase_path_refs_to_delete(),
3233                                  "%s\n", ref_name.buf);
3234        strbuf_release(&ref_name);
3235
3236        return ret;
3237}
3238
3239static const char *reflog_message(struct replay_opts *opts,
3240        const char *sub_action, const char *fmt, ...);
3241
3242static int do_reset(struct repository *r,
3243                    const char *name, int len,
3244                    struct replay_opts *opts)
3245{
3246        struct strbuf ref_name = STRBUF_INIT;
3247        struct object_id oid;
3248        struct lock_file lock = LOCK_INIT;
3249        struct tree_desc desc;
3250        struct tree *tree;
3251        struct unpack_trees_options unpack_tree_opts;
3252        int ret = 0;
3253
3254        if (repo_hold_locked_index(r, &lock, LOCK_REPORT_ON_ERROR) < 0)
3255                return -1;
3256
3257        if (len == 10 && !strncmp("[new root]", name, len)) {
3258                if (!opts->have_squash_onto) {
3259                        const char *hex;
3260                        if (commit_tree("", 0, the_hash_algo->empty_tree,
3261                                        NULL, &opts->squash_onto,
3262                                        NULL, NULL))
3263                                return error(_("writing fake root commit"));
3264                        opts->have_squash_onto = 1;
3265                        hex = oid_to_hex(&opts->squash_onto);
3266                        if (write_message(hex, strlen(hex),
3267                                          rebase_path_squash_onto(), 0))
3268                                return error(_("writing squash-onto"));
3269                }
3270                oidcpy(&oid, &opts->squash_onto);
3271        } else {
3272                int i;
3273
3274                /* Determine the length of the label */
3275                for (i = 0; i < len; i++)
3276                        if (isspace(name[i]))
3277                                break;
3278                len = i;
3279
3280                strbuf_addf(&ref_name, "refs/rewritten/%.*s", len, name);
3281                if (get_oid(ref_name.buf, &oid) &&
3282                    get_oid(ref_name.buf + strlen("refs/rewritten/"), &oid)) {
3283                        error(_("could not read '%s'"), ref_name.buf);
3284                        rollback_lock_file(&lock);
3285                        strbuf_release(&ref_name);
3286                        return -1;
3287                }
3288        }
3289
3290        memset(&unpack_tree_opts, 0, sizeof(unpack_tree_opts));
3291        setup_unpack_trees_porcelain(&unpack_tree_opts, "reset");
3292        unpack_tree_opts.head_idx = 1;
3293        unpack_tree_opts.src_index = r->index;
3294        unpack_tree_opts.dst_index = r->index;
3295        unpack_tree_opts.fn = oneway_merge;
3296        unpack_tree_opts.merge = 1;
3297        unpack_tree_opts.update = 1;
3298
3299        if (repo_read_index_unmerged(r)) {
3300                rollback_lock_file(&lock);
3301                strbuf_release(&ref_name);
3302                return error_resolve_conflict(_(action_name(opts)));
3303        }
3304
3305        if (!fill_tree_descriptor(r, &desc, &oid)) {
3306                error(_("failed to find tree of %s"), oid_to_hex(&oid));
3307                rollback_lock_file(&lock);
3308                free((void *)desc.buffer);
3309                strbuf_release(&ref_name);
3310                return -1;
3311        }
3312
3313        if (unpack_trees(1, &desc, &unpack_tree_opts)) {
3314                rollback_lock_file(&lock);
3315                free((void *)desc.buffer);
3316                strbuf_release(&ref_name);
3317                return -1;
3318        }
3319
3320        tree = parse_tree_indirect(&oid);
3321        prime_cache_tree(r, r->index, tree);
3322
3323        if (write_locked_index(r->index, &lock, COMMIT_LOCK) < 0)
3324                ret = error(_("could not write index"));
3325        free((void *)desc.buffer);
3326
3327        if (!ret)
3328                ret = update_ref(reflog_message(opts, "reset", "'%.*s'",
3329                                                len, name), "HEAD", &oid,
3330                                 NULL, 0, UPDATE_REFS_MSG_ON_ERR);
3331
3332        strbuf_release(&ref_name);
3333        return ret;
3334}
3335
3336static struct commit *lookup_label(const char *label, int len,
3337                                   struct strbuf *buf)
3338{
3339        struct commit *commit;
3340
3341        strbuf_reset(buf);
3342        strbuf_addf(buf, "refs/rewritten/%.*s", len, label);
3343        commit = lookup_commit_reference_by_name(buf->buf);
3344        if (!commit) {
3345                /* fall back to non-rewritten ref or commit */
3346                strbuf_splice(buf, 0, strlen("refs/rewritten/"), "", 0);
3347                commit = lookup_commit_reference_by_name(buf->buf);
3348        }
3349
3350        if (!commit)
3351                error(_("could not resolve '%s'"), buf->buf);
3352
3353        return commit;
3354}
3355
3356static int do_merge(struct repository *r,
3357                    struct commit *commit,
3358                    const char *arg, int arg_len,
3359                    int flags, struct replay_opts *opts)
3360{
3361        int run_commit_flags = (flags & TODO_EDIT_MERGE_MSG) ?
3362                EDIT_MSG | VERIFY_MSG : 0;
3363        struct strbuf ref_name = STRBUF_INIT;
3364        struct commit *head_commit, *merge_commit, *i;
3365        struct commit_list *bases, *j, *reversed = NULL;
3366        struct commit_list *to_merge = NULL, **tail = &to_merge;
3367        const char *strategy = !opts->xopts_nr &&
3368                (!opts->strategy || !strcmp(opts->strategy, "recursive")) ?
3369                NULL : opts->strategy;
3370        struct merge_options o;
3371        int merge_arg_len, oneline_offset, can_fast_forward, ret, k;
3372        static struct lock_file lock;
3373        const char *p;
3374
3375        if (repo_hold_locked_index(r, &lock, LOCK_REPORT_ON_ERROR) < 0) {
3376                ret = -1;
3377                goto leave_merge;
3378        }
3379
3380        head_commit = lookup_commit_reference_by_name("HEAD");
3381        if (!head_commit) {
3382                ret = error(_("cannot merge without a current revision"));
3383                goto leave_merge;
3384        }
3385
3386        /*
3387         * For octopus merges, the arg starts with the list of revisions to be
3388         * merged. The list is optionally followed by '#' and the oneline.
3389         */
3390        merge_arg_len = oneline_offset = arg_len;
3391        for (p = arg; p - arg < arg_len; p += strspn(p, " \t\n")) {
3392                if (!*p)
3393                        break;
3394                if (*p == '#' && (!p[1] || isspace(p[1]))) {
3395                        p += 1 + strspn(p + 1, " \t\n");
3396                        oneline_offset = p - arg;
3397                        break;
3398                }
3399                k = strcspn(p, " \t\n");
3400                if (!k)
3401                        continue;
3402                merge_commit = lookup_label(p, k, &ref_name);
3403                if (!merge_commit) {
3404                        ret = error(_("unable to parse '%.*s'"), k, p);
3405                        goto leave_merge;
3406                }
3407                tail = &commit_list_insert(merge_commit, tail)->next;
3408                p += k;
3409                merge_arg_len = p - arg;
3410        }
3411
3412        if (!to_merge) {
3413                ret = error(_("nothing to merge: '%.*s'"), arg_len, arg);
3414                goto leave_merge;
3415        }
3416
3417        if (opts->have_squash_onto &&
3418            oideq(&head_commit->object.oid, &opts->squash_onto)) {
3419                /*
3420                 * When the user tells us to "merge" something into a
3421                 * "[new root]", let's simply fast-forward to the merge head.
3422                 */
3423                rollback_lock_file(&lock);
3424                if (to_merge->next)
3425                        ret = error(_("octopus merge cannot be executed on "
3426                                      "top of a [new root]"));
3427                else
3428                        ret = fast_forward_to(r, &to_merge->item->object.oid,
3429                                              &head_commit->object.oid, 0,
3430                                              opts);
3431                goto leave_merge;
3432        }
3433
3434        if (commit) {
3435                const char *message = get_commit_buffer(commit, NULL);
3436                const char *body;
3437                int len;
3438
3439                if (!message) {
3440                        ret = error(_("could not get commit message of '%s'"),
3441                                    oid_to_hex(&commit->object.oid));
3442                        goto leave_merge;
3443                }
3444                write_author_script(message);
3445                find_commit_subject(message, &body);
3446                len = strlen(body);
3447                ret = write_message(body, len, git_path_merge_msg(r), 0);
3448                unuse_commit_buffer(commit, message);
3449                if (ret) {
3450                        error_errno(_("could not write '%s'"),
3451                                    git_path_merge_msg(r));
3452                        goto leave_merge;
3453                }
3454        } else {
3455                struct strbuf buf = STRBUF_INIT;
3456                int len;
3457
3458                strbuf_addf(&buf, "author %s", git_author_info(0));
3459                write_author_script(buf.buf);
3460                strbuf_reset(&buf);
3461
3462                if (oneline_offset < arg_len) {
3463                        p = arg + oneline_offset;
3464                        len = arg_len - oneline_offset;
3465                } else {
3466                        strbuf_addf(&buf, "Merge %s '%.*s'",
3467                                    to_merge->next ? "branches" : "branch",
3468                                    merge_arg_len, arg);
3469                        p = buf.buf;
3470                        len = buf.len;
3471                }
3472
3473                ret = write_message(p, len, git_path_merge_msg(r), 0);
3474                strbuf_release(&buf);
3475                if (ret) {
3476                        error_errno(_("could not write '%s'"),
3477                                    git_path_merge_msg(r));
3478                        goto leave_merge;
3479                }
3480        }
3481
3482        /*
3483         * If HEAD is not identical to the first parent of the original merge
3484         * commit, we cannot fast-forward.
3485         */
3486        can_fast_forward = opts->allow_ff && commit && commit->parents &&
3487                oideq(&commit->parents->item->object.oid,
3488                      &head_commit->object.oid);
3489
3490        /*
3491         * If any merge head is different from the original one, we cannot
3492         * fast-forward.
3493         */
3494        if (can_fast_forward) {
3495                struct commit_list *p = commit->parents->next;
3496
3497                for (j = to_merge; j && p; j = j->next, p = p->next)
3498                        if (!oideq(&j->item->object.oid,
3499                                   &p->item->object.oid)) {
3500                                can_fast_forward = 0;
3501                                break;
3502                        }
3503                /*
3504                 * If the number of merge heads differs from the original merge
3505                 * commit, we cannot fast-forward.
3506                 */
3507                if (j || p)
3508                        can_fast_forward = 0;
3509        }
3510
3511        if (can_fast_forward) {
3512                rollback_lock_file(&lock);
3513                ret = fast_forward_to(r, &commit->object.oid,
3514                                      &head_commit->object.oid, 0, opts);
3515                if (flags & TODO_EDIT_MERGE_MSG) {
3516                        run_commit_flags |= AMEND_MSG;
3517                        goto fast_forward_edit;
3518                }
3519                goto leave_merge;
3520        }
3521
3522        if (strategy || to_merge->next) {
3523                /* Octopus merge */
3524                struct child_process cmd = CHILD_PROCESS_INIT;
3525
3526                if (read_env_script(&cmd.env_array)) {
3527                        const char *gpg_opt = gpg_sign_opt_quoted(opts);
3528
3529                        ret = error(_(staged_changes_advice), gpg_opt, gpg_opt);
3530                        goto leave_merge;
3531                }
3532
3533                cmd.git_cmd = 1;
3534                argv_array_push(&cmd.args, "merge");
3535                argv_array_push(&cmd.args, "-s");
3536                if (!strategy)
3537                        argv_array_push(&cmd.args, "octopus");
3538                else {
3539                        argv_array_push(&cmd.args, strategy);
3540                        for (k = 0; k < opts->xopts_nr; k++)
3541                                argv_array_pushf(&cmd.args,
3542                                                 "-X%s", opts->xopts[k]);
3543                }
3544                argv_array_push(&cmd.args, "--no-edit");
3545                argv_array_push(&cmd.args, "--no-ff");
3546                argv_array_push(&cmd.args, "--no-log");
3547                argv_array_push(&cmd.args, "--no-stat");
3548                argv_array_push(&cmd.args, "-F");
3549                argv_array_push(&cmd.args, git_path_merge_msg(r));
3550                if (opts->gpg_sign)
3551                        argv_array_push(&cmd.args, opts->gpg_sign);
3552
3553                /* Add the tips to be merged */
3554                for (j = to_merge; j; j = j->next)
3555                        argv_array_push(&cmd.args,
3556                                        oid_to_hex(&j->item->object.oid));
3557
3558                strbuf_release(&ref_name);
3559                unlink(git_path_cherry_pick_head(r));
3560                rollback_lock_file(&lock);
3561
3562                rollback_lock_file(&lock);
3563                ret = run_command(&cmd);
3564
3565                /* force re-reading of the cache */
3566                if (!ret && (discard_index(r->index) < 0 ||
3567                             repo_read_index(r) < 0))
3568                        ret = error(_("could not read index"));
3569                goto leave_merge;
3570        }
3571
3572        merge_commit = to_merge->item;
3573        bases = get_merge_bases(head_commit, merge_commit);
3574        if (bases && oideq(&merge_commit->object.oid,
3575                           &bases->item->object.oid)) {
3576                ret = 0;
3577                /* skip merging an ancestor of HEAD */
3578                goto leave_merge;
3579        }
3580
3581        write_message(oid_to_hex(&merge_commit->object.oid), GIT_SHA1_HEXSZ,
3582                      git_path_merge_head(r), 0);
3583        write_message("no-ff", 5, git_path_merge_mode(r), 0);
3584
3585        for (j = bases; j; j = j->next)
3586                commit_list_insert(j->item, &reversed);
3587        free_commit_list(bases);
3588
3589        repo_read_index(r);
3590        init_merge_options(&o, r);
3591        o.branch1 = "HEAD";
3592        o.branch2 = ref_name.buf;
3593        o.buffer_output = 2;
3594
3595        ret = merge_recursive(&o, head_commit, merge_commit, reversed, &i);
3596        if (ret <= 0)
3597                fputs(o.obuf.buf, stdout);
3598        strbuf_release(&o.obuf);
3599        if (ret < 0) {
3600                error(_("could not even attempt to merge '%.*s'"),
3601                      merge_arg_len, arg);
3602                goto leave_merge;
3603        }
3604        /*
3605         * The return value of merge_recursive() is 1 on clean, and 0 on
3606         * unclean merge.
3607         *
3608         * Let's reverse that, so that do_merge() returns 0 upon success and
3609         * 1 upon failed merge (keeping the return value -1 for the cases where
3610         * we will want to reschedule the `merge` command).
3611         */
3612        ret = !ret;
3613
3614        if (r->index->cache_changed &&
3615            write_locked_index(r->index, &lock, COMMIT_LOCK)) {
3616                ret = error(_("merge: Unable to write new index file"));
3617                goto leave_merge;
3618        }
3619
3620        rollback_lock_file(&lock);
3621        if (ret)
3622                repo_rerere(r, opts->allow_rerere_auto);
3623        else
3624                /*
3625                 * In case of problems, we now want to return a positive
3626                 * value (a negative one would indicate that the `merge`
3627                 * command needs to be rescheduled).
3628                 */
3629        fast_forward_edit:
3630                ret = !!run_git_commit(r, git_path_merge_msg(r), opts,
3631                                       run_commit_flags);
3632
3633leave_merge:
3634        strbuf_release(&ref_name);
3635        rollback_lock_file(&lock);
3636        free_commit_list(to_merge);
3637        return ret;
3638}
3639
3640static int is_final_fixup(struct todo_list *todo_list)
3641{
3642        int i = todo_list->current;
3643
3644        if (!is_fixup(todo_list->items[i].command))
3645                return 0;
3646
3647        while (++i < todo_list->nr)
3648                if (is_fixup(todo_list->items[i].command))
3649                        return 0;
3650                else if (!is_noop(todo_list->items[i].command))
3651                        break;
3652        return 1;
3653}
3654
3655static enum todo_command peek_command(struct todo_list *todo_list, int offset)
3656{
3657        int i;
3658
3659        for (i = todo_list->current + offset; i < todo_list->nr; i++)
3660                if (!is_noop(todo_list->items[i].command))
3661                        return todo_list->items[i].command;
3662
3663        return -1;
3664}
3665
3666static int apply_autostash(struct replay_opts *opts)
3667{
3668        struct strbuf stash_sha1 = STRBUF_INIT;
3669        struct child_process child = CHILD_PROCESS_INIT;
3670        int ret = 0;
3671
3672        if (!read_oneliner(&stash_sha1, rebase_path_autostash(), 1)) {
3673                strbuf_release(&stash_sha1);
3674                return 0;
3675        }
3676        strbuf_trim(&stash_sha1);
3677
3678        child.git_cmd = 1;
3679        child.no_stdout = 1;
3680        child.no_stderr = 1;
3681        argv_array_push(&child.args, "stash");
3682        argv_array_push(&child.args, "apply");
3683        argv_array_push(&child.args, stash_sha1.buf);
3684        if (!run_command(&child))
3685                fprintf(stderr, _("Applied autostash.\n"));
3686        else {
3687                struct child_process store = CHILD_PROCESS_INIT;
3688
3689                store.git_cmd = 1;
3690                argv_array_push(&store.args, "stash");
3691                argv_array_push(&store.args, "store");
3692                argv_array_push(&store.args, "-m");
3693                argv_array_push(&store.args, "autostash");
3694                argv_array_push(&store.args, "-q");
3695                argv_array_push(&store.args, stash_sha1.buf);
3696                if (run_command(&store))
3697                        ret = error(_("cannot store %s"), stash_sha1.buf);
3698                else
3699                        fprintf(stderr,
3700                                _("Applying autostash resulted in conflicts.\n"
3701                                  "Your changes are safe in the stash.\n"
3702                                  "You can run \"git stash pop\" or"
3703                                  " \"git stash drop\" at any time.\n"));
3704        }
3705
3706        strbuf_release(&stash_sha1);
3707        return ret;
3708}
3709
3710static const char *reflog_message(struct replay_opts *opts,
3711        const char *sub_action, const char *fmt, ...)
3712{
3713        va_list ap;
3714        static struct strbuf buf = STRBUF_INIT;
3715
3716        va_start(ap, fmt);
3717        strbuf_reset(&buf);
3718        strbuf_addstr(&buf, action_name(opts));
3719        if (sub_action)
3720                strbuf_addf(&buf, " (%s)", sub_action);
3721        if (fmt) {
3722                strbuf_addstr(&buf, ": ");
3723                strbuf_vaddf(&buf, fmt, ap);
3724        }
3725        va_end(ap);
3726
3727        return buf.buf;
3728}
3729
3730static int run_git_checkout(struct repository *r, struct replay_opts *opts,
3731                            const char *commit, const char *action)
3732{
3733        struct child_process cmd = CHILD_PROCESS_INIT;
3734        int ret;
3735
3736        cmd.git_cmd = 1;
3737
3738        argv_array_push(&cmd.args, "checkout");
3739        argv_array_push(&cmd.args, commit);
3740        argv_array_pushf(&cmd.env_array, GIT_REFLOG_ACTION "=%s", action);
3741
3742        if (opts->verbose)
3743                ret = run_command(&cmd);
3744        else
3745                ret = run_command_silent_on_success(&cmd);
3746
3747        if (!ret)
3748                discard_index(r->index);
3749
3750        return ret;
3751}
3752
3753int prepare_branch_to_be_rebased(struct repository *r, struct replay_opts *opts,
3754                                 const char *commit)
3755{
3756        const char *action;
3757
3758        if (commit && *commit) {
3759                action = reflog_message(opts, "start", "checkout %s", commit);
3760                if (run_git_checkout(r, opts, commit, action))
3761                        return error(_("could not checkout %s"), commit);
3762        }
3763
3764        return 0;
3765}
3766
3767static int checkout_onto(struct repository *r, struct replay_opts *opts,
3768                         const char *onto_name, const struct object_id *onto,
3769                         const char *orig_head)
3770{
3771        struct object_id oid;
3772        const char *action = reflog_message(opts, "start", "checkout %s", onto_name);
3773
3774        if (get_oid(orig_head, &oid))
3775                return error(_("%s: not a valid OID"), orig_head);
3776
3777        if (run_git_checkout(r, opts, oid_to_hex(onto), action)) {
3778                apply_autostash(opts);
3779                sequencer_remove_state(opts);
3780                return error(_("could not detach HEAD"));
3781        }
3782
3783        return update_ref(NULL, "ORIG_HEAD", &oid, NULL, 0, UPDATE_REFS_MSG_ON_ERR);
3784}
3785
3786static int stopped_at_head(struct repository *r)
3787{
3788        struct object_id head;
3789        struct commit *commit;
3790        struct commit_message message;
3791
3792        if (get_oid("HEAD", &head) ||
3793            !(commit = lookup_commit(r, &head)) ||
3794            parse_commit(commit) || get_message(commit, &message))
3795                fprintf(stderr, _("Stopped at HEAD\n"));
3796        else {
3797                fprintf(stderr, _("Stopped at %s\n"), message.label);
3798                free_message(commit, &message);
3799        }
3800        return 0;
3801
3802}
3803
3804static const char rescheduled_advice[] =
3805N_("Could not execute the todo command\n"
3806"\n"
3807"    %.*s"
3808"\n"
3809"It has been rescheduled; To edit the command before continuing, please\n"
3810"edit the todo list first:\n"
3811"\n"
3812"    git rebase --edit-todo\n"
3813"    git rebase --continue\n");
3814
3815static int pick_commits(struct repository *r,
3816                        struct todo_list *todo_list,
3817                        struct replay_opts *opts)
3818{
3819        int res = 0, reschedule = 0;
3820
3821        setenv(GIT_REFLOG_ACTION, action_name(opts), 0);
3822        if (opts->allow_ff)
3823                assert(!(opts->signoff || opts->no_commit ||
3824                                opts->record_origin || opts->edit));
3825        if (read_and_refresh_cache(r, opts))
3826                return -1;
3827
3828        while (todo_list->current < todo_list->nr) {
3829                struct todo_item *item = todo_list->items + todo_list->current;
3830                const char *arg = todo_item_get_arg(todo_list, item);
3831
3832                if (save_todo(todo_list, opts))
3833                        return -1;
3834                if (is_rebase_i(opts)) {
3835                        if (item->command != TODO_COMMENT) {
3836                                FILE *f = fopen(rebase_path_msgnum(), "w");
3837
3838                                todo_list->done_nr++;
3839
3840                                if (f) {
3841                                        fprintf(f, "%d\n", todo_list->done_nr);
3842                                        fclose(f);
3843                                }
3844                                if (!opts->quiet)
3845                                        fprintf(stderr, "Rebasing (%d/%d)%s",
3846                                                todo_list->done_nr,
3847                                                todo_list->total_nr,
3848                                                opts->verbose ? "\n" : "\r");
3849                        }
3850                        unlink(rebase_path_message());
3851                        unlink(rebase_path_author_script());
3852                        unlink(rebase_path_stopped_sha());
3853                        unlink(rebase_path_amend());
3854                        unlink(git_path_merge_head(r));
3855                        delete_ref(NULL, "REBASE_HEAD", NULL, REF_NO_DEREF);
3856
3857                        if (item->command == TODO_BREAK) {
3858                                if (!opts->verbose)
3859                                        term_clear_line();
3860                                return stopped_at_head(r);
3861                        }
3862                }
3863                if (item->command <= TODO_SQUASH) {
3864                        if (is_rebase_i(opts))
3865                                setenv("GIT_REFLOG_ACTION", reflog_message(opts,
3866                                        command_to_string(item->command), NULL),
3867                                        1);
3868                        res = do_pick_commit(r, item->command, item->commit,
3869                                        opts, is_final_fixup(todo_list));
3870                        if (is_rebase_i(opts) && res < 0) {
3871                                /* Reschedule */
3872                                advise(_(rescheduled_advice),
3873                                       get_item_line_length(todo_list,
3874                                                            todo_list->current),
3875                                       get_item_line(todo_list,
3876                                                     todo_list->current));
3877                                todo_list->current--;
3878                                if (save_todo(todo_list, opts))
3879                                        return -1;
3880                        }
3881                        if (item->command == TODO_EDIT) {
3882                                struct commit *commit = item->commit;
3883                                if (!res) {
3884                                        if (!opts->verbose)
3885                                                term_clear_line();
3886                                        fprintf(stderr,
3887                                                _("Stopped at %s...  %.*s\n"),
3888                                                short_commit_name(commit),
3889                                                item->arg_len, arg);
3890                                }
3891                                return error_with_patch(r, commit,
3892                                        arg, item->arg_len, opts, res, !res);
3893                        }
3894                        if (is_rebase_i(opts) && !res)
3895                                record_in_rewritten(&item->commit->object.oid,
3896                                        peek_command(todo_list, 1));
3897                        if (res && is_fixup(item->command)) {
3898                                if (res == 1)
3899                                        intend_to_amend();
3900                                return error_failed_squash(r, item->commit, opts,
3901                                        item->arg_len, arg);
3902                        } else if (res && is_rebase_i(opts) && item->commit) {
3903                                int to_amend = 0;
3904                                struct object_id oid;
3905
3906                                /*
3907                                 * If we are rewording and have either
3908                                 * fast-forwarded already, or are about to
3909                                 * create a new root commit, we want to amend,
3910                                 * otherwise we do not.
3911                                 */
3912                                if (item->command == TODO_REWORD &&
3913                                    !get_oid("HEAD", &oid) &&
3914                                    (oideq(&item->commit->object.oid, &oid) ||
3915                                     (opts->have_squash_onto &&
3916                                      oideq(&opts->squash_onto, &oid))))
3917                                        to_amend = 1;
3918
3919                                return res | error_with_patch(r, item->commit,
3920                                                arg, item->arg_len, opts,
3921                                                res, to_amend);
3922                        }
3923                } else if (item->command == TODO_EXEC) {
3924                        char *end_of_arg = (char *)(arg + item->arg_len);
3925                        int saved = *end_of_arg;
3926                        struct stat st;
3927
3928                        if (!opts->verbose)
3929                                term_clear_line();
3930                        *end_of_arg = '\0';
3931                        res = do_exec(r, arg);
3932                        *end_of_arg = saved;
3933
3934                        if (res) {
3935                                if (opts->reschedule_failed_exec)
3936                                        reschedule = 1;
3937                        } else if (stat(get_todo_path(opts), &st))
3938                                res = error_errno(_("could not stat '%s'"),
3939                                                  get_todo_path(opts));
3940                        else if (match_stat_data(&todo_list->stat, &st)) {
3941                                /* Reread the todo file if it has changed. */
3942                                todo_list_release(todo_list);
3943                                if (read_populate_todo(r, todo_list, opts))
3944                                        res = -1; /* message was printed */
3945                                /* `current` will be incremented below */
3946                                todo_list->current = -1;
3947                        }
3948                } else if (item->command == TODO_LABEL) {
3949                        if ((res = do_label(r, arg, item->arg_len)))
3950                                reschedule = 1;
3951                } else if (item->command == TODO_RESET) {
3952                        if ((res = do_reset(r, arg, item->arg_len, opts)))
3953                                reschedule = 1;
3954                } else if (item->command == TODO_MERGE) {
3955                        if ((res = do_merge(r, item->commit,
3956                                            arg, item->arg_len,
3957                                            item->flags, opts)) < 0)
3958                                reschedule = 1;
3959                        else if (item->commit)
3960                                record_in_rewritten(&item->commit->object.oid,
3961                                                    peek_command(todo_list, 1));
3962                        if (res > 0)
3963                                /* failed with merge conflicts */
3964                                return error_with_patch(r, item->commit,
3965                                                        arg, item->arg_len,
3966                                                        opts, res, 0);
3967                } else if (!is_noop(item->command))
3968                        return error(_("unknown command %d"), item->command);
3969
3970                if (reschedule) {
3971                        advise(_(rescheduled_advice),
3972                               get_item_line_length(todo_list,
3973                                                    todo_list->current),
3974                               get_item_line(todo_list, todo_list->current));
3975                        todo_list->current--;
3976                        if (save_todo(todo_list, opts))
3977                                return -1;
3978                        if (item->commit)
3979                                return error_with_patch(r,
3980                                                        item->commit,
3981                                                        arg, item->arg_len,
3982                                                        opts, res, 0);
3983                }
3984
3985                todo_list->current++;
3986                if (res)
3987                        return res;
3988        }
3989
3990        if (is_rebase_i(opts)) {
3991                struct strbuf head_ref = STRBUF_INIT, buf = STRBUF_INIT;
3992                struct stat st;
3993
3994                /* Stopped in the middle, as planned? */
3995                if (todo_list->current < todo_list->nr)
3996                        return 0;
3997
3998                if (read_oneliner(&head_ref, rebase_path_head_name(), 0) &&
3999                                starts_with(head_ref.buf, "refs/")) {
4000                        const char *msg;
4001                        struct object_id head, orig;
4002                        int res;
4003
4004                        if (get_oid("HEAD", &head)) {
4005                                res = error(_("cannot read HEAD"));
4006cleanup_head_ref:
4007                                strbuf_release(&head_ref);
4008                                strbuf_release(&buf);
4009                                return res;
4010                        }
4011                        if (!read_oneliner(&buf, rebase_path_orig_head(), 0) ||
4012                                        get_oid_hex(buf.buf, &orig)) {
4013                                res = error(_("could not read orig-head"));
4014                                goto cleanup_head_ref;
4015                        }
4016                        strbuf_reset(&buf);
4017                        if (!read_oneliner(&buf, rebase_path_onto(), 0)) {
4018                                res = error(_("could not read 'onto'"));
4019                                goto cleanup_head_ref;
4020                        }
4021                        msg = reflog_message(opts, "finish", "%s onto %s",
4022                                head_ref.buf, buf.buf);
4023                        if (update_ref(msg, head_ref.buf, &head, &orig,
4024                                       REF_NO_DEREF, UPDATE_REFS_MSG_ON_ERR)) {
4025                                res = error(_("could not update %s"),
4026                                        head_ref.buf);
4027                                goto cleanup_head_ref;
4028                        }
4029                        msg = reflog_message(opts, "finish", "returning to %s",
4030                                head_ref.buf);
4031                        if (create_symref("HEAD", head_ref.buf, msg)) {
4032                                res = error(_("could not update HEAD to %s"),
4033                                        head_ref.buf);
4034                                goto cleanup_head_ref;
4035                        }
4036                        strbuf_reset(&buf);
4037                }
4038
4039                if (opts->verbose) {
4040                        struct rev_info log_tree_opt;
4041                        struct object_id orig, head;
4042
4043                        memset(&log_tree_opt, 0, sizeof(log_tree_opt));
4044                        repo_init_revisions(r, &log_tree_opt, NULL);
4045                        log_tree_opt.diff = 1;
4046                        log_tree_opt.diffopt.output_format =
4047                                DIFF_FORMAT_DIFFSTAT;
4048                        log_tree_opt.disable_stdin = 1;
4049
4050                        if (read_oneliner(&buf, rebase_path_orig_head(), 0) &&
4051                            !get_oid(buf.buf, &orig) &&
4052                            !get_oid("HEAD", &head)) {
4053                                diff_tree_oid(&orig, &head, "",
4054                                              &log_tree_opt.diffopt);
4055                                log_tree_diff_flush(&log_tree_opt);
4056                        }
4057                }
4058                flush_rewritten_pending();
4059                if (!stat(rebase_path_rewritten_list(), &st) &&
4060                                st.st_size > 0) {
4061                        struct child_process child = CHILD_PROCESS_INIT;
4062                        const char *post_rewrite_hook =
4063                                find_hook("post-rewrite");
4064
4065                        child.in = open(rebase_path_rewritten_list(), O_RDONLY);
4066                        child.git_cmd = 1;
4067                        argv_array_push(&child.args, "notes");
4068                        argv_array_push(&child.args, "copy");
4069                        argv_array_push(&child.args, "--for-rewrite=rebase");
4070                        /* we don't care if this copying failed */
4071                        run_command(&child);
4072
4073                        if (post_rewrite_hook) {
4074                                struct child_process hook = CHILD_PROCESS_INIT;
4075
4076                                hook.in = open(rebase_path_rewritten_list(),
4077                                        O_RDONLY);
4078                                hook.stdout_to_stderr = 1;
4079                                hook.trace2_hook_name = "post-rewrite";
4080                                argv_array_push(&hook.args, post_rewrite_hook);
4081                                argv_array_push(&hook.args, "rebase");
4082                                /* we don't care if this hook failed */
4083                                run_command(&hook);
4084                        }
4085                }
4086                apply_autostash(opts);
4087
4088                if (!opts->quiet) {
4089                        if (!opts->verbose)
4090                                term_clear_line();
4091                        fprintf(stderr,
4092                                "Successfully rebased and updated %s.\n",
4093                                head_ref.buf);
4094                }
4095
4096                strbuf_release(&buf);
4097                strbuf_release(&head_ref);
4098        }
4099
4100        /*
4101         * Sequence of picks finished successfully; cleanup by
4102         * removing the .git/sequencer directory
4103         */
4104        return sequencer_remove_state(opts);
4105}
4106
4107static int continue_single_pick(struct repository *r)
4108{
4109        const char *argv[] = { "commit", NULL };
4110
4111        if (!file_exists(git_path_cherry_pick_head(r)) &&
4112            !file_exists(git_path_revert_head(r)))
4113                return error(_("no cherry-pick or revert in progress"));
4114        return run_command_v_opt(argv, RUN_GIT_CMD);
4115}
4116
4117static int commit_staged_changes(struct repository *r,
4118                                 struct replay_opts *opts,
4119                                 struct todo_list *todo_list)
4120{
4121        unsigned int flags = ALLOW_EMPTY | EDIT_MSG;
4122        unsigned int final_fixup = 0, is_clean;
4123
4124        if (has_unstaged_changes(r, 1))
4125                return error(_("cannot rebase: You have unstaged changes."));
4126
4127        is_clean = !has_uncommitted_changes(r, 0);
4128
4129        if (file_exists(rebase_path_amend())) {
4130                struct strbuf rev = STRBUF_INIT;
4131                struct object_id head, to_amend;
4132
4133                if (get_oid("HEAD", &head))
4134                        return error(_("cannot amend non-existing commit"));
4135                if (!read_oneliner(&rev, rebase_path_amend(), 0))
4136                        return error(_("invalid file: '%s'"), rebase_path_amend());
4137                if (get_oid_hex(rev.buf, &to_amend))
4138                        return error(_("invalid contents: '%s'"),
4139                                rebase_path_amend());
4140                if (!is_clean && !oideq(&head, &to_amend))
4141                        return error(_("\nYou have uncommitted changes in your "
4142                                       "working tree. Please, commit them\n"
4143                                       "first and then run 'git rebase "
4144                                       "--continue' again."));
4145                /*
4146                 * When skipping a failed fixup/squash, we need to edit the
4147                 * commit message, the current fixup list and count, and if it
4148                 * was the last fixup/squash in the chain, we need to clean up
4149                 * the commit message and if there was a squash, let the user
4150                 * edit it.
4151                 */
4152                if (!is_clean || !opts->current_fixup_count)
4153                        ; /* this is not the final fixup */
4154                else if (!oideq(&head, &to_amend) ||
4155                         !file_exists(rebase_path_stopped_sha())) {
4156                        /* was a final fixup or squash done manually? */
4157                        if (!is_fixup(peek_command(todo_list, 0))) {
4158                                unlink(rebase_path_fixup_msg());
4159                                unlink(rebase_path_squash_msg());
4160                                unlink(rebase_path_current_fixups());
4161                                strbuf_reset(&opts->current_fixups);
4162                                opts->current_fixup_count = 0;
4163                        }
4164                } else {
4165                        /* we are in a fixup/squash chain */
4166                        const char *p = opts->current_fixups.buf;
4167                        int len = opts->current_fixups.len;
4168
4169                        opts->current_fixup_count--;
4170                        if (!len)
4171                                BUG("Incorrect current_fixups:\n%s", p);
4172                        while (len && p[len - 1] != '\n')
4173                                len--;
4174                        strbuf_setlen(&opts->current_fixups, len);
4175                        if (write_message(p, len, rebase_path_current_fixups(),
4176                                          0) < 0)
4177                                return error(_("could not write file: '%s'"),
4178                                             rebase_path_current_fixups());
4179
4180                        /*
4181                         * If a fixup/squash in a fixup/squash chain failed, the
4182                         * commit message is already correct, no need to commit
4183                         * it again.
4184                         *
4185                         * Only if it is the final command in the fixup/squash
4186                         * chain, and only if the chain is longer than a single
4187                         * fixup/squash command (which was just skipped), do we
4188                         * actually need to re-commit with a cleaned up commit
4189                         * message.
4190                         */
4191                        if (opts->current_fixup_count > 0 &&
4192                            !is_fixup(peek_command(todo_list, 0))) {
4193                                final_fixup = 1;
4194                                /*
4195                                 * If there was not a single "squash" in the
4196                                 * chain, we only need to clean up the commit
4197                                 * message, no need to bother the user with
4198                                 * opening the commit message in the editor.
4199                                 */
4200                                if (!starts_with(p, "squash ") &&
4201                                    !strstr(p, "\nsquash "))
4202                                        flags = (flags & ~EDIT_MSG) | CLEANUP_MSG;
4203                        } else if (is_fixup(peek_command(todo_list, 0))) {
4204                                /*
4205                                 * We need to update the squash message to skip
4206                                 * the latest commit message.
4207                                 */
4208                                struct commit *commit;
4209                                const char *path = rebase_path_squash_msg();
4210
4211                                if (parse_head(r, &commit) ||
4212                                    !(p = get_commit_buffer(commit, NULL)) ||
4213                                    write_message(p, strlen(p), path, 0)) {
4214                                        unuse_commit_buffer(commit, p);
4215                                        return error(_("could not write file: "
4216                                                       "'%s'"), path);
4217                                }
4218                                unuse_commit_buffer(commit, p);
4219                        }
4220                }
4221
4222                strbuf_release(&rev);
4223                flags |= AMEND_MSG;
4224        }
4225
4226        if (is_clean) {
4227                const char *cherry_pick_head = git_path_cherry_pick_head(r);
4228
4229                if (file_exists(cherry_pick_head) && unlink(cherry_pick_head))
4230                        return error(_("could not remove CHERRY_PICK_HEAD"));
4231                if (!final_fixup)
4232                        return 0;
4233        }
4234
4235        if (run_git_commit(r, final_fixup ? NULL : rebase_path_message(),
4236                           opts, flags))
4237                return error(_("could not commit staged changes."));
4238        unlink(rebase_path_amend());
4239        unlink(git_path_merge_head(r));
4240        if (final_fixup) {
4241                unlink(rebase_path_fixup_msg());
4242                unlink(rebase_path_squash_msg());
4243        }
4244        if (opts->current_fixup_count > 0) {
4245                /*
4246                 * Whether final fixup or not, we just cleaned up the commit
4247                 * message...
4248                 */
4249                unlink(rebase_path_current_fixups());
4250                strbuf_reset(&opts->current_fixups);
4251                opts->current_fixup_count = 0;
4252        }
4253        return 0;
4254}
4255
4256int sequencer_continue(struct repository *r, struct replay_opts *opts)
4257{
4258        struct todo_list todo_list = TODO_LIST_INIT;
4259        int res;
4260
4261        if (read_and_refresh_cache(r, opts))
4262                return -1;
4263
4264        if (read_populate_opts(opts))
4265                return -1;
4266        if (is_rebase_i(opts)) {
4267                if ((res = read_populate_todo(r, &todo_list, opts)))
4268                        goto release_todo_list;
4269                if (commit_staged_changes(r, opts, &todo_list))
4270                        return -1;
4271        } else if (!file_exists(get_todo_path(opts)))
4272                return continue_single_pick(r);
4273        else if ((res = read_populate_todo(r, &todo_list, opts)))
4274                goto release_todo_list;
4275
4276        if (!is_rebase_i(opts)) {
4277                /* Verify that the conflict has been resolved */
4278                if (file_exists(git_path_cherry_pick_head(r)) ||
4279                    file_exists(git_path_revert_head(r))) {
4280                        res = continue_single_pick(r);
4281                        if (res)
4282                                goto release_todo_list;
4283                }
4284                if (index_differs_from(r, "HEAD", NULL, 0)) {
4285                        res = error_dirty_index(r, opts);
4286                        goto release_todo_list;
4287                }
4288                todo_list.current++;
4289        } else if (file_exists(rebase_path_stopped_sha())) {
4290                struct strbuf buf = STRBUF_INIT;
4291                struct object_id oid;
4292
4293                if (read_oneliner(&buf, rebase_path_stopped_sha(), 1) &&
4294                    !get_oid_committish(buf.buf, &oid))
4295                        record_in_rewritten(&oid, peek_command(&todo_list, 0));
4296                strbuf_release(&buf);
4297        }
4298
4299        res = pick_commits(r, &todo_list, opts);
4300release_todo_list:
4301        todo_list_release(&todo_list);
4302        return res;
4303}
4304
4305static int single_pick(struct repository *r,
4306                       struct commit *cmit,
4307                       struct replay_opts *opts)
4308{
4309        setenv(GIT_REFLOG_ACTION, action_name(opts), 0);
4310        return do_pick_commit(r, opts->action == REPLAY_PICK ?
4311                TODO_PICK : TODO_REVERT, cmit, opts, 0);
4312}
4313
4314int sequencer_pick_revisions(struct repository *r,
4315                             struct replay_opts *opts)
4316{
4317        struct todo_list todo_list = TODO_LIST_INIT;
4318        struct object_id oid;
4319        int i, res;
4320
4321        assert(opts->revs);
4322        if (read_and_refresh_cache(r, opts))
4323                return -1;
4324
4325        for (i = 0; i < opts->revs->pending.nr; i++) {
4326                struct object_id oid;
4327                const char *name = opts->revs->pending.objects[i].name;
4328
4329                /* This happens when using --stdin. */
4330                if (!strlen(name))
4331                        continue;
4332
4333                if (!get_oid(name, &oid)) {
4334                        if (!lookup_commit_reference_gently(r, &oid, 1)) {
4335                                enum object_type type = oid_object_info(r,
4336                                                                        &oid,
4337                                                                        NULL);
4338                                return error(_("%s: can't cherry-pick a %s"),
4339                                        name, type_name(type));
4340                        }
4341                } else
4342                        return error(_("%s: bad revision"), name);
4343        }
4344
4345        /*
4346         * If we were called as "git cherry-pick <commit>", just
4347         * cherry-pick/revert it, set CHERRY_PICK_HEAD /
4348         * REVERT_HEAD, and don't touch the sequencer state.
4349         * This means it is possible to cherry-pick in the middle
4350         * of a cherry-pick sequence.
4351         */
4352        if (opts->revs->cmdline.nr == 1 &&
4353            opts->revs->cmdline.rev->whence == REV_CMD_REV &&
4354            opts->revs->no_walk &&
4355            !opts->revs->cmdline.rev->flags) {
4356                struct commit *cmit;
4357                if (prepare_revision_walk(opts->revs))
4358                        return error(_("revision walk setup failed"));
4359                cmit = get_revision(opts->revs);
4360                if (!cmit)
4361                        return error(_("empty commit set passed"));
4362                if (get_revision(opts->revs))
4363                        BUG("unexpected extra commit from walk");
4364                return single_pick(r, cmit, opts);
4365        }
4366
4367        /*
4368         * Start a new cherry-pick/ revert sequence; but
4369         * first, make sure that an existing one isn't in
4370         * progress
4371         */
4372
4373        if (walk_revs_populate_todo(&todo_list, opts) ||
4374                        create_seq_dir(r) < 0)
4375                return -1;
4376        if (get_oid("HEAD", &oid) && (opts->action == REPLAY_REVERT))
4377                return error(_("can't revert as initial commit"));
4378        if (save_head(oid_to_hex(&oid)))
4379                return -1;
4380        if (save_opts(opts))
4381                return -1;
4382        update_abort_safety_file();
4383        res = pick_commits(r, &todo_list, opts);
4384        todo_list_release(&todo_list);
4385        return res;
4386}
4387
4388void append_signoff(struct strbuf *msgbuf, size_t ignore_footer, unsigned flag)
4389{
4390        unsigned no_dup_sob = flag & APPEND_SIGNOFF_DEDUP;
4391        struct strbuf sob = STRBUF_INIT;
4392        int has_footer;
4393
4394        strbuf_addstr(&sob, sign_off_header);
4395        strbuf_addstr(&sob, fmt_name(WANT_COMMITTER_IDENT));
4396        strbuf_addch(&sob, '\n');
4397
4398        if (!ignore_footer)
4399                strbuf_complete_line(msgbuf);
4400
4401        /*
4402         * If the whole message buffer is equal to the sob, pretend that we
4403         * found a conforming footer with a matching sob
4404         */
4405        if (msgbuf->len - ignore_footer == sob.len &&
4406            !strncmp(msgbuf->buf, sob.buf, sob.len))
4407                has_footer = 3;
4408        else
4409                has_footer = has_conforming_footer(msgbuf, &sob, ignore_footer);
4410
4411        if (!has_footer) {
4412                const char *append_newlines = NULL;
4413                size_t len = msgbuf->len - ignore_footer;
4414
4415                if (!len) {
4416                        /*
4417                         * The buffer is completely empty.  Leave foom for
4418                         * the title and body to be filled in by the user.
4419                         */
4420                        append_newlines = "\n\n";
4421                } else if (len == 1) {
4422                        /*
4423                         * Buffer contains a single newline.  Add another
4424                         * so that we leave room for the title and body.
4425                         */
4426                        append_newlines = "\n";
4427                } else if (msgbuf->buf[len - 2] != '\n') {
4428                        /*
4429                         * Buffer ends with a single newline.  Add another
4430                         * so that there is an empty line between the message
4431                         * body and the sob.
4432                         */
4433                        append_newlines = "\n";
4434                } /* else, the buffer already ends with two newlines. */
4435
4436                if (append_newlines)
4437                        strbuf_splice(msgbuf, msgbuf->len - ignore_footer, 0,
4438                                append_newlines, strlen(append_newlines));
4439        }
4440
4441        if (has_footer != 3 && (!no_dup_sob || has_footer != 2))
4442                strbuf_splice(msgbuf, msgbuf->len - ignore_footer, 0,
4443                                sob.buf, sob.len);
4444
4445        strbuf_release(&sob);
4446}
4447
4448struct labels_entry {
4449        struct hashmap_entry entry;
4450        char label[FLEX_ARRAY];
4451};
4452
4453static int labels_cmp(const void *fndata, const struct labels_entry *a,
4454                      const struct labels_entry *b, const void *key)
4455{
4456        return key ? strcmp(a->label, key) : strcmp(a->label, b->label);
4457}
4458
4459struct string_entry {
4460        struct oidmap_entry entry;
4461        char string[FLEX_ARRAY];
4462};
4463
4464struct label_state {
4465        struct oidmap commit2label;
4466        struct hashmap labels;
4467        struct strbuf buf;
4468};
4469
4470static const char *label_oid(struct object_id *oid, const char *label,
4471                             struct label_state *state)
4472{
4473        struct labels_entry *labels_entry;
4474        struct string_entry *string_entry;
4475        struct object_id dummy;
4476        size_t len;
4477        int i;
4478
4479        string_entry = oidmap_get(&state->commit2label, oid);
4480        if (string_entry)
4481                return string_entry->string;
4482
4483        /*
4484         * For "uninteresting" commits, i.e. commits that are not to be
4485         * rebased, and which can therefore not be labeled, we use a unique
4486         * abbreviation of the commit name. This is slightly more complicated
4487         * than calling find_unique_abbrev() because we also need to make
4488         * sure that the abbreviation does not conflict with any other
4489         * label.
4490         *
4491         * We disallow "interesting" commits to be labeled by a string that
4492         * is a valid full-length hash, to ensure that we always can find an
4493         * abbreviation for any uninteresting commit's names that does not
4494         * clash with any other label.
4495         */
4496        if (!label) {
4497                char *p;
4498
4499                strbuf_reset(&state->buf);
4500                strbuf_grow(&state->buf, GIT_SHA1_HEXSZ);
4501                label = p = state->buf.buf;
4502
4503                find_unique_abbrev_r(p, oid, default_abbrev);
4504
4505                /*
4506                 * We may need to extend the abbreviated hash so that there is
4507                 * no conflicting label.
4508                 */
4509                if (hashmap_get_from_hash(&state->labels, strihash(p), p)) {
4510                        size_t i = strlen(p) + 1;
4511
4512                        oid_to_hex_r(p, oid);
4513                        for (; i < GIT_SHA1_HEXSZ; i++) {
4514                                char save = p[i];
4515                                p[i] = '\0';
4516                                if (!hashmap_get_from_hash(&state->labels,
4517                                                           strihash(p), p))
4518                                        break;
4519                                p[i] = save;
4520                        }
4521                }
4522        } else if (((len = strlen(label)) == the_hash_algo->hexsz &&
4523                    !get_oid_hex(label, &dummy)) ||
4524                   (len == 1 && *label == '#') ||
4525                   hashmap_get_from_hash(&state->labels,
4526                                         strihash(label), label)) {
4527                /*
4528                 * If the label already exists, or if the label is a valid full
4529                 * OID, or the label is a '#' (which we use as a separator
4530                 * between merge heads and oneline), we append a dash and a
4531                 * number to make it unique.
4532                 */
4533                struct strbuf *buf = &state->buf;
4534
4535                strbuf_reset(buf);
4536                strbuf_add(buf, label, len);
4537
4538                for (i = 2; ; i++) {
4539                        strbuf_setlen(buf, len);
4540                        strbuf_addf(buf, "-%d", i);
4541                        if (!hashmap_get_from_hash(&state->labels,
4542                                                   strihash(buf->buf),
4543                                                   buf->buf))
4544                                break;
4545                }
4546
4547                label = buf->buf;
4548        }
4549
4550        FLEX_ALLOC_STR(labels_entry, label, label);
4551        hashmap_entry_init(labels_entry, strihash(label));
4552        hashmap_add(&state->labels, labels_entry);
4553
4554        FLEX_ALLOC_STR(string_entry, string, label);
4555        oidcpy(&string_entry->entry.oid, oid);
4556        oidmap_put(&state->commit2label, string_entry);
4557
4558        return string_entry->string;
4559}
4560
4561static int make_script_with_merges(struct pretty_print_context *pp,
4562                                   struct rev_info *revs, struct strbuf *out,
4563                                   unsigned flags)
4564{
4565        int keep_empty = flags & TODO_LIST_KEEP_EMPTY;
4566        int rebase_cousins = flags & TODO_LIST_REBASE_COUSINS;
4567        int root_with_onto = flags & TODO_LIST_ROOT_WITH_ONTO;
4568        struct strbuf buf = STRBUF_INIT, oneline = STRBUF_INIT;
4569        struct strbuf label = STRBUF_INIT;
4570        struct commit_list *commits = NULL, **tail = &commits, *iter;
4571        struct commit_list *tips = NULL, **tips_tail = &tips;
4572        struct commit *commit;
4573        struct oidmap commit2todo = OIDMAP_INIT;
4574        struct string_entry *entry;
4575        struct oidset interesting = OIDSET_INIT, child_seen = OIDSET_INIT,
4576                shown = OIDSET_INIT;
4577        struct label_state state = { OIDMAP_INIT, { NULL }, STRBUF_INIT };
4578
4579        int abbr = flags & TODO_LIST_ABBREVIATE_CMDS;
4580        const char *cmd_pick = abbr ? "p" : "pick",
4581                *cmd_label = abbr ? "l" : "label",
4582                *cmd_reset = abbr ? "t" : "reset",
4583                *cmd_merge = abbr ? "m" : "merge";
4584
4585        oidmap_init(&commit2todo, 0);
4586        oidmap_init(&state.commit2label, 0);
4587        hashmap_init(&state.labels, (hashmap_cmp_fn) labels_cmp, NULL, 0);
4588        strbuf_init(&state.buf, 32);
4589
4590        if (revs->cmdline.nr && (revs->cmdline.rev[0].flags & BOTTOM)) {
4591                struct object_id *oid = &revs->cmdline.rev[0].item->oid;
4592                FLEX_ALLOC_STR(entry, string, "onto");
4593                oidcpy(&entry->entry.oid, oid);
4594                oidmap_put(&state.commit2label, entry);
4595        }
4596
4597        /*
4598         * First phase:
4599         * - get onelines for all commits
4600         * - gather all branch tips (i.e. 2nd or later parents of merges)
4601         * - label all branch tips
4602         */
4603        while ((commit = get_revision(revs))) {
4604                struct commit_list *to_merge;
4605                const char *p1, *p2;
4606                struct object_id *oid;
4607                int is_empty;
4608
4609                tail = &commit_list_insert(commit, tail)->next;
4610                oidset_insert(&interesting, &commit->object.oid);
4611
4612                is_empty = is_original_commit_empty(commit);
4613                if (!is_empty && (commit->object.flags & PATCHSAME))
4614                        continue;
4615
4616                strbuf_reset(&oneline);
4617                pretty_print_commit(pp, commit, &oneline);
4618
4619                to_merge = commit->parents ? commit->parents->next : NULL;
4620                if (!to_merge) {
4621                        /* non-merge commit: easy case */
4622                        strbuf_reset(&buf);
4623                        if (!keep_empty && is_empty)
4624                                strbuf_addf(&buf, "%c ", comment_line_char);
4625                        strbuf_addf(&buf, "%s %s %s", cmd_pick,
4626                                    oid_to_hex(&commit->object.oid),
4627                                    oneline.buf);
4628
4629                        FLEX_ALLOC_STR(entry, string, buf.buf);
4630                        oidcpy(&entry->entry.oid, &commit->object.oid);
4631                        oidmap_put(&commit2todo, entry);
4632
4633                        continue;
4634                }
4635
4636                /* Create a label */
4637                strbuf_reset(&label);
4638                if (skip_prefix(oneline.buf, "Merge ", &p1) &&
4639                    (p1 = strchr(p1, '\'')) &&
4640                    (p2 = strchr(++p1, '\'')))
4641                        strbuf_add(&label, p1, p2 - p1);
4642                else if (skip_prefix(oneline.buf, "Merge pull request ",
4643                                     &p1) &&
4644                         (p1 = strstr(p1, " from ")))
4645                        strbuf_addstr(&label, p1 + strlen(" from "));
4646                else
4647                        strbuf_addbuf(&label, &oneline);
4648
4649                for (p1 = label.buf; *p1; p1++)
4650                        if (isspace(*p1))
4651                                *(char *)p1 = '-';
4652
4653                strbuf_reset(&buf);
4654                strbuf_addf(&buf, "%s -C %s",
4655                            cmd_merge, oid_to_hex(&commit->object.oid));
4656
4657                /* label the tips of merged branches */
4658                for (; to_merge; to_merge = to_merge->next) {
4659                        oid = &to_merge->item->object.oid;
4660                        strbuf_addch(&buf, ' ');
4661
4662                        if (!oidset_contains(&interesting, oid)) {
4663                                strbuf_addstr(&buf, label_oid(oid, NULL,
4664                                                              &state));
4665                                continue;
4666                        }
4667
4668                        tips_tail = &commit_list_insert(to_merge->item,
4669                                                        tips_tail)->next;
4670
4671                        strbuf_addstr(&buf, label_oid(oid, label.buf, &state));
4672                }
4673                strbuf_addf(&buf, " # %s", oneline.buf);
4674
4675                FLEX_ALLOC_STR(entry, string, buf.buf);
4676                oidcpy(&entry->entry.oid, &commit->object.oid);
4677                oidmap_put(&commit2todo, entry);
4678        }
4679
4680        /*
4681         * Second phase:
4682         * - label branch points
4683         * - add HEAD to the branch tips
4684         */
4685        for (iter = commits; iter; iter = iter->next) {
4686                struct commit_list *parent = iter->item->parents;
4687                for (; parent; parent = parent->next) {
4688                        struct object_id *oid = &parent->item->object.oid;
4689                        if (!oidset_contains(&interesting, oid))
4690                                continue;
4691                        if (oidset_insert(&child_seen, oid))
4692                                label_oid(oid, "branch-point", &state);
4693                }
4694
4695                /* Add HEAD as implict "tip of branch" */
4696                if (!iter->next)
4697                        tips_tail = &commit_list_insert(iter->item,
4698                                                        tips_tail)->next;
4699        }
4700
4701        /*
4702         * Third phase: output the todo list. This is a bit tricky, as we
4703         * want to avoid jumping back and forth between revisions. To
4704         * accomplish that goal, we walk backwards from the branch tips,
4705         * gathering commits not yet shown, reversing the list on the fly,
4706         * then outputting that list (labeling revisions as needed).
4707         */
4708        strbuf_addf(out, "%s onto\n", cmd_label);
4709        for (iter = tips; iter; iter = iter->next) {
4710                struct commit_list *list = NULL, *iter2;
4711
4712                commit = iter->item;
4713                if (oidset_contains(&shown, &commit->object.oid))
4714                        continue;
4715                entry = oidmap_get(&state.commit2label, &commit->object.oid);
4716
4717                if (entry)
4718                        strbuf_addf(out, "\n%c Branch %s\n", comment_line_char, entry->string);
4719                else
4720                        strbuf_addch(out, '\n');
4721
4722                while (oidset_contains(&interesting, &commit->object.oid) &&
4723                       !oidset_contains(&shown, &commit->object.oid)) {
4724                        commit_list_insert(commit, &list);
4725                        if (!commit->parents) {
4726                                commit = NULL;
4727                                break;
4728                        }
4729                        commit = commit->parents->item;
4730                }
4731
4732                if (!commit)
4733                        strbuf_addf(out, "%s %s\n", cmd_reset,
4734                                    rebase_cousins || root_with_onto ?
4735                                    "onto" : "[new root]");
4736                else {
4737                        const char *to = NULL;
4738
4739                        entry = oidmap_get(&state.commit2label,
4740                                           &commit->object.oid);
4741                        if (entry)
4742                                to = entry->string;
4743                        else if (!rebase_cousins)
4744                                to = label_oid(&commit->object.oid, NULL,
4745                                               &state);
4746
4747                        if (!to || !strcmp(to, "onto"))
4748                                strbuf_addf(out, "%s onto\n", cmd_reset);
4749                        else {
4750                                strbuf_reset(&oneline);
4751                                pretty_print_commit(pp, commit, &oneline);
4752                                strbuf_addf(out, "%s %s # %s\n",
4753                                            cmd_reset, to, oneline.buf);
4754                        }
4755                }
4756
4757                for (iter2 = list; iter2; iter2 = iter2->next) {
4758                        struct object_id *oid = &iter2->item->object.oid;
4759                        entry = oidmap_get(&commit2todo, oid);
4760                        /* only show if not already upstream */
4761                        if (entry)
4762                                strbuf_addf(out, "%s\n", entry->string);
4763                        entry = oidmap_get(&state.commit2label, oid);
4764                        if (entry)
4765                                strbuf_addf(out, "%s %s\n",
4766                                            cmd_label, entry->string);
4767                        oidset_insert(&shown, oid);
4768                }
4769
4770                free_commit_list(list);
4771        }
4772
4773        free_commit_list(commits);
4774        free_commit_list(tips);
4775
4776        strbuf_release(&label);
4777        strbuf_release(&oneline);
4778        strbuf_release(&buf);
4779
4780        oidmap_free(&commit2todo, 1);
4781        oidmap_free(&state.commit2label, 1);
4782        hashmap_free(&state.labels, 1);
4783        strbuf_release(&state.buf);
4784
4785        return 0;
4786}
4787
4788int sequencer_make_script(struct repository *r, struct strbuf *out, int argc,
4789                          const char **argv, unsigned flags)
4790{
4791        char *format = NULL;
4792        struct pretty_print_context pp = {0};
4793        struct rev_info revs;
4794        struct commit *commit;
4795        int keep_empty = flags & TODO_LIST_KEEP_EMPTY;
4796        const char *insn = flags & TODO_LIST_ABBREVIATE_CMDS ? "p" : "pick";
4797        int rebase_merges = flags & TODO_LIST_REBASE_MERGES;
4798
4799        repo_init_revisions(r, &revs, NULL);
4800        revs.verbose_header = 1;
4801        if (!rebase_merges)
4802                revs.max_parents = 1;
4803        revs.cherry_mark = 1;
4804        revs.limited = 1;
4805        revs.reverse = 1;
4806        revs.right_only = 1;
4807        revs.sort_order = REV_SORT_IN_GRAPH_ORDER;
4808        revs.topo_order = 1;
4809
4810        revs.pretty_given = 1;
4811        git_config_get_string("rebase.instructionFormat", &format);
4812        if (!format || !*format) {
4813                free(format);
4814                format = xstrdup("%s");
4815        }
4816        get_commit_format(format, &revs);
4817        free(format);
4818        pp.fmt = revs.commit_format;
4819        pp.output_encoding = get_log_output_encoding();
4820
4821        if (setup_revisions(argc, argv, &revs, NULL) > 1)
4822                return error(_("make_script: unhandled options"));
4823
4824        if (prepare_revision_walk(&revs) < 0)
4825                return error(_("make_script: error preparing revisions"));
4826
4827        if (rebase_merges)
4828                return make_script_with_merges(&pp, &revs, out, flags);
4829
4830        while ((commit = get_revision(&revs))) {
4831                int is_empty  = is_original_commit_empty(commit);
4832
4833                if (!is_empty && (commit->object.flags & PATCHSAME))
4834                        continue;
4835                if (!keep_empty && is_empty)
4836                        strbuf_addf(out, "%c ", comment_line_char);
4837                strbuf_addf(out, "%s %s ", insn,
4838                            oid_to_hex(&commit->object.oid));
4839                pretty_print_commit(&pp, commit, out);
4840                strbuf_addch(out, '\n');
4841        }
4842        return 0;
4843}
4844
4845/*
4846 * Add commands after pick and (series of) squash/fixup commands
4847 * in the todo list.
4848 */
4849void todo_list_add_exec_commands(struct todo_list *todo_list,
4850                                 struct string_list *commands)
4851{
4852        struct strbuf *buf = &todo_list->buf;
4853        size_t base_offset = buf->len;
4854        int i, insert, nr = 0, alloc = 0;
4855        struct todo_item *items = NULL, *base_items = NULL;
4856
4857        base_items = xcalloc(commands->nr, sizeof(struct todo_item));
4858        for (i = 0; i < commands->nr; i++) {
4859                size_t command_len = strlen(commands->items[i].string);
4860
4861                strbuf_addstr(buf, commands->items[i].string);
4862                strbuf_addch(buf, '\n');
4863
4864                base_items[i].command = TODO_EXEC;
4865                base_items[i].offset_in_buf = base_offset;
4866                base_items[i].arg_offset = base_offset + strlen("exec ");
4867                base_items[i].arg_len = command_len - strlen("exec ");
4868
4869                base_offset += command_len + 1;
4870        }
4871
4872        /*
4873         * Insert <commands> after every pick. Here, fixup/squash chains
4874         * are considered part of the pick, so we insert the commands *after*
4875         * those chains if there are any.
4876         *
4877         * As we insert the exec commands immediatly after rearranging
4878         * any fixups and before the user edits the list, a fixup chain
4879         * can never contain comments (any comments are empty picks that
4880         * have been commented out because the user did not specify
4881         * --keep-empty).  So, it is safe to insert an exec command
4882         * without looking at the command following a comment.
4883         */
4884        insert = 0;
4885        for (i = 0; i < todo_list->nr; i++) {
4886                enum todo_command command = todo_list->items[i].command;
4887                if (insert && !is_fixup(command)) {
4888                        ALLOC_GROW(items, nr + commands->nr, alloc);
4889                        COPY_ARRAY(items + nr, base_items, commands->nr);
4890                        nr += commands->nr;
4891
4892                        insert = 0;
4893                }
4894
4895                ALLOC_GROW(items, nr + 1, alloc);
4896                items[nr++] = todo_list->items[i];
4897
4898                if (command == TODO_PICK || command == TODO_MERGE)
4899                        insert = 1;
4900        }
4901
4902        /* insert or append final <commands> */
4903        if (insert || nr == todo_list->nr) {
4904                ALLOC_GROW(items, nr + commands->nr, alloc);
4905                COPY_ARRAY(items + nr, base_items, commands->nr);
4906                nr += commands->nr;
4907        }
4908
4909        free(base_items);
4910        FREE_AND_NULL(todo_list->items);
4911        todo_list->items = items;
4912        todo_list->nr = nr;
4913        todo_list->alloc = alloc;
4914}
4915
4916static void todo_list_to_strbuf(struct repository *r, struct todo_list *todo_list,
4917                                struct strbuf *buf, int num, unsigned flags)
4918{
4919        struct todo_item *item;
4920        int i, max = todo_list->nr;
4921
4922        if (num > 0 && num < max)
4923                max = num;
4924
4925        for (item = todo_list->items, i = 0; i < max; i++, item++) {
4926                /* if the item is not a command write it and continue */
4927                if (item->command >= TODO_COMMENT) {
4928                        strbuf_addf(buf, "%.*s\n", item->arg_len,
4929                                    todo_item_get_arg(todo_list, item));
4930                        continue;
4931                }
4932
4933                /* add command to the buffer */
4934                if (flags & TODO_LIST_ABBREVIATE_CMDS)
4935                        strbuf_addch(buf, command_to_char(item->command));
4936                else
4937                        strbuf_addstr(buf, command_to_string(item->command));
4938
4939                /* add commit id */
4940                if (item->commit) {
4941                        const char *oid = flags & TODO_LIST_SHORTEN_IDS ?
4942                                          short_commit_name(item->commit) :
4943                                          oid_to_hex(&item->commit->object.oid);
4944
4945                        if (item->command == TODO_MERGE) {
4946                                if (item->flags & TODO_EDIT_MERGE_MSG)
4947                                        strbuf_addstr(buf, " -c");
4948                                else
4949                                        strbuf_addstr(buf, " -C");
4950                        }
4951
4952                        strbuf_addf(buf, " %s", oid);
4953                }
4954
4955                /* add all the rest */
4956                if (!item->arg_len)
4957                        strbuf_addch(buf, '\n');
4958                else
4959                        strbuf_addf(buf, " %.*s\n", item->arg_len,
4960                                    todo_item_get_arg(todo_list, item));
4961        }
4962}
4963
4964int todo_list_write_to_file(struct repository *r, struct todo_list *todo_list,
4965                            const char *file, const char *shortrevisions,
4966                            const char *shortonto, int num, unsigned flags)
4967{
4968        int res;
4969        struct strbuf buf = STRBUF_INIT;
4970
4971        todo_list_to_strbuf(r, todo_list, &buf, num, flags);
4972        if (flags & TODO_LIST_APPEND_TODO_HELP)
4973                append_todo_help(flags & TODO_LIST_KEEP_EMPTY, count_commands(todo_list),
4974                                 shortrevisions, shortonto, &buf);
4975
4976        res = write_message(buf.buf, buf.len, file, 0);
4977        strbuf_release(&buf);
4978
4979        return res;
4980}
4981
4982static const char edit_todo_list_advice[] =
4983N_("You can fix this with 'git rebase --edit-todo' "
4984"and then run 'git rebase --continue'.\n"
4985"Or you can abort the rebase with 'git rebase"
4986" --abort'.\n");
4987
4988int check_todo_list_from_file(struct repository *r)
4989{
4990        struct todo_list old_todo = TODO_LIST_INIT, new_todo = TODO_LIST_INIT;
4991        int res = 0;
4992
4993        if (strbuf_read_file_or_whine(&new_todo.buf, rebase_path_todo()) < 0) {
4994                res = -1;
4995                goto out;
4996        }
4997
4998        if (strbuf_read_file_or_whine(&old_todo.buf, rebase_path_todo_backup()) < 0) {
4999                res = -1;
5000                goto out;
5001        }
5002
5003        res = todo_list_parse_insn_buffer(r, old_todo.buf.buf, &old_todo);
5004        if (!res)
5005                res = todo_list_parse_insn_buffer(r, new_todo.buf.buf, &new_todo);
5006        if (!res)
5007                res = todo_list_check(&old_todo, &new_todo);
5008        if (res)
5009                fprintf(stderr, _(edit_todo_list_advice));
5010out:
5011        todo_list_release(&old_todo);
5012        todo_list_release(&new_todo);
5013
5014        return res;
5015}
5016
5017/* skip picking commits whose parents are unchanged */
5018static int skip_unnecessary_picks(struct repository *r,
5019                                  struct todo_list *todo_list,
5020                                  struct object_id *base_oid)
5021{
5022        struct object_id *parent_oid;
5023        int i;
5024
5025        for (i = 0; i < todo_list->nr; i++) {
5026                struct todo_item *item = todo_list->items + i;
5027
5028                if (item->command >= TODO_NOOP)
5029                        continue;
5030                if (item->command != TODO_PICK)
5031                        break;
5032                if (parse_commit(item->commit)) {
5033                        return error(_("could not parse commit '%s'"),
5034                                oid_to_hex(&item->commit->object.oid));
5035                }
5036                if (!item->commit->parents)
5037                        break; /* root commit */
5038                if (item->commit->parents->next)
5039                        break; /* merge commit */
5040                parent_oid = &item->commit->parents->item->object.oid;
5041                if (!oideq(parent_oid, base_oid))
5042                        break;
5043                oidcpy(base_oid, &item->commit->object.oid);
5044        }
5045        if (i > 0) {
5046                const char *done_path = rebase_path_done();
5047
5048                if (todo_list_write_to_file(r, todo_list, done_path, NULL, NULL, i, 0)) {
5049                        error_errno(_("could not write to '%s'"), done_path);
5050                        return -1;
5051                }
5052
5053                MOVE_ARRAY(todo_list->items, todo_list->items + i, todo_list->nr - i);
5054                todo_list->nr -= i;
5055                todo_list->current = 0;
5056
5057                if (is_fixup(peek_command(todo_list, 0)))
5058                        record_in_rewritten(base_oid, peek_command(todo_list, 0));
5059        }
5060
5061        return 0;
5062}
5063
5064int complete_action(struct repository *r, struct replay_opts *opts, unsigned flags,
5065                    const char *shortrevisions, const char *onto_name,
5066                    struct commit *onto, const char *orig_head,
5067                    struct string_list *commands, unsigned autosquash,
5068                    struct todo_list *todo_list)
5069{
5070        const char *shortonto, *todo_file = rebase_path_todo();
5071        struct todo_list new_todo = TODO_LIST_INIT;
5072        struct strbuf *buf = &todo_list->buf;
5073        struct object_id oid = onto->object.oid;
5074        int res;
5075
5076        shortonto = find_unique_abbrev(&oid, DEFAULT_ABBREV);
5077
5078        if (buf->len == 0) {
5079                struct todo_item *item = append_new_todo(todo_list);
5080                item->command = TODO_NOOP;
5081                item->commit = NULL;
5082                item->arg_len = item->arg_offset = item->flags = item->offset_in_buf = 0;
5083        }
5084
5085        if (autosquash && todo_list_rearrange_squash(todo_list))
5086                return -1;
5087
5088        if (commands->nr)
5089                todo_list_add_exec_commands(todo_list, commands);
5090
5091        if (count_commands(todo_list) == 0) {
5092                apply_autostash(opts);
5093                sequencer_remove_state(opts);
5094
5095                return error(_("nothing to do"));
5096        }
5097
5098        res = edit_todo_list(r, todo_list, &new_todo, shortrevisions,
5099                             shortonto, flags);
5100        if (res == -1)
5101                return -1;
5102        else if (res == -2) {
5103                apply_autostash(opts);
5104                sequencer_remove_state(opts);
5105
5106                return -1;
5107        } else if (res == -3) {
5108                apply_autostash(opts);
5109                sequencer_remove_state(opts);
5110                todo_list_release(&new_todo);
5111
5112                return error(_("nothing to do"));
5113        }
5114
5115        if (todo_list_parse_insn_buffer(r, new_todo.buf.buf, &new_todo) ||
5116            todo_list_check(todo_list, &new_todo)) {
5117                fprintf(stderr, _(edit_todo_list_advice));
5118                checkout_onto(r, opts, onto_name, &onto->object.oid, orig_head);
5119                todo_list_release(&new_todo);
5120
5121                return -1;
5122        }
5123
5124        if (opts->allow_ff && skip_unnecessary_picks(r, &new_todo, &oid)) {
5125                todo_list_release(&new_todo);
5126                return error(_("could not skip unnecessary pick commands"));
5127        }
5128
5129        if (todo_list_write_to_file(r, &new_todo, todo_file, NULL, NULL, -1,
5130                                    flags & ~(TODO_LIST_SHORTEN_IDS))) {
5131                todo_list_release(&new_todo);
5132                return error_errno(_("could not write '%s'"), todo_file);
5133        }
5134
5135        todo_list_release(&new_todo);
5136
5137        if (checkout_onto(r, opts, onto_name, &oid, orig_head))
5138                return -1;
5139
5140        if (require_clean_work_tree(r, "rebase", "", 1, 1))
5141                return -1;
5142
5143        return sequencer_continue(r, opts);
5144}
5145
5146struct subject2item_entry {
5147        struct hashmap_entry entry;
5148        int i;
5149        char subject[FLEX_ARRAY];
5150};
5151
5152static int subject2item_cmp(const void *fndata,
5153                            const struct subject2item_entry *a,
5154                            const struct subject2item_entry *b, const void *key)
5155{
5156        return key ? strcmp(a->subject, key) : strcmp(a->subject, b->subject);
5157}
5158
5159define_commit_slab(commit_todo_item, struct todo_item *);
5160
5161/*
5162 * Rearrange the todo list that has both "pick commit-id msg" and "pick
5163 * commit-id fixup!/squash! msg" in it so that the latter is put immediately
5164 * after the former, and change "pick" to "fixup"/"squash".
5165 *
5166 * Note that if the config has specified a custom instruction format, each log
5167 * message will have to be retrieved from the commit (as the oneline in the
5168 * script cannot be trusted) in order to normalize the autosquash arrangement.
5169 */
5170int todo_list_rearrange_squash(struct todo_list *todo_list)
5171{
5172        struct hashmap subject2item;
5173        int rearranged = 0, *next, *tail, i, nr = 0, alloc = 0;
5174        char **subjects;
5175        struct commit_todo_item commit_todo;
5176        struct todo_item *items = NULL;
5177
5178        init_commit_todo_item(&commit_todo);
5179        /*
5180         * The hashmap maps onelines to the respective todo list index.
5181         *
5182         * If any items need to be rearranged, the next[i] value will indicate
5183         * which item was moved directly after the i'th.
5184         *
5185         * In that case, last[i] will indicate the index of the latest item to
5186         * be moved to appear after the i'th.
5187         */
5188        hashmap_init(&subject2item, (hashmap_cmp_fn) subject2item_cmp,
5189                     NULL, todo_list->nr);
5190        ALLOC_ARRAY(next, todo_list->nr);
5191        ALLOC_ARRAY(tail, todo_list->nr);
5192        ALLOC_ARRAY(subjects, todo_list->nr);
5193        for (i = 0; i < todo_list->nr; i++) {
5194                struct strbuf buf = STRBUF_INIT;
5195                struct todo_item *item = todo_list->items + i;
5196                const char *commit_buffer, *subject, *p;
5197                size_t subject_len;
5198                int i2 = -1;
5199                struct subject2item_entry *entry;
5200
5201                next[i] = tail[i] = -1;
5202                if (!item->commit || item->command == TODO_DROP) {
5203                        subjects[i] = NULL;
5204                        continue;
5205                }
5206
5207                if (is_fixup(item->command)) {
5208                        clear_commit_todo_item(&commit_todo);
5209                        return error(_("the script was already rearranged."));
5210                }
5211
5212                *commit_todo_item_at(&commit_todo, item->commit) = item;
5213
5214                parse_commit(item->commit);
5215                commit_buffer = get_commit_buffer(item->commit, NULL);
5216                find_commit_subject(commit_buffer, &subject);
5217                format_subject(&buf, subject, " ");
5218                subject = subjects[i] = strbuf_detach(&buf, &subject_len);
5219                unuse_commit_buffer(item->commit, commit_buffer);
5220                if ((skip_prefix(subject, "fixup! ", &p) ||
5221                     skip_prefix(subject, "squash! ", &p))) {
5222                        struct commit *commit2;
5223
5224                        for (;;) {
5225                                while (isspace(*p))
5226                                        p++;
5227                                if (!skip_prefix(p, "fixup! ", &p) &&
5228                                    !skip_prefix(p, "squash! ", &p))
5229                                        break;
5230                        }
5231
5232                        if ((entry = hashmap_get_from_hash(&subject2item,
5233                                                           strhash(p), p)))
5234                                /* found by title */
5235                                i2 = entry->i;
5236                        else if (!strchr(p, ' ') &&
5237                                 (commit2 =
5238                                  lookup_commit_reference_by_name(p)) &&
5239                                 *commit_todo_item_at(&commit_todo, commit2))
5240                                /* found by commit name */
5241                                i2 = *commit_todo_item_at(&commit_todo, commit2)
5242                                        - todo_list->items;
5243                        else {
5244                                /* copy can be a prefix of the commit subject */
5245                                for (i2 = 0; i2 < i; i2++)
5246                                        if (subjects[i2] &&
5247                                            starts_with(subjects[i2], p))
5248                                                break;
5249                                if (i2 == i)
5250                                        i2 = -1;
5251                        }
5252                }
5253                if (i2 >= 0) {
5254                        rearranged = 1;
5255                        todo_list->items[i].command =
5256                                starts_with(subject, "fixup!") ?
5257                                TODO_FIXUP : TODO_SQUASH;
5258                        if (next[i2] < 0)
5259                                next[i2] = i;
5260                        else
5261                                next[tail[i2]] = i;
5262                        tail[i2] = i;
5263                } else if (!hashmap_get_from_hash(&subject2item,
5264                                                strhash(subject), subject)) {
5265                        FLEX_ALLOC_MEM(entry, subject, subject, subject_len);
5266                        entry->i = i;
5267                        hashmap_entry_init(entry, strhash(entry->subject));
5268                        hashmap_put(&subject2item, entry);
5269                }
5270        }
5271
5272        if (rearranged) {
5273                for (i = 0; i < todo_list->nr; i++) {
5274                        enum todo_command command = todo_list->items[i].command;
5275                        int cur = i;
5276
5277                        /*
5278                         * Initially, all commands are 'pick's. If it is a
5279                         * fixup or a squash now, we have rearranged it.
5280                         */
5281                        if (is_fixup(command))
5282                                continue;
5283
5284                        while (cur >= 0) {
5285                                ALLOC_GROW(items, nr + 1, alloc);
5286                                items[nr++] = todo_list->items[cur];
5287                                cur = next[cur];
5288                        }
5289                }
5290
5291                FREE_AND_NULL(todo_list->items);
5292                todo_list->items = items;
5293                todo_list->nr = nr;
5294                todo_list->alloc = alloc;
5295        }
5296
5297        free(next);
5298        free(tail);
5299        for (i = 0; i < todo_list->nr; i++)
5300                free(subjects[i]);
5301        free(subjects);
5302        hashmap_free(&subject2item, 1);
5303
5304        clear_commit_todo_item(&commit_todo);
5305
5306        return 0;
5307}