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