+/*

+ * A 'struct replay_ctx' represents the private state of the sequencer.

+ */

+struct replay_ctx {

+ /*

+ * The commit message that will be used except at the end of a

+ * chain of fixup and squash commands.

+ */

+ struct strbuf message;

+ /*

+ * The list of completed fixup and squash commands in the

+ * current chain.

+ */

+ struct strbuf current_fixups;

+ /*

+ * Stores the reflog message that will be used when creating a

+ * commit. Points to a static buffer and should not be free()'d.

+ */

+ const char *reflog_message;

+ /*

+ * The number of completed fixup and squash commands in the

+ * current chain.

+ */

+ int current_fixup_count;

+ /*

+ * Whether message contains a commit message.

+ */

+ unsigned have_message :1;

+};

+

+struct replay_ctx* replay_ctx_new(void)

+{

+ struct replay_ctx *ctx = xcalloc(1, sizeof(*ctx));

+

+ strbuf_init(&ctx->current_fixups, 0);

+ strbuf_init(&ctx->message, 0);

+

+ return ctx;

+}

+

+ refs_read_ref(get_main_ref_store(the_repository), ref, &rec->before);

+ int ret = git_config_string(&opts->default_strategy, k, v);

+ struct trailer_iterator iter;

+ size_t i = 0;

+ trailer_iterator_init(&iter, sb->buf);

+ while (trailer_iterator_advance(&iter)) {

+ i++;

+ if (sob && !strncmp(iter.raw, sob->buf, sob->len))

+ found_sob = i;

+ }

+ trailer_iterator_release(&iter);

+ if (!i)

+ return 0;

+ found_sob_last = (int)i == found_sob;

+static void replay_ctx_release(struct replay_ctx *ctx)

+{

+ strbuf_release(&ctx->current_fixups);

+ strbuf_release(&ctx->message);

+}

+

+ struct replay_ctx *ctx = opts->ctx;

+

+ replay_ctx_release(ctx);

+ free(opts->ctx);

+ if (refs_delete_ref(get_main_ref_store(the_repository), "(rebase) cleanup", p, NULL, 0) < 0) {

+const char *rebase_resolvemsg =

+N_("Resolve all conflicts manually, mark them as resolved with\n"

+"\"git add/rm <conflicted_files>\", then run \"git rebase --continue\".\n"

+"You can instead skip this commit: run \"git rebase --skip\".\n"

+"To abort and get back to the state before \"git rebase\", run "

+"\"git rebase --abort\".");

+

+ const char *msg;

+

+ if (is_rebase_i(opts))

+ msg = rebase_resolvemsg;

+ else

+ msg = getenv("GIT_CHERRY_PICK_HELP");

+ advise_if_enabled(ADVICE_MERGE_CONFLICT, "%s", msg);

+ NULL, REF_NO_DEREF);

+ advise_if_enabled(ADVICE_MERGE_CONFLICT,

+ _("after resolving the conflicts, mark the corrected paths\n"

+ "with 'git add <paths>' or 'git rm <paths>'"));

+ advise_if_enabled(ADVICE_MERGE_CONFLICT,

+ _("After resolving the conflicts, mark them with\n"

+ "\"git add/rm <pathspec>\", then run\n"

+ "\"git cherry-pick --continue\".\n"

+ "You can instead skip this commit with \"git cherry-pick --skip\".\n"

+ "To abort and get back to the state before \"git cherry-pick\",\n"

+ "run \"git cherry-pick --abort\"."));

+ advise_if_enabled(ADVICE_MERGE_CONFLICT,

+ _("After resolving the conflicts, mark them with\n"

+ "\"git add/rm <pathspec>\", then run\n"

+ "\"git revert --continue\".\n"

+ "You can instead skip this commit with \"git revert --skip\".\n"

+ "To abort and get back to the state before \"git revert\",\n"

+ "run \"git revert --abort\"."));

+ transaction = ref_store_transaction_begin(get_main_ref_store(the_repository),

+ &err);

+ null_oid() : from, NULL, NULL,

+ strbuf_addstr(msgbuf, comment_line_str);

+ strbuf_commented_addf(msgbuf, comment_line_str, "Conflicts:\n");

+ strbuf_commented_addf(msgbuf, comment_line_str,

+ if (!head_tree)

+ return error(_("unable to read tree (%s)"), oid_to_hex(head));

+ const struct object_id *head_tree_oid;

+ const char *head_name;

+

+ if (!refs_resolve_ref_unsafe(get_main_ref_store(the_repository), "HEAD", RESOLVE_REF_READING, &head_oid, NULL)) {

+ /* Check to see if this is an unborn branch */

+ head_name = refs_resolve_ref_unsafe(get_main_ref_store(the_repository),

+ "HEAD",

+ RESOLVE_REF_READING | RESOLVE_REF_NO_RECURSE,

+ &head_oid, NULL);

+ if (!head_name ||

+ !starts_with(head_name, "refs/heads/") ||

+ !is_null_oid(&head_oid))

+ return error(_("could not resolve HEAD commit"));

+ head_tree_oid = the_hash_algo->empty_tree;

+ } else {

+ head_commit = lookup_commit(r, &head_oid);

+ /*

+ * If head_commit is NULL, check_commit, called from

+ * lookup_commit, would have indicated that head_commit is not

+ * a commit object already. repo_parse_commit() will return failure

+ * without further complaints in such a case. Otherwise, if

+ * the commit is invalid, repo_parse_commit() will complain. So

+ * there is nothing for us to say here. Just return failure.

+ */

+ if (repo_parse_commit(r, head_commit))

+ return -1;

+ head_tree_oid = get_commit_tree_oid(head_commit);

+ }

+ return oideq(cache_tree_oid, head_tree_oid);

+ struct replay_ctx *ctx = opts->ctx;

+ strvec_pushf(&cmd.env, GIT_REFLOG_ACTION "=%s", ctx->reflog_message);

+ cleanup_mode == COMMIT_MSG_CLEANUP_ALL ? comment_line_str : NULL);

+ cleanup_mode == COMMIT_MSG_CLEANUP_ALL ? comment_line_str : NULL);

+ transaction = ref_store_transaction_begin(get_main_ref_store(the_repository),

+ err);

+ NULL, NULL, 0, sb.buf, err) ||

+ struct replay_ctx *ctx = opts->ctx;

+ cleanup == COMMIT_MSG_CLEANUP_ALL ? comment_line_str : NULL);

+ if (update_head_with_reflog(current_head, oid, ctx->reflog_message,

+ if (refs_update_ref(get_main_ref_store(the_repository), "rebase", "REBASE_HEAD", oid,

+ NULL, REF_NO_DEREF, UPDATE_REFS_MSG_ON_ERR))

+ "CHERRY_PICK_HEAD", NULL, REF_NO_DEREF);

+ * For a commit that is initially empty, allow_empty determines if it

+ * should be kept or not

+ * For a commit that becomes empty, keep_redundant_commits and

+ * drop_redundant_commits determine whether the commit should be kept or

+ * dropped. If neither is specified, halt.

+ return opts->allow_empty;

+ else if (opts->keep_redundant_commits)

+ if (command == TODO_COMMENT)

+ return comment_line_str;

+ return 0;

+ while (starts_with_mem(s, len, comment_line_str)) {

+ strbuf_add_commented_lines(buf, s, len, comment_line_str);

+static int seen_squash(struct replay_ctx *ctx)

+ return starts_with(ctx->current_fixups.buf, "squash") ||

+ strstr(ctx->current_fixups.buf, "\nsquash");

+ struct replay_ctx *ctx = opts->ctx;

+ ((command == TODO_SQUASH || seen_squash(ctx)) &&

+ strbuf_addf(buf, "\n%s ", comment_line_str);

+ ++ctx->current_fixup_count + 1);

+ strbuf_add_commented_lines(buf, body, commented_len, comment_line_str);

+ if (is_fixup_flag(command, flag) && !seen_squash(ctx)) {

+ struct replay_ctx *ctx = opts->ctx;

+ if (ctx->current_fixup_count > 0) {

+ eol = !starts_with(buf.buf, comment_line_str) ?

+ strbuf_addf(&header, "%s ", comment_line_str);

+ ctx->current_fixup_count + 2);

+ if (is_fixup_flag(command, flag) && !seen_squash(ctx))

+ strbuf_addf(&buf, "%s ", comment_line_str);

+ strbuf_addf(&buf, "\n%s ", comment_line_str);

+ comment_line_str);

+ strbuf_addf(&buf, "\n%s ", comment_line_str);

+ ++ctx->current_fixup_count + 1);

+ comment_line_str);

+ strbuf_addf(&ctx->current_fixups, "%s%s %s",

+ ctx->current_fixups.len ? "\n" : "",

+ res = write_message(ctx->current_fixups.buf,

+ ctx->current_fixups.len,

+ struct replay_ctx *ctx = opts->ctx;

+ strbuf_addstr(&ctx->message,

+ strbuf_addstr(&ctx->message, "Reapply \"");

+ strbuf_addstr(&ctx->message, orig_subject);

+ strbuf_addstr(&ctx->message, "Revert \"");

+ strbuf_addstr(&ctx->message, msg.subject);

+ strbuf_addstr(&ctx->message, "\"");

+ strbuf_addstr(&ctx->message, "\n\nThis reverts commit ");

+ refer_to_commit(opts, &ctx->message, commit);

+ strbuf_addstr(&ctx->message, ", reversing\nchanges made to ");

+ refer_to_commit(opts, &ctx->message, parent);

+ strbuf_addstr(&ctx->message, ".\n");

+ /* Append the commit log message to ctx->message. */

+ strbuf_addstr(&ctx->message, p);

+ strbuf_complete_line(&ctx->message);

+ if (!has_conforming_footer(&ctx->message, NULL, 0))

+ strbuf_addch(&ctx->message, '\n');

+ strbuf_addstr(&ctx->message, cherry_picked_prefix);

+ strbuf_addstr(&ctx->message, oid_to_hex(&commit->object.oid));

+ strbuf_addstr(&ctx->message, ")\n");

+ ctx->have_message = 1;

+ append_signoff(&ctx->message, 0, 0);

+ &head, &ctx->message, opts);

+ res |= write_message(ctx->message.buf, ctx->message.len,

+ res = write_message(ctx->message.buf, ctx->message.len,

+ refs_update_ref(get_main_ref_store(the_repository), NULL, "CHERRY_PICK_HEAD", &commit->object.oid, NULL,

+ REF_NO_DEREF, UPDATE_REFS_MSG_ON_ERR))

+ refs_update_ref(get_main_ref_store(the_repository), NULL, "REVERT_HEAD", &commit->object.oid, NULL,

+ REF_NO_DEREF, UPDATE_REFS_MSG_ON_ERR))

+ NULL, REF_NO_DEREF);

+ refs_delete_ref(get_main_ref_store(r), "", "AUTO_MERGE",

+ NULL, REF_NO_DEREF);

+ strbuf_reset(&ctx->current_fixups);

+ ctx->current_fixup_count = 0;

+static int check_merge_commit_insn(enum todo_command command)

+{

+ switch(command) {

+ case TODO_PICK:

+ error(_("'%s' does not accept merge commits"),

+ todo_command_info[command].str);

+ advise_if_enabled(ADVICE_REBASE_TODO_ERROR, _(

+ /*

+ * TRANSLATORS: 'pick' and 'merge -C' should not be

+ * translated.

+ */

+ "'pick' does not take a merge commit. If you wanted to\n"

+ "replay the merge, use 'merge -C' on the commit."));

+ return -1;

+

+ case TODO_REWORD:

+ error(_("'%s' does not accept merge commits"),

+ todo_command_info[command].str);

+ advise_if_enabled(ADVICE_REBASE_TODO_ERROR, _(

+ /*

+ * TRANSLATORS: 'reword' and 'merge -c' should not be

+ * translated.

+ */

+ "'reword' does not take a merge commit. If you wanted to\n"

+ "replay the merge and reword the commit message, use\n"

+ "'merge -c' on the commit"));

+ return -1;

+

+ case TODO_EDIT:

+ error(_("'%s' does not accept merge commits"),

+ todo_command_info[command].str);

+ advise_if_enabled(ADVICE_REBASE_TODO_ERROR, _(

+ /*

+ * TRANSLATORS: 'edit', 'merge -C' and 'break' should

+ * not be translated.

+ */

+ "'edit' does not take a merge commit. If you wanted to\n"

+ "replay the merge, use 'merge -C' on the commit, and then\n"

+ "'break' to give the control back to you so that you can\n"

+ "do 'git commit --amend && git rebase --continue'."));

+ return -1;

+

+ case TODO_FIXUP:

+ case TODO_SQUASH:

+ return error(_("cannot squash merge commit into another commit"));

+

+ case TODO_MERGE:

+ return 0;

+

+ default:

+ BUG("unexpected todo_command");

+ }

+}

+

+static int parse_insn_line(struct repository *r, struct replay_opts *opts,

+ struct todo_item *item, const char *buf,

+ const char *bol, char *eol)

+ if (bol == eol || *bol == '\r' || starts_with_mem(bol, eol - bol, comment_line_str)) {

+ if (!item->commit)

+ return -1;

+ if (is_rebase_i(opts) &&

+ item->commit->parents && item->commit->parents->next)

+ return check_merge_commit_insn(item->command);

+ return 0;

+int todo_list_parse_insn_buffer(struct repository *r, struct replay_opts *opts,

+ char *buf, struct todo_list *todo_list)

+ if (parse_insn_line(r, opts, item, buf, p, eol)) {

+ "CHERRY_PICK_HEAD", NULL, REF_NO_DEREF) &&

+ NULL, REF_NO_DEREF) &&

+ refs_delete_ref(get_main_ref_store(r), "", "AUTO_MERGE",

+ NULL, REF_NO_DEREF);

+ goto out;

+ goto out;

+out:

+ replay_opts_release(&opts);

+ res = todo_list_parse_insn_buffer(r, opts, todo_list->buf.buf, todo_list);

+ !todo_list_parse_insn_buffer(r, opts, done.buf.buf, &done))

+ else if (!strcmp(key, "options.drop-redundant-commits"))

+ opts->drop_redundant_commits =

+ git_config_bool_or_int(key, value, ctx->kvi, &error_flag);

+ struct replay_ctx *ctx = opts->ctx;

+

+ if (read_oneliner(&ctx->current_fixups,

+ const char *p = ctx->current_fixups.buf;

+ ctx->current_fixup_count = 1;

+ ctx->current_fixup_count++;

+ if (refs_read_ref_full(get_main_ref_store(the_repository), "HEAD", 0, &head_oid, NULL))

+ if (refs_read_ref_full(get_main_ref_store(the_repository), "HEAD", 0, &head, NULL))

+ "options.no-commit", NULL, "true");

+ res |= git_config_set_in_file_gently(opts_file, "options.edit", NULL,

+ "options.allow-empty", NULL, "true");

+ "options.allow-empty-message", NULL, "true");

+ if (opts->drop_redundant_commits)

+ res |= git_config_set_in_file_gently(opts_file,

+ "options.drop-redundant-commits", NULL, "true");

+ "options.keep-redundant-commits", NULL, "true");

+ "options.signoff", NULL, "true");

+ "options.record-origin", NULL, "true");

+ "options.allow-ff", NULL, "true");

+ "options.mainline", NULL, buf.buf);

+ "options.strategy", NULL, opts->strategy);

+ "options.gpg-sign", NULL, opts->gpg_sign);

+ opts->xopts.v[i], "^$", NULL, 0);

+ "options.allow-rerere-auto", NULL,

+ "options.default-msg-cleanup", NULL,

+ struct replay_ctx *ctx = opts->ctx;

+

+ /*

+ * Write the commit message to be used by "git rebase

+ * --continue". If a "fixup" or "squash" command has conflicts

+ * then we will have already written rebase_path_message() in

+ * error_failed_squash(). If an "edit" command was

+ * fast-forwarded then we don't have a message in ctx->message

+ * and rely on make_patch() to write rebase_path_message()

+ * instead.

+ */

+ if (ctx->have_message && !file_exists(rebase_path_message()) &&

+ write_message(ctx->message.buf, ctx->message.len,

+ rebase_path_message(), 0))

+ return error(_("could not write commit message file"));

+

+ if (commit && make_patch(r, commit, opts))

+ strvec_push(&cmd.env, "GIT_CHERRY_PICK_HELP");

+ } else if (ref_transaction_update(transaction, ref_name.buf,

+ &head_oid, NULL, NULL, NULL,

+ 0, msg.buf, &err) < 0 ||

+ if (!refs_read_ref(get_main_ref_store(the_repository), buf->buf, &oid)) {

+ if (!tree)

+ return error(_("unable to read tree (%s)"), oid_to_hex(&oid));

+ ret = refs_update_ref(get_main_ref_store(the_repository), reflog_message(opts, "reset", "'%.*s'",

+ len, name),

+ "HEAD", &oid,

+ NULL, 0, UPDATE_REFS_MSG_ON_ERR);

+ struct replay_ctx *ctx = opts->ctx;

+ struct commit_list *bases = NULL, *j;

+ strbuf_add(&ctx->message, body, len);

+ strbuf_release(&buf);

+ strbuf_add(&ctx->message, arg + oneline_offset,

+ arg_len - oneline_offset);

+ strbuf_addf(&ctx->message, "Merge %s '%.*s'",

+ ctx->have_message = 1;

+ if (write_message(ctx->message.buf, ctx->message.len,

+ git_path_merge_msg(r), 0)) {

+ ret = error_errno(_("could not write '%s'"),

+ git_path_merge_msg(r));

+ goto leave_merge;

+ }

+ NULL, REF_NO_DEREF);

+ if (repo_get_merge_bases(r, head_commit, merge_commit, &bases) < 0) {

+ ret = -1;

+ goto leave_merge;

+ }

+

+ if (refs_read_ref(get_main_ref_store(the_repository), "HEAD", &rec->after))

+static void create_autostash_internal(struct repository *r,

+ const char *path,

+ const char *refname)

+ if (path && refname)

+ BUG("can only pass path or refname");

+

+ if (path) {

+ if (safe_create_leading_directories_const(path))

+ die(_("Could not create directory for '%s'"),

+ path);

+ write_file(path, "%s", oid_to_hex(&oid));

+ } else {

+ refs_update_ref(get_main_ref_store(r), "", refname,

+ &oid, null_oid(), 0, UPDATE_REFS_DIE_ON_ERR);

+ }

+

+void create_autostash(struct repository *r, const char *path)

+{

+ create_autostash_internal(r, path, NULL);

+}

+

+void create_autostash_ref(struct repository *r, const char *refname)

+{

+ create_autostash_internal(r, NULL, refname);

+}

+

+static int apply_save_autostash_ref(struct repository *r, const char *refname,

+ int attempt_apply)

+{

+ struct object_id stash_oid;

+ char stash_oid_hex[GIT_MAX_HEXSZ + 1];

+ int flag, ret;

+

+ if (!refs_ref_exists(get_main_ref_store(r), refname))

+ return 0;

+

+ if (!refs_resolve_ref_unsafe(get_main_ref_store(r), refname,

+ RESOLVE_REF_READING, &stash_oid, &flag))

+ return -1;

+ if (flag & REF_ISSYMREF)

+ return error(_("autostash reference is a symref"));

+

+ oid_to_hex_r(stash_oid_hex, &stash_oid);

+ ret = apply_save_autostash_oid(stash_oid_hex, attempt_apply);

+

+ refs_delete_ref(get_main_ref_store(r), "", refname,

+ &stash_oid, REF_NO_DEREF);

+

+ return ret;

+}

+

+int save_autostash_ref(struct repository *r, const char *refname)

+{

+ return apply_save_autostash_ref(r, refname, 0);

+}

+

+int apply_autostash_ref(struct repository *r, const char *refname)

+{

+ return apply_save_autostash_ref(r, refname, 1);

+}

+

+ struct replay_ctx *ctx = opts->ctx;

+ ctx->reflog_message = reflog_message(

+ struct replay_ctx *ctx = opts->ctx;

+ ctx->reflog_message = sequencer_reflog_action(opts);

+ refs_delete_ref(get_main_ref_store(r), "", "AUTO_MERGE",

+ NULL, REF_NO_DEREF);

+ refs_delete_ref(get_main_ref_store(r), "", "REBASE_HEAD",

+ NULL, REF_NO_DEREF);

+ strbuf_reset(&ctx->message);

+ ctx->have_message = 0;

+ if (refs_update_ref(get_main_ref_store(the_repository), msg, head_ref.buf, &head, &orig,

+ REF_NO_DEREF, UPDATE_REFS_MSG_ON_ERR)) {

+ if (refs_update_symref(get_main_ref_store(the_repository), "HEAD", head_ref.buf, msg)) {

+ struct replay_ctx *ctx = opts->ctx;

+ if (!is_clean || !ctx->current_fixup_count)

+ strbuf_reset(&ctx->current_fixups);

+ ctx->current_fixup_count = 0;

+ const char *p = ctx->current_fixups.buf;

+ int len = ctx->current_fixups.len;

+ ctx->current_fixup_count--;

+ strbuf_setlen(&ctx->current_fixups, len);

+ if (ctx->current_fixup_count > 0 &&

+ "CHERRY_PICK_HEAD", NULL, REF_NO_DEREF))

+ refs_delete_ref(get_main_ref_store(r), "", "AUTO_MERGE",

+ NULL, REF_NO_DEREF);

+ if (ctx->current_fixup_count > 0) {

+ strbuf_reset(&ctx->current_fixups);

+ ctx->current_fixup_count = 0;

+ struct replay_ctx *ctx = opts->ctx;

+ if ((res = todo_list_check_against_backup(r, opts,

+ &todo_list)))

+ ctx->reflog_message = reflog_message(opts, "continue", NULL);

+ opts->ctx->reflog_message = sequencer_reflog_action(opts);

+ strbuf_addf(&buf, " %s empty",

+ comment_line_str);

+ strbuf_addf(out, "\n%s Branch %s\n", comment_line_str, entry->string);

+ strbuf_addf(out, " %s empty", comment_line_str);

+ const char *head_ref = refs_resolve_ref_unsafe(get_main_ref_store(the_repository),

+ "HEAD",

+ RESOLVE_REF_READING,

+ NULL,

+ NULL);

+ res = edit_todo_list(r, opts, todo_list, &new_todo, shortrevisions,

+ if (todo_list_parse_insn_buffer(r, opts, new_todo.buf.buf, &new_todo) < 0)