sequencer.con commit Merge branch 'es/local-atomic-push-failure-with-http' (f87ee7f)
   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        struct merge_options o;
3368        int merge_arg_len, oneline_offset, can_fast_forward, ret, k;
3369        static struct lock_file lock;
3370        const char *p;
3371
3372        if (repo_hold_locked_index(r, &lock, LOCK_REPORT_ON_ERROR) < 0) {
3373                ret = -1;
3374                goto leave_merge;
3375        }
3376
3377        head_commit = lookup_commit_reference_by_name("HEAD");
3378        if (!head_commit) {
3379                ret = error(_("cannot merge without a current revision"));
3380                goto leave_merge;
3381        }
3382
3383        /*
3384         * For octopus merges, the arg starts with the list of revisions to be
3385         * merged. The list is optionally followed by '#' and the oneline.
3386         */
3387        merge_arg_len = oneline_offset = arg_len;
3388        for (p = arg; p - arg < arg_len; p += strspn(p, " \t\n")) {
3389                if (!*p)
3390                        break;
3391                if (*p == '#' && (!p[1] || isspace(p[1]))) {
3392                        p += 1 + strspn(p + 1, " \t\n");
3393                        oneline_offset = p - arg;
3394                        break;
3395                }
3396                k = strcspn(p, " \t\n");
3397                if (!k)
3398                        continue;
3399                merge_commit = lookup_label(p, k, &ref_name);
3400                if (!merge_commit) {
3401                        ret = error(_("unable to parse '%.*s'"), k, p);
3402                        goto leave_merge;
3403                }
3404                tail = &commit_list_insert(merge_commit, tail)->next;
3405                p += k;
3406                merge_arg_len = p - arg;
3407        }
3408
3409        if (!to_merge) {
3410                ret = error(_("nothing to merge: '%.*s'"), arg_len, arg);
3411                goto leave_merge;
3412        }
3413
3414        if (opts->have_squash_onto &&
3415            oideq(&head_commit->object.oid, &opts->squash_onto)) {
3416                /*
3417                 * When the user tells us to "merge" something into a
3418                 * "[new root]", let's simply fast-forward to the merge head.
3419                 */
3420                rollback_lock_file(&lock);
3421                if (to_merge->next)
3422                        ret = error(_("octopus merge cannot be executed on "
3423                                      "top of a [new root]"));
3424                else
3425                        ret = fast_forward_to(r, &to_merge->item->object.oid,
3426                                              &head_commit->object.oid, 0,
3427                                              opts);
3428                goto leave_merge;
3429        }
3430
3431        if (commit) {
3432                const char *message = get_commit_buffer(commit, NULL);
3433                const char *body;
3434                int len;
3435
3436                if (!message) {
3437                        ret = error(_("could not get commit message of '%s'"),
3438                                    oid_to_hex(&commit->object.oid));
3439                        goto leave_merge;
3440                }
3441                write_author_script(message);
3442                find_commit_subject(message, &body);
3443                len = strlen(body);
3444                ret = write_message(body, len, git_path_merge_msg(r), 0);
3445                unuse_commit_buffer(commit, message);
3446                if (ret) {
3447                        error_errno(_("could not write '%s'"),
3448                                    git_path_merge_msg(r));
3449                        goto leave_merge;
3450                }
3451        } else {
3452                struct strbuf buf = STRBUF_INIT;
3453                int len;
3454
3455                strbuf_addf(&buf, "author %s", git_author_info(0));
3456                write_author_script(buf.buf);
3457                strbuf_reset(&buf);
3458
3459                if (oneline_offset < arg_len) {
3460                        p = arg + oneline_offset;
3461                        len = arg_len - oneline_offset;
3462                } else {
3463                        strbuf_addf(&buf, "Merge %s '%.*s'",
3464                                    to_merge->next ? "branches" : "branch",
3465                                    merge_arg_len, arg);
3466                        p = buf.buf;
3467                        len = buf.len;
3468                }
3469
3470                ret = write_message(p, len, git_path_merge_msg(r), 0);
3471                strbuf_release(&buf);
3472                if (ret) {
3473                        error_errno(_("could not write '%s'"),
3474                                    git_path_merge_msg(r));
3475                        goto leave_merge;
3476                }
3477        }
3478
3479        /*
3480         * If HEAD is not identical to the first parent of the original merge
3481         * commit, we cannot fast-forward.
3482         */
3483        can_fast_forward = opts->allow_ff && commit && commit->parents &&
3484                oideq(&commit->parents->item->object.oid,
3485                      &head_commit->object.oid);
3486
3487        /*
3488         * If any merge head is different from the original one, we cannot
3489         * fast-forward.
3490         */
3491        if (can_fast_forward) {
3492                struct commit_list *p = commit->parents->next;
3493
3494                for (j = to_merge; j && p; j = j->next, p = p->next)
3495                        if (!oideq(&j->item->object.oid,
3496                                   &p->item->object.oid)) {
3497                                can_fast_forward = 0;
3498                                break;
3499                        }
3500                /*
3501                 * If the number of merge heads differs from the original merge
3502                 * commit, we cannot fast-forward.
3503                 */
3504                if (j || p)
3505                        can_fast_forward = 0;
3506        }
3507
3508        if (can_fast_forward) {
3509                rollback_lock_file(&lock);
3510                ret = fast_forward_to(r, &commit->object.oid,
3511                                      &head_commit->object.oid, 0, opts);
3512                if (flags & TODO_EDIT_MERGE_MSG) {
3513                        run_commit_flags |= AMEND_MSG;
3514                        goto fast_forward_edit;
3515                }
3516                goto leave_merge;
3517        }
3518
3519        if (to_merge->next) {
3520                /* Octopus merge */
3521                struct child_process cmd = CHILD_PROCESS_INIT;
3522
3523                if (read_env_script(&cmd.env_array)) {
3524                        const char *gpg_opt = gpg_sign_opt_quoted(opts);
3525
3526                        ret = error(_(staged_changes_advice), gpg_opt, gpg_opt);
3527                        goto leave_merge;
3528                }
3529
3530                cmd.git_cmd = 1;
3531                argv_array_push(&cmd.args, "merge");
3532                argv_array_push(&cmd.args, "-s");
3533                argv_array_push(&cmd.args, "octopus");
3534                argv_array_push(&cmd.args, "--no-edit");
3535                argv_array_push(&cmd.args, "--no-ff");
3536                argv_array_push(&cmd.args, "--no-log");
3537                argv_array_push(&cmd.args, "--no-stat");
3538                argv_array_push(&cmd.args, "-F");
3539                argv_array_push(&cmd.args, git_path_merge_msg(r));
3540                if (opts->gpg_sign)
3541                        argv_array_push(&cmd.args, opts->gpg_sign);
3542
3543                /* Add the tips to be merged */
3544                for (j = to_merge; j; j = j->next)
3545                        argv_array_push(&cmd.args,
3546                                        oid_to_hex(&j->item->object.oid));
3547
3548                strbuf_release(&ref_name);
3549                unlink(git_path_cherry_pick_head(r));
3550                rollback_lock_file(&lock);
3551
3552                rollback_lock_file(&lock);
3553                ret = run_command(&cmd);
3554
3555                /* force re-reading of the cache */
3556                if (!ret && (discard_index(r->index) < 0 ||
3557                             repo_read_index(r) < 0))
3558                        ret = error(_("could not read index"));
3559                goto leave_merge;
3560        }
3561
3562        merge_commit = to_merge->item;
3563        bases = get_merge_bases(head_commit, merge_commit);
3564        if (bases && oideq(&merge_commit->object.oid,
3565                           &bases->item->object.oid)) {
3566                ret = 0;
3567                /* skip merging an ancestor of HEAD */
3568                goto leave_merge;
3569        }
3570
3571        write_message(oid_to_hex(&merge_commit->object.oid), GIT_SHA1_HEXSZ,
3572                      git_path_merge_head(r), 0);
3573        write_message("no-ff", 5, git_path_merge_mode(r), 0);
3574
3575        for (j = bases; j; j = j->next)
3576                commit_list_insert(j->item, &reversed);
3577        free_commit_list(bases);
3578
3579        repo_read_index(r);
3580        init_merge_options(&o, r);
3581        o.branch1 = "HEAD";
3582        o.branch2 = ref_name.buf;
3583        o.buffer_output = 2;
3584
3585        ret = merge_recursive(&o, head_commit, merge_commit, reversed, &i);
3586        if (ret <= 0)
3587                fputs(o.obuf.buf, stdout);
3588        strbuf_release(&o.obuf);
3589        if (ret < 0) {
3590                error(_("could not even attempt to merge '%.*s'"),
3591                      merge_arg_len, arg);
3592                goto leave_merge;
3593        }
3594        /*
3595         * The return value of merge_recursive() is 1 on clean, and 0 on
3596         * unclean merge.
3597         *
3598         * Let's reverse that, so that do_merge() returns 0 upon success and
3599         * 1 upon failed merge (keeping the return value -1 for the cases where
3600         * we will want to reschedule the `merge` command).
3601         */
3602        ret = !ret;
3603
3604        if (r->index->cache_changed &&
3605            write_locked_index(r->index, &lock, COMMIT_LOCK)) {
3606                ret = error(_("merge: Unable to write new index file"));
3607                goto leave_merge;
3608        }
3609
3610        rollback_lock_file(&lock);
3611        if (ret)
3612                repo_rerere(r, opts->allow_rerere_auto);
3613        else
3614                /*
3615                 * In case of problems, we now want to return a positive
3616                 * value (a negative one would indicate that the `merge`
3617                 * command needs to be rescheduled).
3618                 */
3619        fast_forward_edit:
3620                ret = !!run_git_commit(r, git_path_merge_msg(r), opts,
3621                                       run_commit_flags);
3622
3623leave_merge:
3624        strbuf_release(&ref_name);
3625        rollback_lock_file(&lock);
3626        free_commit_list(to_merge);
3627        return ret;
3628}
3629
3630static int is_final_fixup(struct todo_list *todo_list)
3631{
3632        int i = todo_list->current;
3633
3634        if (!is_fixup(todo_list->items[i].command))
3635                return 0;
3636
3637        while (++i < todo_list->nr)
3638                if (is_fixup(todo_list->items[i].command))
3639                        return 0;
3640                else if (!is_noop(todo_list->items[i].command))
3641                        break;
3642        return 1;
3643}
3644
3645static enum todo_command peek_command(struct todo_list *todo_list, int offset)
3646{
3647        int i;
3648
3649        for (i = todo_list->current + offset; i < todo_list->nr; i++)
3650                if (!is_noop(todo_list->items[i].command))
3651                        return todo_list->items[i].command;
3652
3653        return -1;
3654}
3655
3656static int apply_autostash(struct replay_opts *opts)
3657{
3658        struct strbuf stash_sha1 = STRBUF_INIT;
3659        struct child_process child = CHILD_PROCESS_INIT;
3660        int ret = 0;
3661
3662        if (!read_oneliner(&stash_sha1, rebase_path_autostash(), 1)) {
3663                strbuf_release(&stash_sha1);
3664                return 0;
3665        }
3666        strbuf_trim(&stash_sha1);
3667
3668        child.git_cmd = 1;
3669        child.no_stdout = 1;
3670        child.no_stderr = 1;
3671        argv_array_push(&child.args, "stash");
3672        argv_array_push(&child.args, "apply");
3673        argv_array_push(&child.args, stash_sha1.buf);
3674        if (!run_command(&child))
3675                fprintf(stderr, _("Applied autostash.\n"));
3676        else {
3677                struct child_process store = CHILD_PROCESS_INIT;
3678
3679                store.git_cmd = 1;
3680                argv_array_push(&store.args, "stash");
3681                argv_array_push(&store.args, "store");
3682                argv_array_push(&store.args, "-m");
3683                argv_array_push(&store.args, "autostash");
3684                argv_array_push(&store.args, "-q");
3685                argv_array_push(&store.args, stash_sha1.buf);
3686                if (run_command(&store))
3687                        ret = error(_("cannot store %s"), stash_sha1.buf);
3688                else
3689                        fprintf(stderr,
3690                                _("Applying autostash resulted in conflicts.\n"
3691                                  "Your changes are safe in the stash.\n"
3692                                  "You can run \"git stash pop\" or"
3693                                  " \"git stash drop\" at any time.\n"));
3694        }
3695
3696        strbuf_release(&stash_sha1);
3697        return ret;
3698}
3699
3700static const char *reflog_message(struct replay_opts *opts,
3701        const char *sub_action, const char *fmt, ...)
3702{
3703        va_list ap;
3704        static struct strbuf buf = STRBUF_INIT;
3705
3706        va_start(ap, fmt);
3707        strbuf_reset(&buf);
3708        strbuf_addstr(&buf, action_name(opts));
3709        if (sub_action)
3710                strbuf_addf(&buf, " (%s)", sub_action);
3711        if (fmt) {
3712                strbuf_addstr(&buf, ": ");
3713                strbuf_vaddf(&buf, fmt, ap);
3714        }
3715        va_end(ap);
3716
3717        return buf.buf;
3718}
3719
3720static int run_git_checkout(struct repository *r, struct replay_opts *opts,
3721                            const char *commit, const char *action)
3722{
3723        struct child_process cmd = CHILD_PROCESS_INIT;
3724        int ret;
3725
3726        cmd.git_cmd = 1;
3727
3728        argv_array_push(&cmd.args, "checkout");
3729        argv_array_push(&cmd.args, commit);
3730        argv_array_pushf(&cmd.env_array, GIT_REFLOG_ACTION "=%s", action);
3731
3732        if (opts->verbose)
3733                ret = run_command(&cmd);
3734        else
3735                ret = run_command_silent_on_success(&cmd);
3736
3737        if (!ret)
3738                discard_index(r->index);
3739
3740        return ret;
3741}
3742
3743int prepare_branch_to_be_rebased(struct repository *r, struct replay_opts *opts,
3744                                 const char *commit)
3745{
3746        const char *action;
3747
3748        if (commit && *commit) {
3749                action = reflog_message(opts, "start", "checkout %s", commit);
3750                if (run_git_checkout(r, opts, commit, action))
3751                        return error(_("could not checkout %s"), commit);
3752        }
3753
3754        return 0;
3755}
3756
3757static int checkout_onto(struct repository *r, struct replay_opts *opts,
3758                         const char *onto_name, const struct object_id *onto,
3759                         const char *orig_head)
3760{
3761        struct object_id oid;
3762        const char *action = reflog_message(opts, "start", "checkout %s", onto_name);
3763
3764        if (get_oid(orig_head, &oid))
3765                return error(_("%s: not a valid OID"), orig_head);
3766
3767        if (run_git_checkout(r, opts, oid_to_hex(onto), action)) {
3768                apply_autostash(opts);
3769                sequencer_remove_state(opts);
3770                return error(_("could not detach HEAD"));
3771        }
3772
3773        return update_ref(NULL, "ORIG_HEAD", &oid, NULL, 0, UPDATE_REFS_MSG_ON_ERR);
3774}
3775
3776static int stopped_at_head(struct repository *r)
3777{
3778        struct object_id head;
3779        struct commit *commit;
3780        struct commit_message message;
3781
3782        if (get_oid("HEAD", &head) ||
3783            !(commit = lookup_commit(r, &head)) ||
3784            parse_commit(commit) || get_message(commit, &message))
3785                fprintf(stderr, _("Stopped at HEAD\n"));
3786        else {
3787                fprintf(stderr, _("Stopped at %s\n"), message.label);
3788                free_message(commit, &message);
3789        }
3790        return 0;
3791
3792}
3793
3794static const char rescheduled_advice[] =
3795N_("Could not execute the todo command\n"
3796"\n"
3797"    %.*s"
3798"\n"
3799"It has been rescheduled; To edit the command before continuing, please\n"
3800"edit the todo list first:\n"
3801"\n"
3802"    git rebase --edit-todo\n"
3803"    git rebase --continue\n");
3804
3805static int pick_commits(struct repository *r,
3806                        struct todo_list *todo_list,
3807                        struct replay_opts *opts)
3808{
3809        int res = 0, reschedule = 0;
3810
3811        setenv(GIT_REFLOG_ACTION, action_name(opts), 0);
3812        if (opts->allow_ff)
3813                assert(!(opts->signoff || opts->no_commit ||
3814                                opts->record_origin || opts->edit));
3815        if (read_and_refresh_cache(r, opts))
3816                return -1;
3817
3818        while (todo_list->current < todo_list->nr) {
3819                struct todo_item *item = todo_list->items + todo_list->current;
3820                const char *arg = todo_item_get_arg(todo_list, item);
3821
3822                if (save_todo(todo_list, opts))
3823                        return -1;
3824                if (is_rebase_i(opts)) {
3825                        if (item->command != TODO_COMMENT) {
3826                                FILE *f = fopen(rebase_path_msgnum(), "w");
3827
3828                                todo_list->done_nr++;
3829
3830                                if (f) {
3831                                        fprintf(f, "%d\n", todo_list->done_nr);
3832                                        fclose(f);
3833                                }
3834                                if (!opts->quiet)
3835                                        fprintf(stderr, "Rebasing (%d/%d)%s",
3836                                                todo_list->done_nr,
3837                                                todo_list->total_nr,
3838                                                opts->verbose ? "\n" : "\r");
3839                        }
3840                        unlink(rebase_path_message());
3841                        unlink(rebase_path_author_script());
3842                        unlink(rebase_path_stopped_sha());
3843                        unlink(rebase_path_amend());
3844                        unlink(git_path_merge_head(r));
3845                        delete_ref(NULL, "REBASE_HEAD", NULL, REF_NO_DEREF);
3846
3847                        if (item->command == TODO_BREAK) {
3848                                if (!opts->verbose)
3849                                        term_clear_line();
3850                                return stopped_at_head(r);
3851                        }
3852                }
3853                if (item->command <= TODO_SQUASH) {
3854                        if (is_rebase_i(opts))
3855                                setenv("GIT_REFLOG_ACTION", reflog_message(opts,
3856                                        command_to_string(item->command), NULL),
3857                                        1);
3858                        res = do_pick_commit(r, item->command, item->commit,
3859                                        opts, is_final_fixup(todo_list));
3860                        if (is_rebase_i(opts) && res < 0) {
3861                                /* Reschedule */
3862                                advise(_(rescheduled_advice),
3863                                       get_item_line_length(todo_list,
3864                                                            todo_list->current),
3865                                       get_item_line(todo_list,
3866                                                     todo_list->current));
3867                                todo_list->current--;
3868                                if (save_todo(todo_list, opts))
3869                                        return -1;
3870                        }
3871                        if (item->command == TODO_EDIT) {
3872                                struct commit *commit = item->commit;
3873                                if (!res) {
3874                                        if (!opts->verbose)
3875                                                term_clear_line();
3876                                        fprintf(stderr,
3877                                                _("Stopped at %s...  %.*s\n"),
3878                                                short_commit_name(commit),
3879                                                item->arg_len, arg);
3880                                }
3881                                return error_with_patch(r, commit,
3882                                        arg, item->arg_len, opts, res, !res);
3883                        }
3884                        if (is_rebase_i(opts) && !res)
3885                                record_in_rewritten(&item->commit->object.oid,
3886                                        peek_command(todo_list, 1));
3887                        if (res && is_fixup(item->command)) {
3888                                if (res == 1)
3889                                        intend_to_amend();
3890                                return error_failed_squash(r, item->commit, opts,
3891                                        item->arg_len, arg);
3892                        } else if (res && is_rebase_i(opts) && item->commit) {
3893                                int to_amend = 0;
3894                                struct object_id oid;
3895
3896                                /*
3897                                 * If we are rewording and have either
3898                                 * fast-forwarded already, or are about to
3899                                 * create a new root commit, we want to amend,
3900                                 * otherwise we do not.
3901                                 */
3902                                if (item->command == TODO_REWORD &&
3903                                    !get_oid("HEAD", &oid) &&
3904                                    (oideq(&item->commit->object.oid, &oid) ||
3905                                     (opts->have_squash_onto &&
3906                                      oideq(&opts->squash_onto, &oid))))
3907                                        to_amend = 1;
3908
3909                                return res | error_with_patch(r, item->commit,
3910                                                arg, item->arg_len, opts,
3911                                                res, to_amend);
3912                        }
3913                } else if (item->command == TODO_EXEC) {
3914                        char *end_of_arg = (char *)(arg + item->arg_len);
3915                        int saved = *end_of_arg;
3916                        struct stat st;
3917
3918                        if (!opts->verbose)
3919                                term_clear_line();
3920                        *end_of_arg = '\0';
3921                        res = do_exec(r, arg);
3922                        *end_of_arg = saved;
3923
3924                        if (res) {
3925                                if (opts->reschedule_failed_exec)
3926                                        reschedule = 1;
3927                        } else if (stat(get_todo_path(opts), &st))
3928                                res = error_errno(_("could not stat '%s'"),
3929                                                  get_todo_path(opts));
3930                        else if (match_stat_data(&todo_list->stat, &st)) {
3931                                /* Reread the todo file if it has changed. */
3932                                todo_list_release(todo_list);
3933                                if (read_populate_todo(r, todo_list, opts))
3934                                        res = -1; /* message was printed */
3935                                /* `current` will be incremented below */
3936                                todo_list->current = -1;
3937                        }
3938                } else if (item->command == TODO_LABEL) {
3939                        if ((res = do_label(r, arg, item->arg_len)))
3940                                reschedule = 1;
3941                } else if (item->command == TODO_RESET) {
3942                        if ((res = do_reset(r, arg, item->arg_len, opts)))
3943                                reschedule = 1;
3944                } else if (item->command == TODO_MERGE) {
3945                        if ((res = do_merge(r, item->commit,
3946                                            arg, item->arg_len,
3947                                            item->flags, opts)) < 0)
3948                                reschedule = 1;
3949                        else if (item->commit)
3950                                record_in_rewritten(&item->commit->object.oid,
3951                                                    peek_command(todo_list, 1));
3952                        if (res > 0)
3953                                /* failed with merge conflicts */
3954                                return error_with_patch(r, item->commit,
3955                                                        arg, item->arg_len,
3956                                                        opts, res, 0);
3957                } else if (!is_noop(item->command))
3958                        return error(_("unknown command %d"), item->command);
3959
3960                if (reschedule) {
3961                        advise(_(rescheduled_advice),
3962                               get_item_line_length(todo_list,
3963                                                    todo_list->current),
3964                               get_item_line(todo_list, todo_list->current));
3965                        todo_list->current--;
3966                        if (save_todo(todo_list, opts))
3967                                return -1;
3968                        if (item->commit)
3969                                return error_with_patch(r,
3970                                                        item->commit,
3971                                                        arg, item->arg_len,
3972                                                        opts, res, 0);
3973                }
3974
3975                todo_list->current++;
3976                if (res)
3977                        return res;
3978        }
3979
3980        if (is_rebase_i(opts)) {
3981                struct strbuf head_ref = STRBUF_INIT, buf = STRBUF_INIT;
3982                struct stat st;
3983
3984                /* Stopped in the middle, as planned? */
3985                if (todo_list->current < todo_list->nr)
3986                        return 0;
3987
3988                if (read_oneliner(&head_ref, rebase_path_head_name(), 0) &&
3989                                starts_with(head_ref.buf, "refs/")) {
3990                        const char *msg;
3991                        struct object_id head, orig;
3992                        int res;
3993
3994                        if (get_oid("HEAD", &head)) {
3995                                res = error(_("cannot read HEAD"));
3996cleanup_head_ref:
3997                                strbuf_release(&head_ref);
3998                                strbuf_release(&buf);
3999                                return res;
4000                        }
4001                        if (!read_oneliner(&buf, rebase_path_orig_head(), 0) ||
4002                                        get_oid_hex(buf.buf, &orig)) {
4003                                res = error(_("could not read orig-head"));
4004                                goto cleanup_head_ref;
4005                        }
4006                        strbuf_reset(&buf);
4007                        if (!read_oneliner(&buf, rebase_path_onto(), 0)) {
4008                                res = error(_("could not read 'onto'"));
4009                                goto cleanup_head_ref;
4010                        }
4011                        msg = reflog_message(opts, "finish", "%s onto %s",
4012                                head_ref.buf, buf.buf);
4013                        if (update_ref(msg, head_ref.buf, &head, &orig,
4014                                       REF_NO_DEREF, UPDATE_REFS_MSG_ON_ERR)) {
4015                                res = error(_("could not update %s"),
4016                                        head_ref.buf);
4017                                goto cleanup_head_ref;
4018                        }
4019                        msg = reflog_message(opts, "finish", "returning to %s",
4020                                head_ref.buf);
4021                        if (create_symref("HEAD", head_ref.buf, msg)) {
4022                                res = error(_("could not update HEAD to %s"),
4023                                        head_ref.buf);
4024                                goto cleanup_head_ref;
4025                        }
4026                        strbuf_reset(&buf);
4027                }
4028
4029                if (opts->verbose) {
4030                        struct rev_info log_tree_opt;
4031                        struct object_id orig, head;
4032
4033                        memset(&log_tree_opt, 0, sizeof(log_tree_opt));
4034                        repo_init_revisions(r, &log_tree_opt, NULL);
4035                        log_tree_opt.diff = 1;
4036                        log_tree_opt.diffopt.output_format =
4037                                DIFF_FORMAT_DIFFSTAT;
4038                        log_tree_opt.disable_stdin = 1;
4039
4040                        if (read_oneliner(&buf, rebase_path_orig_head(), 0) &&
4041                            !get_oid(buf.buf, &orig) &&
4042                            !get_oid("HEAD", &head)) {
4043                                diff_tree_oid(&orig, &head, "",
4044                                              &log_tree_opt.diffopt);
4045                                log_tree_diff_flush(&log_tree_opt);
4046                        }
4047                }
4048                flush_rewritten_pending();
4049                if (!stat(rebase_path_rewritten_list(), &st) &&
4050                                st.st_size > 0) {
4051                        struct child_process child = CHILD_PROCESS_INIT;
4052                        const char *post_rewrite_hook =
4053                                find_hook("post-rewrite");
4054
4055                        child.in = open(rebase_path_rewritten_list(), O_RDONLY);
4056                        child.git_cmd = 1;
4057                        argv_array_push(&child.args, "notes");
4058                        argv_array_push(&child.args, "copy");
4059                        argv_array_push(&child.args, "--for-rewrite=rebase");
4060                        /* we don't care if this copying failed */
4061                        run_command(&child);
4062
4063                        if (post_rewrite_hook) {
4064                                struct child_process hook = CHILD_PROCESS_INIT;
4065
4066                                hook.in = open(rebase_path_rewritten_list(),
4067                                        O_RDONLY);
4068                                hook.stdout_to_stderr = 1;
4069                                hook.trace2_hook_name = "post-rewrite";
4070                                argv_array_push(&hook.args, post_rewrite_hook);
4071                                argv_array_push(&hook.args, "rebase");
4072                                /* we don't care if this hook failed */
4073                                run_command(&hook);
4074                        }
4075                }
4076                apply_autostash(opts);
4077
4078                if (!opts->quiet) {
4079                        if (!opts->verbose)
4080                                term_clear_line();
4081                        fprintf(stderr,
4082                                "Successfully rebased and updated %s.\n",
4083                                head_ref.buf);
4084                }
4085
4086                strbuf_release(&buf);
4087                strbuf_release(&head_ref);
4088        }
4089
4090        /*
4091         * Sequence of picks finished successfully; cleanup by
4092         * removing the .git/sequencer directory
4093         */
4094        return sequencer_remove_state(opts);
4095}
4096
4097static int continue_single_pick(struct repository *r)
4098{
4099        const char *argv[] = { "commit", NULL };
4100
4101        if (!file_exists(git_path_cherry_pick_head(r)) &&
4102            !file_exists(git_path_revert_head(r)))
4103                return error(_("no cherry-pick or revert in progress"));
4104        return run_command_v_opt(argv, RUN_GIT_CMD);
4105}
4106
4107static int commit_staged_changes(struct repository *r,
4108                                 struct replay_opts *opts,
4109                                 struct todo_list *todo_list)
4110{
4111        unsigned int flags = ALLOW_EMPTY | EDIT_MSG;
4112        unsigned int final_fixup = 0, is_clean;
4113
4114        if (has_unstaged_changes(r, 1))
4115                return error(_("cannot rebase: You have unstaged changes."));
4116
4117        is_clean = !has_uncommitted_changes(r, 0);
4118
4119        if (file_exists(rebase_path_amend())) {
4120                struct strbuf rev = STRBUF_INIT;
4121                struct object_id head, to_amend;
4122
4123                if (get_oid("HEAD", &head))
4124                        return error(_("cannot amend non-existing commit"));
4125                if (!read_oneliner(&rev, rebase_path_amend(), 0))
4126                        return error(_("invalid file: '%s'"), rebase_path_amend());
4127                if (get_oid_hex(rev.buf, &to_amend))
4128                        return error(_("invalid contents: '%s'"),
4129                                rebase_path_amend());
4130                if (!is_clean && !oideq(&head, &to_amend))
4131                        return error(_("\nYou have uncommitted changes in your "
4132                                       "working tree. Please, commit them\n"
4133                                       "first and then run 'git rebase "
4134                                       "--continue' again."));
4135                /*
4136                 * When skipping a failed fixup/squash, we need to edit the
4137                 * commit message, the current fixup list and count, and if it
4138                 * was the last fixup/squash in the chain, we need to clean up
4139                 * the commit message and if there was a squash, let the user
4140                 * edit it.
4141                 */
4142                if (!is_clean || !opts->current_fixup_count)
4143                        ; /* this is not the final fixup */
4144                else if (!oideq(&head, &to_amend) ||
4145                         !file_exists(rebase_path_stopped_sha())) {
4146                        /* was a final fixup or squash done manually? */
4147                        if (!is_fixup(peek_command(todo_list, 0))) {
4148                                unlink(rebase_path_fixup_msg());
4149                                unlink(rebase_path_squash_msg());
4150                                unlink(rebase_path_current_fixups());
4151                                strbuf_reset(&opts->current_fixups);
4152                                opts->current_fixup_count = 0;
4153                        }
4154                } else {
4155                        /* we are in a fixup/squash chain */
4156                        const char *p = opts->current_fixups.buf;
4157                        int len = opts->current_fixups.len;
4158
4159                        opts->current_fixup_count--;
4160                        if (!len)
4161                                BUG("Incorrect current_fixups:\n%s", p);
4162                        while (len && p[len - 1] != '\n')
4163                                len--;
4164                        strbuf_setlen(&opts->current_fixups, len);
4165                        if (write_message(p, len, rebase_path_current_fixups(),
4166                                          0) < 0)
4167                                return error(_("could not write file: '%s'"),
4168                                             rebase_path_current_fixups());
4169
4170                        /*
4171                         * If a fixup/squash in a fixup/squash chain failed, the
4172                         * commit message is already correct, no need to commit
4173                         * it again.
4174                         *
4175                         * Only if it is the final command in the fixup/squash
4176                         * chain, and only if the chain is longer than a single
4177                         * fixup/squash command (which was just skipped), do we
4178                         * actually need to re-commit with a cleaned up commit
4179                         * message.
4180                         */
4181                        if (opts->current_fixup_count > 0 &&
4182                            !is_fixup(peek_command(todo_list, 0))) {
4183                                final_fixup = 1;
4184                                /*
4185                                 * If there was not a single "squash" in the
4186                                 * chain, we only need to clean up the commit
4187                                 * message, no need to bother the user with
4188                                 * opening the commit message in the editor.
4189                                 */
4190                                if (!starts_with(p, "squash ") &&
4191                                    !strstr(p, "\nsquash "))
4192                                        flags = (flags & ~EDIT_MSG) | CLEANUP_MSG;
4193                        } else if (is_fixup(peek_command(todo_list, 0))) {
4194                                /*
4195                                 * We need to update the squash message to skip
4196                                 * the latest commit message.
4197                                 */
4198                                struct commit *commit;
4199                                const char *path = rebase_path_squash_msg();
4200
4201                                if (parse_head(r, &commit) ||
4202                                    !(p = get_commit_buffer(commit, NULL)) ||
4203                                    write_message(p, strlen(p), path, 0)) {
4204                                        unuse_commit_buffer(commit, p);
4205                                        return error(_("could not write file: "
4206                                                       "'%s'"), path);
4207                                }
4208                                unuse_commit_buffer(commit, p);
4209                        }
4210                }
4211
4212                strbuf_release(&rev);
4213                flags |= AMEND_MSG;
4214        }
4215
4216        if (is_clean) {
4217                const char *cherry_pick_head = git_path_cherry_pick_head(r);
4218
4219                if (file_exists(cherry_pick_head) && unlink(cherry_pick_head))
4220                        return error(_("could not remove CHERRY_PICK_HEAD"));
4221                if (!final_fixup)
4222                        return 0;
4223        }
4224
4225        if (run_git_commit(r, final_fixup ? NULL : rebase_path_message(),
4226                           opts, flags))
4227                return error(_("could not commit staged changes."));
4228        unlink(rebase_path_amend());
4229        unlink(git_path_merge_head(r));
4230        if (final_fixup) {
4231                unlink(rebase_path_fixup_msg());
4232                unlink(rebase_path_squash_msg());
4233        }
4234        if (opts->current_fixup_count > 0) {
4235                /*
4236                 * Whether final fixup or not, we just cleaned up the commit
4237                 * message...
4238                 */
4239                unlink(rebase_path_current_fixups());
4240                strbuf_reset(&opts->current_fixups);
4241                opts->current_fixup_count = 0;
4242        }
4243        return 0;
4244}
4245
4246int sequencer_continue(struct repository *r, struct replay_opts *opts)
4247{
4248        struct todo_list todo_list = TODO_LIST_INIT;
4249        int res;
4250
4251        if (read_and_refresh_cache(r, opts))
4252                return -1;
4253
4254        if (read_populate_opts(opts))
4255                return -1;
4256        if (is_rebase_i(opts)) {
4257                if ((res = read_populate_todo(r, &todo_list, opts)))
4258                        goto release_todo_list;
4259                if (commit_staged_changes(r, opts, &todo_list))
4260                        return -1;
4261        } else if (!file_exists(get_todo_path(opts)))
4262                return continue_single_pick(r);
4263        else if ((res = read_populate_todo(r, &todo_list, opts)))
4264                goto release_todo_list;
4265
4266        if (!is_rebase_i(opts)) {
4267                /* Verify that the conflict has been resolved */
4268                if (file_exists(git_path_cherry_pick_head(r)) ||
4269                    file_exists(git_path_revert_head(r))) {
4270                        res = continue_single_pick(r);
4271                        if (res)
4272                                goto release_todo_list;
4273                }
4274                if (index_differs_from(r, "HEAD", NULL, 0)) {
4275                        res = error_dirty_index(r, opts);
4276                        goto release_todo_list;
4277                }
4278                todo_list.current++;
4279        } else if (file_exists(rebase_path_stopped_sha())) {
4280                struct strbuf buf = STRBUF_INIT;
4281                struct object_id oid;
4282
4283                if (read_oneliner(&buf, rebase_path_stopped_sha(), 1) &&
4284                    !get_oid_committish(buf.buf, &oid))
4285                        record_in_rewritten(&oid, peek_command(&todo_list, 0));
4286                strbuf_release(&buf);
4287        }
4288
4289        res = pick_commits(r, &todo_list, opts);
4290release_todo_list:
4291        todo_list_release(&todo_list);
4292        return res;
4293}
4294
4295static int single_pick(struct repository *r,
4296                       struct commit *cmit,
4297                       struct replay_opts *opts)
4298{
4299        setenv(GIT_REFLOG_ACTION, action_name(opts), 0);
4300        return do_pick_commit(r, opts->action == REPLAY_PICK ?
4301                TODO_PICK : TODO_REVERT, cmit, opts, 0);
4302}
4303
4304int sequencer_pick_revisions(struct repository *r,
4305                             struct replay_opts *opts)
4306{
4307        struct todo_list todo_list = TODO_LIST_INIT;
4308        struct object_id oid;
4309        int i, res;
4310
4311        assert(opts->revs);
4312        if (read_and_refresh_cache(r, opts))
4313                return -1;
4314
4315        for (i = 0; i < opts->revs->pending.nr; i++) {
4316                struct object_id oid;
4317                const char *name = opts->revs->pending.objects[i].name;
4318
4319                /* This happens when using --stdin. */
4320                if (!strlen(name))
4321                        continue;
4322
4323                if (!get_oid(name, &oid)) {
4324                        if (!lookup_commit_reference_gently(r, &oid, 1)) {
4325                                enum object_type type = oid_object_info(r,
4326                                                                        &oid,
4327                                                                        NULL);
4328                                return error(_("%s: can't cherry-pick a %s"),
4329                                        name, type_name(type));
4330                        }
4331                } else
4332                        return error(_("%s: bad revision"), name);
4333        }
4334
4335        /*
4336         * If we were called as "git cherry-pick <commit>", just
4337         * cherry-pick/revert it, set CHERRY_PICK_HEAD /
4338         * REVERT_HEAD, and don't touch the sequencer state.
4339         * This means it is possible to cherry-pick in the middle
4340         * of a cherry-pick sequence.
4341         */
4342        if (opts->revs->cmdline.nr == 1 &&
4343            opts->revs->cmdline.rev->whence == REV_CMD_REV &&
4344            opts->revs->no_walk &&
4345            !opts->revs->cmdline.rev->flags) {
4346                struct commit *cmit;
4347                if (prepare_revision_walk(opts->revs))
4348                        return error(_("revision walk setup failed"));
4349                cmit = get_revision(opts->revs);
4350                if (!cmit)
4351                        return error(_("empty commit set passed"));
4352                if (get_revision(opts->revs))
4353                        BUG("unexpected extra commit from walk");
4354                return single_pick(r, cmit, opts);
4355        }
4356
4357        /*
4358         * Start a new cherry-pick/ revert sequence; but
4359         * first, make sure that an existing one isn't in
4360         * progress
4361         */
4362
4363        if (walk_revs_populate_todo(&todo_list, opts) ||
4364                        create_seq_dir(r) < 0)
4365                return -1;
4366        if (get_oid("HEAD", &oid) && (opts->action == REPLAY_REVERT))
4367                return error(_("can't revert as initial commit"));
4368        if (save_head(oid_to_hex(&oid)))
4369                return -1;
4370        if (save_opts(opts))
4371                return -1;
4372        update_abort_safety_file();
4373        res = pick_commits(r, &todo_list, opts);
4374        todo_list_release(&todo_list);
4375        return res;
4376}
4377
4378void append_signoff(struct strbuf *msgbuf, size_t ignore_footer, unsigned flag)
4379{
4380        unsigned no_dup_sob = flag & APPEND_SIGNOFF_DEDUP;
4381        struct strbuf sob = STRBUF_INIT;
4382        int has_footer;
4383
4384        strbuf_addstr(&sob, sign_off_header);
4385        strbuf_addstr(&sob, fmt_name(WANT_COMMITTER_IDENT));
4386        strbuf_addch(&sob, '\n');
4387
4388        if (!ignore_footer)
4389                strbuf_complete_line(msgbuf);
4390
4391        /*
4392         * If the whole message buffer is equal to the sob, pretend that we
4393         * found a conforming footer with a matching sob
4394         */
4395        if (msgbuf->len - ignore_footer == sob.len &&
4396            !strncmp(msgbuf->buf, sob.buf, sob.len))
4397                has_footer = 3;
4398        else
4399                has_footer = has_conforming_footer(msgbuf, &sob, ignore_footer);
4400
4401        if (!has_footer) {
4402                const char *append_newlines = NULL;
4403                size_t len = msgbuf->len - ignore_footer;
4404
4405                if (!len) {
4406                        /*
4407                         * The buffer is completely empty.  Leave foom for
4408                         * the title and body to be filled in by the user.
4409                         */
4410                        append_newlines = "\n\n";
4411                } else if (len == 1) {
4412                        /*
4413                         * Buffer contains a single newline.  Add another
4414                         * so that we leave room for the title and body.
4415                         */
4416                        append_newlines = "\n";
4417                } else if (msgbuf->buf[len - 2] != '\n') {
4418                        /*
4419                         * Buffer ends with a single newline.  Add another
4420                         * so that there is an empty line between the message
4421                         * body and the sob.
4422                         */
4423                        append_newlines = "\n";
4424                } /* else, the buffer already ends with two newlines. */
4425
4426                if (append_newlines)
4427                        strbuf_splice(msgbuf, msgbuf->len - ignore_footer, 0,
4428                                append_newlines, strlen(append_newlines));
4429        }
4430
4431        if (has_footer != 3 && (!no_dup_sob || has_footer != 2))
4432                strbuf_splice(msgbuf, msgbuf->len - ignore_footer, 0,
4433                                sob.buf, sob.len);
4434
4435        strbuf_release(&sob);
4436}
4437
4438struct labels_entry {
4439        struct hashmap_entry entry;
4440        char label[FLEX_ARRAY];
4441};
4442
4443static int labels_cmp(const void *fndata, const struct labels_entry *a,
4444                      const struct labels_entry *b, const void *key)
4445{
4446        return key ? strcmp(a->label, key) : strcmp(a->label, b->label);
4447}
4448
4449struct string_entry {
4450        struct oidmap_entry entry;
4451        char string[FLEX_ARRAY];
4452};
4453
4454struct label_state {
4455        struct oidmap commit2label;
4456        struct hashmap labels;
4457        struct strbuf buf;
4458};
4459
4460static const char *label_oid(struct object_id *oid, const char *label,
4461                             struct label_state *state)
4462{
4463        struct labels_entry *labels_entry;
4464        struct string_entry *string_entry;
4465        struct object_id dummy;
4466        size_t len;
4467        int i;
4468
4469        string_entry = oidmap_get(&state->commit2label, oid);
4470        if (string_entry)
4471                return string_entry->string;
4472
4473        /*
4474         * For "uninteresting" commits, i.e. commits that are not to be
4475         * rebased, and which can therefore not be labeled, we use a unique
4476         * abbreviation of the commit name. This is slightly more complicated
4477         * than calling find_unique_abbrev() because we also need to make
4478         * sure that the abbreviation does not conflict with any other
4479         * label.
4480         *
4481         * We disallow "interesting" commits to be labeled by a string that
4482         * is a valid full-length hash, to ensure that we always can find an
4483         * abbreviation for any uninteresting commit's names that does not
4484         * clash with any other label.
4485         */
4486        if (!label) {
4487                char *p;
4488
4489                strbuf_reset(&state->buf);
4490                strbuf_grow(&state->buf, GIT_SHA1_HEXSZ);
4491                label = p = state->buf.buf;
4492
4493                find_unique_abbrev_r(p, oid, default_abbrev);
4494
4495                /*
4496                 * We may need to extend the abbreviated hash so that there is
4497                 * no conflicting label.
4498                 */
4499                if (hashmap_get_from_hash(&state->labels, strihash(p), p)) {
4500                        size_t i = strlen(p) + 1;
4501
4502                        oid_to_hex_r(p, oid);
4503                        for (; i < GIT_SHA1_HEXSZ; i++) {
4504                                char save = p[i];
4505                                p[i] = '\0';
4506                                if (!hashmap_get_from_hash(&state->labels,
4507                                                           strihash(p), p))
4508                                        break;
4509                                p[i] = save;
4510                        }
4511                }
4512        } else if (((len = strlen(label)) == the_hash_algo->hexsz &&
4513                    !get_oid_hex(label, &dummy)) ||
4514                   (len == 1 && *label == '#') ||
4515                   hashmap_get_from_hash(&state->labels,
4516                                         strihash(label), label)) {
4517                /*
4518                 * If the label already exists, or if the label is a valid full
4519                 * OID, or the label is a '#' (which we use as a separator
4520                 * between merge heads and oneline), we append a dash and a
4521                 * number to make it unique.
4522                 */
4523                struct strbuf *buf = &state->buf;
4524
4525                strbuf_reset(buf);
4526                strbuf_add(buf, label, len);
4527
4528                for (i = 2; ; i++) {
4529                        strbuf_setlen(buf, len);
4530                        strbuf_addf(buf, "-%d", i);
4531                        if (!hashmap_get_from_hash(&state->labels,
4532                                                   strihash(buf->buf),
4533                                                   buf->buf))
4534                                break;
4535                }
4536
4537                label = buf->buf;
4538        }
4539
4540        FLEX_ALLOC_STR(labels_entry, label, label);
4541        hashmap_entry_init(labels_entry, strihash(label));
4542        hashmap_add(&state->labels, labels_entry);
4543
4544        FLEX_ALLOC_STR(string_entry, string, label);
4545        oidcpy(&string_entry->entry.oid, oid);
4546        oidmap_put(&state->commit2label, string_entry);
4547
4548        return string_entry->string;
4549}
4550
4551static int make_script_with_merges(struct pretty_print_context *pp,
4552                                   struct rev_info *revs, struct strbuf *out,
4553                                   unsigned flags)
4554{
4555        int keep_empty = flags & TODO_LIST_KEEP_EMPTY;
4556        int rebase_cousins = flags & TODO_LIST_REBASE_COUSINS;
4557        struct strbuf buf = STRBUF_INIT, oneline = STRBUF_INIT;
4558        struct strbuf label = STRBUF_INIT;
4559        struct commit_list *commits = NULL, **tail = &commits, *iter;
4560        struct commit_list *tips = NULL, **tips_tail = &tips;
4561        struct commit *commit;
4562        struct oidmap commit2todo = OIDMAP_INIT;
4563        struct string_entry *entry;
4564        struct oidset interesting = OIDSET_INIT, child_seen = OIDSET_INIT,
4565                shown = OIDSET_INIT;
4566        struct label_state state = { OIDMAP_INIT, { NULL }, STRBUF_INIT };
4567
4568        int abbr = flags & TODO_LIST_ABBREVIATE_CMDS;
4569        const char *cmd_pick = abbr ? "p" : "pick",
4570                *cmd_label = abbr ? "l" : "label",
4571                *cmd_reset = abbr ? "t" : "reset",
4572                *cmd_merge = abbr ? "m" : "merge";
4573
4574        oidmap_init(&commit2todo, 0);
4575        oidmap_init(&state.commit2label, 0);
4576        hashmap_init(&state.labels, (hashmap_cmp_fn) labels_cmp, NULL, 0);
4577        strbuf_init(&state.buf, 32);
4578
4579        if (revs->cmdline.nr && (revs->cmdline.rev[0].flags & BOTTOM)) {
4580                struct object_id *oid = &revs->cmdline.rev[0].item->oid;
4581                FLEX_ALLOC_STR(entry, string, "onto");
4582                oidcpy(&entry->entry.oid, oid);
4583                oidmap_put(&state.commit2label, entry);
4584        }
4585
4586        /*
4587         * First phase:
4588         * - get onelines for all commits
4589         * - gather all branch tips (i.e. 2nd or later parents of merges)
4590         * - label all branch tips
4591         */
4592        while ((commit = get_revision(revs))) {
4593                struct commit_list *to_merge;
4594                const char *p1, *p2;
4595                struct object_id *oid;
4596                int is_empty;
4597
4598                tail = &commit_list_insert(commit, tail)->next;
4599                oidset_insert(&interesting, &commit->object.oid);
4600
4601                is_empty = is_original_commit_empty(commit);
4602                if (!is_empty && (commit->object.flags & PATCHSAME))
4603                        continue;
4604
4605                strbuf_reset(&oneline);
4606                pretty_print_commit(pp, commit, &oneline);
4607
4608                to_merge = commit->parents ? commit->parents->next : NULL;
4609                if (!to_merge) {
4610                        /* non-merge commit: easy case */
4611                        strbuf_reset(&buf);
4612                        if (!keep_empty && is_empty)
4613                                strbuf_addf(&buf, "%c ", comment_line_char);
4614                        strbuf_addf(&buf, "%s %s %s", cmd_pick,
4615                                    oid_to_hex(&commit->object.oid),
4616                                    oneline.buf);
4617
4618                        FLEX_ALLOC_STR(entry, string, buf.buf);
4619                        oidcpy(&entry->entry.oid, &commit->object.oid);
4620                        oidmap_put(&commit2todo, entry);
4621
4622                        continue;
4623                }
4624
4625                /* Create a label */
4626                strbuf_reset(&label);
4627                if (skip_prefix(oneline.buf, "Merge ", &p1) &&
4628                    (p1 = strchr(p1, '\'')) &&
4629                    (p2 = strchr(++p1, '\'')))
4630                        strbuf_add(&label, p1, p2 - p1);
4631                else if (skip_prefix(oneline.buf, "Merge pull request ",
4632                                     &p1) &&
4633                         (p1 = strstr(p1, " from ")))
4634                        strbuf_addstr(&label, p1 + strlen(" from "));
4635                else
4636                        strbuf_addbuf(&label, &oneline);
4637
4638                for (p1 = label.buf; *p1; p1++)
4639                        if (isspace(*p1))
4640                                *(char *)p1 = '-';
4641
4642                strbuf_reset(&buf);
4643                strbuf_addf(&buf, "%s -C %s",
4644                            cmd_merge, oid_to_hex(&commit->object.oid));
4645
4646                /* label the tips of merged branches */
4647                for (; to_merge; to_merge = to_merge->next) {
4648                        oid = &to_merge->item->object.oid;
4649                        strbuf_addch(&buf, ' ');
4650
4651                        if (!oidset_contains(&interesting, oid)) {
4652                                strbuf_addstr(&buf, label_oid(oid, NULL,
4653                                                              &state));
4654                                continue;
4655                        }
4656
4657                        tips_tail = &commit_list_insert(to_merge->item,
4658                                                        tips_tail)->next;
4659
4660                        strbuf_addstr(&buf, label_oid(oid, label.buf, &state));
4661                }
4662                strbuf_addf(&buf, " # %s", oneline.buf);
4663
4664                FLEX_ALLOC_STR(entry, string, buf.buf);
4665                oidcpy(&entry->entry.oid, &commit->object.oid);
4666                oidmap_put(&commit2todo, entry);
4667        }
4668
4669        /*
4670         * Second phase:
4671         * - label branch points
4672         * - add HEAD to the branch tips
4673         */
4674        for (iter = commits; iter; iter = iter->next) {
4675                struct commit_list *parent = iter->item->parents;
4676                for (; parent; parent = parent->next) {
4677                        struct object_id *oid = &parent->item->object.oid;
4678                        if (!oidset_contains(&interesting, oid))
4679                                continue;
4680                        if (oidset_insert(&child_seen, oid))
4681                                label_oid(oid, "branch-point", &state);
4682                }
4683
4684                /* Add HEAD as implict "tip of branch" */
4685                if (!iter->next)
4686                        tips_tail = &commit_list_insert(iter->item,
4687                                                        tips_tail)->next;
4688        }
4689
4690        /*
4691         * Third phase: output the todo list. This is a bit tricky, as we
4692         * want to avoid jumping back and forth between revisions. To
4693         * accomplish that goal, we walk backwards from the branch tips,
4694         * gathering commits not yet shown, reversing the list on the fly,
4695         * then outputting that list (labeling revisions as needed).
4696         */
4697        strbuf_addf(out, "%s onto\n", cmd_label);
4698        for (iter = tips; iter; iter = iter->next) {
4699                struct commit_list *list = NULL, *iter2;
4700
4701                commit = iter->item;
4702                if (oidset_contains(&shown, &commit->object.oid))
4703                        continue;
4704                entry = oidmap_get(&state.commit2label, &commit->object.oid);
4705
4706                if (entry)
4707                        strbuf_addf(out, "\n%c Branch %s\n", comment_line_char, entry->string);
4708                else
4709                        strbuf_addch(out, '\n');
4710
4711                while (oidset_contains(&interesting, &commit->object.oid) &&
4712                       !oidset_contains(&shown, &commit->object.oid)) {
4713                        commit_list_insert(commit, &list);
4714                        if (!commit->parents) {
4715                                commit = NULL;
4716                                break;
4717                        }
4718                        commit = commit->parents->item;
4719                }
4720
4721                if (!commit)
4722                        strbuf_addf(out, "%s %s\n", cmd_reset,
4723                                    rebase_cousins ? "onto" : "[new root]");
4724                else {
4725                        const char *to = NULL;
4726
4727                        entry = oidmap_get(&state.commit2label,
4728                                           &commit->object.oid);
4729                        if (entry)
4730                                to = entry->string;
4731                        else if (!rebase_cousins)
4732                                to = label_oid(&commit->object.oid, NULL,
4733                                               &state);
4734
4735                        if (!to || !strcmp(to, "onto"))
4736                                strbuf_addf(out, "%s onto\n", cmd_reset);
4737                        else {
4738                                strbuf_reset(&oneline);
4739                                pretty_print_commit(pp, commit, &oneline);
4740                                strbuf_addf(out, "%s %s # %s\n",
4741                                            cmd_reset, to, oneline.buf);
4742                        }
4743                }
4744
4745                for (iter2 = list; iter2; iter2 = iter2->next) {
4746                        struct object_id *oid = &iter2->item->object.oid;
4747                        entry = oidmap_get(&commit2todo, oid);
4748                        /* only show if not already upstream */
4749                        if (entry)
4750                                strbuf_addf(out, "%s\n", entry->string);
4751                        entry = oidmap_get(&state.commit2label, oid);
4752                        if (entry)
4753                                strbuf_addf(out, "%s %s\n",
4754                                            cmd_label, entry->string);
4755                        oidset_insert(&shown, oid);
4756                }
4757
4758                free_commit_list(list);
4759        }
4760
4761        free_commit_list(commits);
4762        free_commit_list(tips);
4763
4764        strbuf_release(&label);
4765        strbuf_release(&oneline);
4766        strbuf_release(&buf);
4767
4768        oidmap_free(&commit2todo, 1);
4769        oidmap_free(&state.commit2label, 1);
4770        hashmap_free(&state.labels, 1);
4771        strbuf_release(&state.buf);
4772
4773        return 0;
4774}
4775
4776int sequencer_make_script(struct repository *r, struct strbuf *out, int argc,
4777                          const char **argv, unsigned flags)
4778{
4779        char *format = NULL;
4780        struct pretty_print_context pp = {0};
4781        struct rev_info revs;
4782        struct commit *commit;
4783        int keep_empty = flags & TODO_LIST_KEEP_EMPTY;
4784        const char *insn = flags & TODO_LIST_ABBREVIATE_CMDS ? "p" : "pick";
4785        int rebase_merges = flags & TODO_LIST_REBASE_MERGES;
4786
4787        repo_init_revisions(r, &revs, NULL);
4788        revs.verbose_header = 1;
4789        if (!rebase_merges)
4790                revs.max_parents = 1;
4791        revs.cherry_mark = 1;
4792        revs.limited = 1;
4793        revs.reverse = 1;
4794        revs.right_only = 1;
4795        revs.sort_order = REV_SORT_IN_GRAPH_ORDER;
4796        revs.topo_order = 1;
4797
4798        revs.pretty_given = 1;
4799        git_config_get_string("rebase.instructionFormat", &format);
4800        if (!format || !*format) {
4801                free(format);
4802                format = xstrdup("%s");
4803        }
4804        get_commit_format(format, &revs);
4805        free(format);
4806        pp.fmt = revs.commit_format;
4807        pp.output_encoding = get_log_output_encoding();
4808
4809        if (setup_revisions(argc, argv, &revs, NULL) > 1)
4810                return error(_("make_script: unhandled options"));
4811
4812        if (prepare_revision_walk(&revs) < 0)
4813                return error(_("make_script: error preparing revisions"));
4814
4815        if (rebase_merges)
4816                return make_script_with_merges(&pp, &revs, out, flags);
4817
4818        while ((commit = get_revision(&revs))) {
4819                int is_empty  = is_original_commit_empty(commit);
4820
4821                if (!is_empty && (commit->object.flags & PATCHSAME))
4822                        continue;
4823                if (!keep_empty && is_empty)
4824                        strbuf_addf(out, "%c ", comment_line_char);
4825                strbuf_addf(out, "%s %s ", insn,
4826                            oid_to_hex(&commit->object.oid));
4827                pretty_print_commit(&pp, commit, out);
4828                strbuf_addch(out, '\n');
4829        }
4830        return 0;
4831}
4832
4833/*
4834 * Add commands after pick and (series of) squash/fixup commands
4835 * in the todo list.
4836 */
4837void todo_list_add_exec_commands(struct todo_list *todo_list,
4838                                 struct string_list *commands)
4839{
4840        struct strbuf *buf = &todo_list->buf;
4841        size_t base_offset = buf->len;
4842        int i, insert, nr = 0, alloc = 0;
4843        struct todo_item *items = NULL, *base_items = NULL;
4844
4845        base_items = xcalloc(commands->nr, sizeof(struct todo_item));
4846        for (i = 0; i < commands->nr; i++) {
4847                size_t command_len = strlen(commands->items[i].string);
4848
4849                strbuf_addstr(buf, commands->items[i].string);
4850                strbuf_addch(buf, '\n');
4851
4852                base_items[i].command = TODO_EXEC;
4853                base_items[i].offset_in_buf = base_offset;
4854                base_items[i].arg_offset = base_offset + strlen("exec ");
4855                base_items[i].arg_len = command_len - strlen("exec ");
4856
4857                base_offset += command_len + 1;
4858        }
4859
4860        /*
4861         * Insert <commands> after every pick. Here, fixup/squash chains
4862         * are considered part of the pick, so we insert the commands *after*
4863         * those chains if there are any.
4864         *
4865         * As we insert the exec commands immediatly after rearranging
4866         * any fixups and before the user edits the list, a fixup chain
4867         * can never contain comments (any comments are empty picks that
4868         * have been commented out because the user did not specify
4869         * --keep-empty).  So, it is safe to insert an exec command
4870         * without looking at the command following a comment.
4871         */
4872        insert = 0;
4873        for (i = 0; i < todo_list->nr; i++) {
4874                enum todo_command command = todo_list->items[i].command;
4875                if (insert && !is_fixup(command)) {
4876                        ALLOC_GROW(items, nr + commands->nr, alloc);
4877                        COPY_ARRAY(items + nr, base_items, commands->nr);
4878                        nr += commands->nr;
4879
4880                        insert = 0;
4881                }
4882
4883                ALLOC_GROW(items, nr + 1, alloc);
4884                items[nr++] = todo_list->items[i];
4885
4886                if (command == TODO_PICK || command == TODO_MERGE)
4887                        insert = 1;
4888        }
4889
4890        /* insert or append final <commands> */
4891        if (insert || nr == todo_list->nr) {
4892                ALLOC_GROW(items, nr + commands->nr, alloc);
4893                COPY_ARRAY(items + nr, base_items, commands->nr);
4894                nr += commands->nr;
4895        }
4896
4897        free(base_items);
4898        FREE_AND_NULL(todo_list->items);
4899        todo_list->items = items;
4900        todo_list->nr = nr;
4901        todo_list->alloc = alloc;
4902}
4903
4904static void todo_list_to_strbuf(struct repository *r, struct todo_list *todo_list,
4905                                struct strbuf *buf, int num, unsigned flags)
4906{
4907        struct todo_item *item;
4908        int i, max = todo_list->nr;
4909
4910        if (num > 0 && num < max)
4911                max = num;
4912
4913        for (item = todo_list->items, i = 0; i < max; i++, item++) {
4914                /* if the item is not a command write it and continue */
4915                if (item->command >= TODO_COMMENT) {
4916                        strbuf_addf(buf, "%.*s\n", item->arg_len,
4917                                    todo_item_get_arg(todo_list, item));
4918                        continue;
4919                }
4920
4921                /* add command to the buffer */
4922                if (flags & TODO_LIST_ABBREVIATE_CMDS)
4923                        strbuf_addch(buf, command_to_char(item->command));
4924                else
4925                        strbuf_addstr(buf, command_to_string(item->command));
4926
4927                /* add commit id */
4928                if (item->commit) {
4929                        const char *oid = flags & TODO_LIST_SHORTEN_IDS ?
4930                                          short_commit_name(item->commit) :
4931                                          oid_to_hex(&item->commit->object.oid);
4932
4933                        if (item->command == TODO_MERGE) {
4934                                if (item->flags & TODO_EDIT_MERGE_MSG)
4935                                        strbuf_addstr(buf, " -c");
4936                                else
4937                                        strbuf_addstr(buf, " -C");
4938                        }
4939
4940                        strbuf_addf(buf, " %s", oid);
4941                }
4942
4943                /* add all the rest */
4944                if (!item->arg_len)
4945                        strbuf_addch(buf, '\n');
4946                else
4947                        strbuf_addf(buf, " %.*s\n", item->arg_len,
4948                                    todo_item_get_arg(todo_list, item));
4949        }
4950}
4951
4952int todo_list_write_to_file(struct repository *r, struct todo_list *todo_list,
4953                            const char *file, const char *shortrevisions,
4954                            const char *shortonto, int num, unsigned flags)
4955{
4956        int res;
4957        struct strbuf buf = STRBUF_INIT;
4958
4959        todo_list_to_strbuf(r, todo_list, &buf, num, flags);
4960        if (flags & TODO_LIST_APPEND_TODO_HELP)
4961                append_todo_help(flags & TODO_LIST_KEEP_EMPTY, count_commands(todo_list),
4962                                 shortrevisions, shortonto, &buf);
4963
4964        res = write_message(buf.buf, buf.len, file, 0);
4965        strbuf_release(&buf);
4966
4967        return res;
4968}
4969
4970static const char edit_todo_list_advice[] =
4971N_("You can fix this with 'git rebase --edit-todo' "
4972"and then run 'git rebase --continue'.\n"
4973"Or you can abort the rebase with 'git rebase"
4974" --abort'.\n");
4975
4976int check_todo_list_from_file(struct repository *r)
4977{
4978        struct todo_list old_todo = TODO_LIST_INIT, new_todo = TODO_LIST_INIT;
4979        int res = 0;
4980
4981        if (strbuf_read_file_or_whine(&new_todo.buf, rebase_path_todo()) < 0) {
4982                res = -1;
4983                goto out;
4984        }
4985
4986        if (strbuf_read_file_or_whine(&old_todo.buf, rebase_path_todo_backup()) < 0) {
4987                res = -1;
4988                goto out;
4989        }
4990
4991        res = todo_list_parse_insn_buffer(r, old_todo.buf.buf, &old_todo);
4992        if (!res)
4993                res = todo_list_parse_insn_buffer(r, new_todo.buf.buf, &new_todo);
4994        if (!res)
4995                res = todo_list_check(&old_todo, &new_todo);
4996        if (res)
4997                fprintf(stderr, _(edit_todo_list_advice));
4998out:
4999        todo_list_release(&old_todo);
5000        todo_list_release(&new_todo);
5001
5002        return res;
5003}
5004
5005/* skip picking commits whose parents are unchanged */
5006static int skip_unnecessary_picks(struct repository *r,
5007                                  struct todo_list *todo_list,
5008                                  struct object_id *base_oid)
5009{
5010        struct object_id *parent_oid;
5011        int i;
5012
5013        for (i = 0; i < todo_list->nr; i++) {
5014                struct todo_item *item = todo_list->items + i;
5015
5016                if (item->command >= TODO_NOOP)
5017                        continue;
5018                if (item->command != TODO_PICK)
5019                        break;
5020                if (parse_commit(item->commit)) {
5021                        return error(_("could not parse commit '%s'"),
5022                                oid_to_hex(&item->commit->object.oid));
5023                }
5024                if (!item->commit->parents)
5025                        break; /* root commit */
5026                if (item->commit->parents->next)
5027                        break; /* merge commit */
5028                parent_oid = &item->commit->parents->item->object.oid;
5029                if (!oideq(parent_oid, base_oid))
5030                        break;
5031                oidcpy(base_oid, &item->commit->object.oid);
5032        }
5033        if (i > 0) {
5034                const char *done_path = rebase_path_done();
5035
5036                if (todo_list_write_to_file(r, todo_list, done_path, NULL, NULL, i, 0)) {
5037                        error_errno(_("could not write to '%s'"), done_path);
5038                        return -1;
5039                }
5040
5041                MOVE_ARRAY(todo_list->items, todo_list->items + i, todo_list->nr - i);
5042                todo_list->nr -= i;
5043                todo_list->current = 0;
5044
5045                if (is_fixup(peek_command(todo_list, 0)))
5046                        record_in_rewritten(base_oid, peek_command(todo_list, 0));
5047        }
5048
5049        return 0;
5050}
5051
5052int complete_action(struct repository *r, struct replay_opts *opts, unsigned flags,
5053                    const char *shortrevisions, const char *onto_name,
5054                    struct commit *onto, const char *orig_head,
5055                    struct string_list *commands, unsigned autosquash,
5056                    struct todo_list *todo_list)
5057{
5058        const char *shortonto, *todo_file = rebase_path_todo();
5059        struct todo_list new_todo = TODO_LIST_INIT;
5060        struct strbuf *buf = &todo_list->buf;
5061        struct object_id oid = onto->object.oid;
5062        int res;
5063
5064        shortonto = find_unique_abbrev(&oid, DEFAULT_ABBREV);
5065
5066        if (buf->len == 0) {
5067                struct todo_item *item = append_new_todo(todo_list);
5068                item->command = TODO_NOOP;
5069                item->commit = NULL;
5070                item->arg_len = item->arg_offset = item->flags = item->offset_in_buf = 0;
5071        }
5072
5073        if (autosquash && todo_list_rearrange_squash(todo_list))
5074                return -1;
5075
5076        if (commands->nr)
5077                todo_list_add_exec_commands(todo_list, commands);
5078
5079        if (count_commands(todo_list) == 0) {
5080                apply_autostash(opts);
5081                sequencer_remove_state(opts);
5082
5083                return error(_("nothing to do"));
5084        }
5085
5086        res = edit_todo_list(r, todo_list, &new_todo, shortrevisions,
5087                             shortonto, flags);
5088        if (res == -1)
5089                return -1;
5090        else if (res == -2) {
5091                apply_autostash(opts);
5092                sequencer_remove_state(opts);
5093
5094                return -1;
5095        } else if (res == -3) {
5096                apply_autostash(opts);
5097                sequencer_remove_state(opts);
5098                todo_list_release(&new_todo);
5099
5100                return error(_("nothing to do"));
5101        }
5102
5103        if (todo_list_parse_insn_buffer(r, new_todo.buf.buf, &new_todo) ||
5104            todo_list_check(todo_list, &new_todo)) {
5105                fprintf(stderr, _(edit_todo_list_advice));
5106                checkout_onto(r, opts, onto_name, &onto->object.oid, orig_head);
5107                todo_list_release(&new_todo);
5108
5109                return -1;
5110        }
5111
5112        if (opts->allow_ff && skip_unnecessary_picks(r, &new_todo, &oid)) {
5113                todo_list_release(&new_todo);
5114                return error(_("could not skip unnecessary pick commands"));
5115        }
5116
5117        if (todo_list_write_to_file(r, &new_todo, todo_file, NULL, NULL, -1,
5118                                    flags & ~(TODO_LIST_SHORTEN_IDS))) {
5119                todo_list_release(&new_todo);
5120                return error_errno(_("could not write '%s'"), todo_file);
5121        }
5122
5123        todo_list_release(&new_todo);
5124
5125        if (checkout_onto(r, opts, onto_name, &oid, orig_head))
5126                return -1;
5127
5128        if (require_clean_work_tree(r, "rebase", "", 1, 1))
5129                return -1;
5130
5131        return sequencer_continue(r, opts);
5132}
5133
5134struct subject2item_entry {
5135        struct hashmap_entry entry;
5136        int i;
5137        char subject[FLEX_ARRAY];
5138};
5139
5140static int subject2item_cmp(const void *fndata,
5141                            const struct subject2item_entry *a,
5142                            const struct subject2item_entry *b, const void *key)
5143{
5144        return key ? strcmp(a->subject, key) : strcmp(a->subject, b->subject);
5145}
5146
5147define_commit_slab(commit_todo_item, struct todo_item *);
5148
5149/*
5150 * Rearrange the todo list that has both "pick commit-id msg" and "pick
5151 * commit-id fixup!/squash! msg" in it so that the latter is put immediately
5152 * after the former, and change "pick" to "fixup"/"squash".
5153 *
5154 * Note that if the config has specified a custom instruction format, each log
5155 * message will have to be retrieved from the commit (as the oneline in the
5156 * script cannot be trusted) in order to normalize the autosquash arrangement.
5157 */
5158int todo_list_rearrange_squash(struct todo_list *todo_list)
5159{
5160        struct hashmap subject2item;
5161        int rearranged = 0, *next, *tail, i, nr = 0, alloc = 0;
5162        char **subjects;
5163        struct commit_todo_item commit_todo;
5164        struct todo_item *items = NULL;
5165
5166        init_commit_todo_item(&commit_todo);
5167        /*
5168         * The hashmap maps onelines to the respective todo list index.
5169         *
5170         * If any items need to be rearranged, the next[i] value will indicate
5171         * which item was moved directly after the i'th.
5172         *
5173         * In that case, last[i] will indicate the index of the latest item to
5174         * be moved to appear after the i'th.
5175         */
5176        hashmap_init(&subject2item, (hashmap_cmp_fn) subject2item_cmp,
5177                     NULL, todo_list->nr);
5178        ALLOC_ARRAY(next, todo_list->nr);
5179        ALLOC_ARRAY(tail, todo_list->nr);
5180        ALLOC_ARRAY(subjects, todo_list->nr);
5181        for (i = 0; i < todo_list->nr; i++) {
5182                struct strbuf buf = STRBUF_INIT;
5183                struct todo_item *item = todo_list->items + i;
5184                const char *commit_buffer, *subject, *p;
5185                size_t subject_len;
5186                int i2 = -1;
5187                struct subject2item_entry *entry;
5188
5189                next[i] = tail[i] = -1;
5190                if (!item->commit || item->command == TODO_DROP) {
5191                        subjects[i] = NULL;
5192                        continue;
5193                }
5194
5195                if (is_fixup(item->command)) {
5196                        clear_commit_todo_item(&commit_todo);
5197                        return error(_("the script was already rearranged."));
5198                }
5199
5200                *commit_todo_item_at(&commit_todo, item->commit) = item;
5201
5202                parse_commit(item->commit);
5203                commit_buffer = get_commit_buffer(item->commit, NULL);
5204                find_commit_subject(commit_buffer, &subject);
5205                format_subject(&buf, subject, " ");
5206                subject = subjects[i] = strbuf_detach(&buf, &subject_len);
5207                unuse_commit_buffer(item->commit, commit_buffer);
5208                if ((skip_prefix(subject, "fixup! ", &p) ||
5209                     skip_prefix(subject, "squash! ", &p))) {
5210                        struct commit *commit2;
5211
5212                        for (;;) {
5213                                while (isspace(*p))
5214                                        p++;
5215                                if (!skip_prefix(p, "fixup! ", &p) &&
5216                                    !skip_prefix(p, "squash! ", &p))
5217                                        break;
5218                        }
5219
5220                        if ((entry = hashmap_get_from_hash(&subject2item,
5221                                                           strhash(p), p)))
5222                                /* found by title */
5223                                i2 = entry->i;
5224                        else if (!strchr(p, ' ') &&
5225                                 (commit2 =
5226                                  lookup_commit_reference_by_name(p)) &&
5227                                 *commit_todo_item_at(&commit_todo, commit2))
5228                                /* found by commit name */
5229                                i2 = *commit_todo_item_at(&commit_todo, commit2)
5230                                        - todo_list->items;
5231                        else {
5232                                /* copy can be a prefix of the commit subject */
5233                                for (i2 = 0; i2 < i; i2++)
5234                                        if (subjects[i2] &&
5235                                            starts_with(subjects[i2], p))
5236                                                break;
5237                                if (i2 == i)
5238                                        i2 = -1;
5239                        }
5240                }
5241                if (i2 >= 0) {
5242                        rearranged = 1;
5243                        todo_list->items[i].command =
5244                                starts_with(subject, "fixup!") ?
5245                                TODO_FIXUP : TODO_SQUASH;
5246                        if (next[i2] < 0)
5247                                next[i2] = i;
5248                        else
5249                                next[tail[i2]] = i;
5250                        tail[i2] = i;
5251                } else if (!hashmap_get_from_hash(&subject2item,
5252                                                strhash(subject), subject)) {
5253                        FLEX_ALLOC_MEM(entry, subject, subject, subject_len);
5254                        entry->i = i;
5255                        hashmap_entry_init(entry, strhash(entry->subject));
5256                        hashmap_put(&subject2item, entry);
5257                }
5258        }
5259
5260        if (rearranged) {
5261                for (i = 0; i < todo_list->nr; i++) {
5262                        enum todo_command command = todo_list->items[i].command;
5263                        int cur = i;
5264
5265                        /*
5266                         * Initially, all commands are 'pick's. If it is a
5267                         * fixup or a squash now, we have rearranged it.
5268                         */
5269                        if (is_fixup(command))
5270                                continue;
5271
5272                        while (cur >= 0) {
5273                                ALLOC_GROW(items, nr + 1, alloc);
5274                                items[nr++] = todo_list->items[cur];
5275                                cur = next[cur];
5276                        }
5277                }
5278
5279                FREE_AND_NULL(todo_list->items);
5280                todo_list->items = items;
5281                todo_list->nr = nr;
5282                todo_list->alloc = alloc;
5283        }
5284
5285        free(next);
5286        free(tail);
5287        for (i = 0; i < todo_list->nr; i++)
5288                free(subjects[i]);
5289        free(subjects);
5290        hashmap_free(&subject2item, 1);
5291
5292        clear_commit_todo_item(&commit_todo);
5293
5294        return 0;
5295}