5 #include "object-store.h"
10 #include "run-command.h"
13 #include "cache-tree.h"
17 #include "merge-recursive.h"
19 #include "argv-array.h"
23 #include "wt-status.h"
25 #include "notes-utils.h"
27 #include "unpack-trees.h"
31 #include "commit-slab.h"
33 #include "commit-reach.h"
34 #include "rebase-interactive.h"
36 #define GIT_REFLOG_ACTION "GIT_REFLOG_ACTION"
38 const char sign_off_header[] = "Signed-off-by: ";
39 static const char cherry_picked_prefix[] = "(cherry picked from commit ";
41 GIT_PATH_FUNC(git_path_commit_editmsg, "COMMIT_EDITMSG")
43 GIT_PATH_FUNC(git_path_seq_dir, "sequencer")
45 static GIT_PATH_FUNC(git_path_todo_file, "sequencer/todo")
46 static GIT_PATH_FUNC(git_path_opts_file, "sequencer/opts")
47 static GIT_PATH_FUNC(git_path_head_file, "sequencer/head")
48 static GIT_PATH_FUNC(git_path_abort_safety_file, "sequencer/abort-safety")
50 static GIT_PATH_FUNC(rebase_path, "rebase-merge")
52 * The file containing rebase commands, comments, and empty lines.
53 * This file is created by "git rebase -i" then edited by the user. As
54 * the lines are processed, they are removed from the front of this
55 * file and written to the tail of 'done'.
57 GIT_PATH_FUNC(rebase_path_todo, "rebase-merge/git-rebase-todo")
58 static GIT_PATH_FUNC(rebase_path_todo_backup,
59 "rebase-merge/git-rebase-todo.backup")
62 * The rebase command lines that have already been processed. A line
63 * is moved here when it is first handled, before any associated user
66 static GIT_PATH_FUNC(rebase_path_done, "rebase-merge/done")
68 * The file to keep track of how many commands were already processed (e.g.
71 static GIT_PATH_FUNC(rebase_path_msgnum, "rebase-merge/msgnum")
73 * The file to keep track of how many commands are to be processed in total
74 * (e.g. for the prompt).
76 static GIT_PATH_FUNC(rebase_path_msgtotal, "rebase-merge/end")
78 * The commit message that is planned to be used for any changes that
79 * need to be committed following a user interaction.
81 static GIT_PATH_FUNC(rebase_path_message, "rebase-merge/message")
83 * The file into which is accumulated the suggested commit message for
84 * squash/fixup commands. When the first of a series of squash/fixups
85 * is seen, the file is created and the commit message from the
86 * previous commit and from the first squash/fixup commit are written
87 * to it. The commit message for each subsequent squash/fixup commit
88 * is appended to the file as it is processed.
90 static GIT_PATH_FUNC(rebase_path_squash_msg, "rebase-merge/message-squash")
92 * If the current series of squash/fixups has not yet included a squash
93 * command, then this file exists and holds the commit message of the
94 * original "pick" commit. (If the series ends without a "squash"
95 * command, then this can be used as the commit message of the combined
96 * commit without opening the editor.)
98 static GIT_PATH_FUNC(rebase_path_fixup_msg, "rebase-merge/message-fixup")
100 * This file contains the list fixup/squash commands that have been
101 * accumulated into message-fixup or message-squash so far.
103 static GIT_PATH_FUNC(rebase_path_current_fixups, "rebase-merge/current-fixups")
105 * A script to set the GIT_AUTHOR_NAME, GIT_AUTHOR_EMAIL, and
106 * GIT_AUTHOR_DATE that will be used for the commit that is currently
109 static GIT_PATH_FUNC(rebase_path_author_script, "rebase-merge/author-script")
111 * When an "edit" rebase command is being processed, the SHA1 of the
112 * commit to be edited is recorded in this file. When "git rebase
113 * --continue" is executed, if there are any staged changes then they
114 * will be amended to the HEAD commit, but only provided the HEAD
115 * commit is still the commit to be edited. When any other rebase
116 * command is processed, this file is deleted.
118 static GIT_PATH_FUNC(rebase_path_amend, "rebase-merge/amend")
120 * When we stop at a given patch via the "edit" command, this file contains
121 * the abbreviated commit name of the corresponding patch.
123 static GIT_PATH_FUNC(rebase_path_stopped_sha, "rebase-merge/stopped-sha")
125 * For the post-rewrite hook, we make a list of rewritten commits and
126 * their new sha1s. The rewritten-pending list keeps the sha1s of
127 * commits that have been processed, but not committed yet,
128 * e.g. because they are waiting for a 'squash' command.
130 static GIT_PATH_FUNC(rebase_path_rewritten_list, "rebase-merge/rewritten-list")
131 static GIT_PATH_FUNC(rebase_path_rewritten_pending,
132 "rebase-merge/rewritten-pending")
135 * The path of the file containig the OID of the "squash onto" commit, i.e.
136 * the dummy commit used for `reset [new root]`.
138 static GIT_PATH_FUNC(rebase_path_squash_onto, "rebase-merge/squash-onto")
141 * The path of the file listing refs that need to be deleted after the rebase
142 * finishes. This is used by the `label` command to record the need for cleanup.
144 static GIT_PATH_FUNC(rebase_path_refs_to_delete, "rebase-merge/refs-to-delete")
147 * The following files are written by git-rebase just after parsing the
150 static GIT_PATH_FUNC(rebase_path_gpg_sign_opt, "rebase-merge/gpg_sign_opt")
151 static GIT_PATH_FUNC(rebase_path_orig_head, "rebase-merge/orig-head")
152 static GIT_PATH_FUNC(rebase_path_verbose, "rebase-merge/verbose")
153 static GIT_PATH_FUNC(rebase_path_quiet, "rebase-merge/quiet")
154 static GIT_PATH_FUNC(rebase_path_signoff, "rebase-merge/signoff")
155 static GIT_PATH_FUNC(rebase_path_head_name, "rebase-merge/head-name")
156 static GIT_PATH_FUNC(rebase_path_onto, "rebase-merge/onto")
157 static GIT_PATH_FUNC(rebase_path_autostash, "rebase-merge/autostash")
158 static GIT_PATH_FUNC(rebase_path_strategy, "rebase-merge/strategy")
159 static GIT_PATH_FUNC(rebase_path_strategy_opts, "rebase-merge/strategy_opts")
160 static GIT_PATH_FUNC(rebase_path_allow_rerere_autoupdate, "rebase-merge/allow_rerere_autoupdate")
161 static GIT_PATH_FUNC(rebase_path_reschedule_failed_exec, "rebase-merge/reschedule-failed-exec")
163 static int git_sequencer_config(const char *k, const char *v, void *cb)
165 struct replay_opts *opts = cb;
168 if (!strcmp(k, "commit.cleanup")) {
171 status = git_config_string(&s, k, v);
175 if (!strcmp(s, "verbatim"))
176 opts->default_msg_cleanup = COMMIT_MSG_CLEANUP_NONE;
177 else if (!strcmp(s, "whitespace"))
178 opts->default_msg_cleanup = COMMIT_MSG_CLEANUP_SPACE;
179 else if (!strcmp(s, "strip"))
180 opts->default_msg_cleanup = COMMIT_MSG_CLEANUP_ALL;
181 else if (!strcmp(s, "scissors"))
182 opts->default_msg_cleanup = COMMIT_MSG_CLEANUP_SPACE;
184 warning(_("invalid commit message cleanup mode '%s'"),
191 if (!strcmp(k, "commit.gpgsign")) {
192 opts->gpg_sign = git_config_bool(k, v) ? xstrdup("") : NULL;
196 status = git_gpg_config(k, v, NULL);
200 return git_diff_basic_config(k, v, NULL);
203 void sequencer_init_config(struct replay_opts *opts)
205 opts->default_msg_cleanup = COMMIT_MSG_CLEANUP_NONE;
206 git_config(git_sequencer_config, opts);
209 static inline int is_rebase_i(const struct replay_opts *opts)
211 return opts->action == REPLAY_INTERACTIVE_REBASE;
214 static const char *get_dir(const struct replay_opts *opts)
216 if (is_rebase_i(opts))
217 return rebase_path();
218 return git_path_seq_dir();
221 static const char *get_todo_path(const struct replay_opts *opts)
223 if (is_rebase_i(opts))
224 return rebase_path_todo();
225 return git_path_todo_file();
229 * Returns 0 for non-conforming footer
230 * Returns 1 for conforming footer
231 * Returns 2 when sob exists within conforming footer
232 * Returns 3 when sob exists within conforming footer as last entry
234 static int has_conforming_footer(struct strbuf *sb, struct strbuf *sob,
235 size_t ignore_footer)
237 struct process_trailer_options opts = PROCESS_TRAILER_OPTIONS_INIT;
238 struct trailer_info info;
240 int found_sob = 0, found_sob_last = 0;
244 trailer_info_get(&info, sb->buf, &opts);
246 if (info.trailer_start == info.trailer_end)
249 for (i = 0; i < info.trailer_nr; i++)
250 if (sob && !strncmp(info.trailers[i], sob->buf, sob->len)) {
252 if (i == info.trailer_nr - 1)
256 trailer_info_release(&info);
265 static const char *gpg_sign_opt_quoted(struct replay_opts *opts)
267 static struct strbuf buf = STRBUF_INIT;
271 sq_quotef(&buf, "-S%s", opts->gpg_sign);
275 int sequencer_remove_state(struct replay_opts *opts)
277 struct strbuf buf = STRBUF_INIT;
280 if (is_rebase_i(opts) &&
281 strbuf_read_file(&buf, rebase_path_refs_to_delete(), 0) > 0) {
284 char *eol = strchr(p, '\n');
287 if (delete_ref("(rebase -i) cleanup", p, NULL, 0) < 0)
288 warning(_("could not delete '%s'"), p);
295 free(opts->gpg_sign);
296 free(opts->strategy);
297 for (i = 0; i < opts->xopts_nr; i++)
298 free(opts->xopts[i]);
300 strbuf_release(&opts->current_fixups);
303 strbuf_addstr(&buf, get_dir(opts));
304 remove_dir_recursively(&buf, 0);
305 strbuf_release(&buf);
310 static const char *action_name(const struct replay_opts *opts)
312 switch (opts->action) {
316 return N_("cherry-pick");
317 case REPLAY_INTERACTIVE_REBASE:
318 return N_("rebase -i");
320 die(_("unknown action: %d"), opts->action);
323 struct commit_message {
330 static const char *short_commit_name(struct commit *commit)
332 return find_unique_abbrev(&commit->object.oid, DEFAULT_ABBREV);
335 static int get_message(struct commit *commit, struct commit_message *out)
337 const char *abbrev, *subject;
340 out->message = logmsg_reencode(commit, NULL, get_commit_output_encoding());
341 abbrev = short_commit_name(commit);
343 subject_len = find_commit_subject(out->message, &subject);
345 out->subject = xmemdupz(subject, subject_len);
346 out->label = xstrfmt("%s... %s", abbrev, out->subject);
347 out->parent_label = xstrfmt("parent of %s", out->label);
352 static void free_message(struct commit *commit, struct commit_message *msg)
354 free(msg->parent_label);
357 unuse_commit_buffer(commit, msg->message);
360 static void print_advice(struct repository *r, int show_hint,
361 struct replay_opts *opts)
363 char *msg = getenv("GIT_CHERRY_PICK_HELP");
366 fprintf(stderr, "%s\n", msg);
368 * A conflict has occurred but the porcelain
369 * (typically rebase --interactive) wants to take care
370 * of the commit itself so remove CHERRY_PICK_HEAD
372 unlink(git_path_cherry_pick_head(r));
378 advise(_("after resolving the conflicts, mark the corrected paths\n"
379 "with 'git add <paths>' or 'git rm <paths>'"));
381 advise(_("after resolving the conflicts, mark the corrected paths\n"
382 "with 'git add <paths>' or 'git rm <paths>'\n"
383 "and commit the result with 'git commit'"));
387 int write_message(const void *buf, size_t len, const char *filename,
390 struct lock_file msg_file = LOCK_INIT;
392 int msg_fd = hold_lock_file_for_update(&msg_file, filename, 0);
394 return error_errno(_("could not lock '%s'"), filename);
395 if (write_in_full(msg_fd, buf, len) < 0) {
396 error_errno(_("could not write to '%s'"), filename);
397 rollback_lock_file(&msg_file);
400 if (append_eol && write(msg_fd, "\n", 1) < 0) {
401 error_errno(_("could not write eol to '%s'"), filename);
402 rollback_lock_file(&msg_file);
405 if (commit_lock_file(&msg_file) < 0)
406 return error(_("failed to finalize '%s'"), filename);
412 * Reads a file that was presumably written by a shell script, i.e. with an
413 * end-of-line marker that needs to be stripped.
415 * Note that only the last end-of-line marker is stripped, consistent with the
416 * behavior of "$(cat path)" in a shell script.
418 * Returns 1 if the file was read, 0 if it could not be read or does not exist.
420 static int read_oneliner(struct strbuf *buf,
421 const char *path, int skip_if_empty)
423 int orig_len = buf->len;
425 if (!file_exists(path))
428 if (strbuf_read_file(buf, path, 0) < 0) {
429 warning_errno(_("could not read '%s'"), path);
433 if (buf->len > orig_len && buf->buf[buf->len - 1] == '\n') {
434 if (--buf->len > orig_len && buf->buf[buf->len - 1] == '\r')
436 buf->buf[buf->len] = '\0';
439 if (skip_if_empty && buf->len == orig_len)
445 static struct tree *empty_tree(struct repository *r)
447 return lookup_tree(r, the_hash_algo->empty_tree);
450 static int error_dirty_index(struct index_state *istate, struct replay_opts *opts)
452 if (read_index_unmerged(istate))
453 return error_resolve_conflict(_(action_name(opts)));
455 error(_("your local changes would be overwritten by %s."),
456 _(action_name(opts)));
458 if (advice_commit_before_merge)
459 advise(_("commit your changes or stash them to proceed."));
463 static void update_abort_safety_file(void)
465 struct object_id head;
467 /* Do nothing on a single-pick */
468 if (!file_exists(git_path_seq_dir()))
471 if (!get_oid("HEAD", &head))
472 write_file(git_path_abort_safety_file(), "%s", oid_to_hex(&head));
474 write_file(git_path_abort_safety_file(), "%s", "");
477 static int fast_forward_to(struct repository *r,
478 const struct object_id *to,
479 const struct object_id *from,
481 struct replay_opts *opts)
483 struct ref_transaction *transaction;
484 struct strbuf sb = STRBUF_INIT;
485 struct strbuf err = STRBUF_INIT;
487 read_index(r->index);
488 if (checkout_fast_forward(r, from, to, 1))
489 return -1; /* the callee should have complained already */
491 strbuf_addf(&sb, _("%s: fast-forward"), _(action_name(opts)));
493 transaction = ref_transaction_begin(&err);
495 ref_transaction_update(transaction, "HEAD",
496 to, unborn && !is_rebase_i(opts) ?
499 ref_transaction_commit(transaction, &err)) {
500 ref_transaction_free(transaction);
501 error("%s", err.buf);
503 strbuf_release(&err);
508 strbuf_release(&err);
509 ref_transaction_free(transaction);
510 update_abort_safety_file();
514 void append_conflicts_hint(struct index_state *istate,
515 struct strbuf *msgbuf)
519 strbuf_addch(msgbuf, '\n');
520 strbuf_commented_addf(msgbuf, "Conflicts:\n");
521 for (i = 0; i < istate->cache_nr;) {
522 const struct cache_entry *ce = istate->cache[i++];
524 strbuf_commented_addf(msgbuf, "\t%s\n", ce->name);
525 while (i < istate->cache_nr &&
526 !strcmp(ce->name, istate->cache[i]->name))
532 static int do_recursive_merge(struct repository *r,
533 struct commit *base, struct commit *next,
534 const char *base_label, const char *next_label,
535 struct object_id *head, struct strbuf *msgbuf,
536 struct replay_opts *opts)
538 struct merge_options o;
539 struct tree *result, *next_tree, *base_tree, *head_tree;
542 struct lock_file index_lock = LOCK_INIT;
544 if (hold_locked_index(&index_lock, LOCK_REPORT_ON_ERROR) < 0)
547 read_index(r->index);
549 init_merge_options(&o);
550 o.ancestor = base ? base_label : "(empty tree)";
552 o.branch2 = next ? next_label : "(empty tree)";
553 if (is_rebase_i(opts))
555 o.show_rename_progress = 1;
557 head_tree = parse_tree_indirect(head);
558 next_tree = next ? get_commit_tree(next) : empty_tree(r);
559 base_tree = base ? get_commit_tree(base) : empty_tree(r);
561 for (xopt = opts->xopts; xopt != opts->xopts + opts->xopts_nr; xopt++)
562 parse_merge_opt(&o, *xopt);
564 clean = merge_trees(&o,
566 next_tree, base_tree, &result);
567 if (is_rebase_i(opts) && clean <= 0)
568 fputs(o.obuf.buf, stdout);
569 strbuf_release(&o.obuf);
570 diff_warn_rename_limit("merge.renamelimit", o.needed_rename_limit, 0);
572 rollback_lock_file(&index_lock);
576 if (write_locked_index(r->index, &index_lock,
577 COMMIT_LOCK | SKIP_IF_UNCHANGED))
579 * TRANSLATORS: %s will be "revert", "cherry-pick" or
582 return error(_("%s: Unable to write new index file"),
583 _(action_name(opts)));
586 append_conflicts_hint(r->index, msgbuf);
591 static struct object_id *get_cache_tree_oid(struct index_state *istate)
593 if (!istate->cache_tree)
594 istate->cache_tree = cache_tree();
596 if (!cache_tree_fully_valid(istate->cache_tree))
597 if (cache_tree_update(istate, 0)) {
598 error(_("unable to update cache tree"));
602 return &istate->cache_tree->oid;
605 static int is_index_unchanged(struct repository *r)
607 struct object_id head_oid, *cache_tree_oid;
608 struct commit *head_commit;
609 struct index_state *istate = r->index;
611 if (!resolve_ref_unsafe("HEAD", RESOLVE_REF_READING, &head_oid, NULL))
612 return error(_("could not resolve HEAD commit"));
614 head_commit = lookup_commit(r, &head_oid);
617 * If head_commit is NULL, check_commit, called from
618 * lookup_commit, would have indicated that head_commit is not
619 * a commit object already. parse_commit() will return failure
620 * without further complaints in such a case. Otherwise, if
621 * the commit is invalid, parse_commit() will complain. So
622 * there is nothing for us to say here. Just return failure.
624 if (parse_commit(head_commit))
627 if (!(cache_tree_oid = get_cache_tree_oid(istate)))
630 return oideq(cache_tree_oid, get_commit_tree_oid(head_commit));
633 static int write_author_script(const char *message)
635 struct strbuf buf = STRBUF_INIT;
640 if (!*message || starts_with(message, "\n")) {
642 /* Missing 'author' line? */
643 unlink(rebase_path_author_script());
645 } else if (skip_prefix(message, "author ", &message))
647 else if ((eol = strchr(message, '\n')))
652 strbuf_addstr(&buf, "GIT_AUTHOR_NAME='");
653 while (*message && *message != '\n' && *message != '\r')
654 if (skip_prefix(message, " <", &message))
656 else if (*message != '\'')
657 strbuf_addch(&buf, *(message++));
659 strbuf_addf(&buf, "'\\%c'", *(message++));
660 strbuf_addstr(&buf, "'\nGIT_AUTHOR_EMAIL='");
661 while (*message && *message != '\n' && *message != '\r')
662 if (skip_prefix(message, "> ", &message))
664 else if (*message != '\'')
665 strbuf_addch(&buf, *(message++));
667 strbuf_addf(&buf, "'\\%c'", *(message++));
668 strbuf_addstr(&buf, "'\nGIT_AUTHOR_DATE='@");
669 while (*message && *message != '\n' && *message != '\r')
670 if (*message != '\'')
671 strbuf_addch(&buf, *(message++));
673 strbuf_addf(&buf, "'\\%c'", *(message++));
674 strbuf_addch(&buf, '\'');
675 res = write_message(buf.buf, buf.len, rebase_path_author_script(), 1);
676 strbuf_release(&buf);
681 * Take a series of KEY='VALUE' lines where VALUE part is
682 * sq-quoted, and append <KEY, VALUE> at the end of the string list
684 static int parse_key_value_squoted(char *buf, struct string_list *list)
687 struct string_list_item *item;
689 char *cp = strchr(buf, '=');
691 np = strchrnul(buf, '\n');
692 return error(_("no key present in '%.*s'"),
693 (int) (np - buf), buf);
695 np = strchrnul(cp, '\n');
697 item = string_list_append(list, buf);
699 buf = np + (*np == '\n');
703 return error(_("unable to dequote value of '%s'"),
705 item->util = xstrdup(cp);
711 * Reads and parses the state directory's "author-script" file, and sets name,
712 * email and date accordingly.
713 * Returns 0 on success, -1 if the file could not be parsed.
715 * The author script is of the format:
717 * GIT_AUTHOR_NAME='$author_name'
718 * GIT_AUTHOR_EMAIL='$author_email'
719 * GIT_AUTHOR_DATE='$author_date'
721 * where $author_name, $author_email and $author_date are quoted. We are strict
722 * with our parsing, as the file was meant to be eval'd in the old
723 * git-am.sh/git-rebase--interactive.sh scripts, and thus if the file differs
724 * from what this function expects, it is better to bail out than to do
725 * something that the user does not expect.
727 int read_author_script(const char *path, char **name, char **email, char **date,
730 struct strbuf buf = STRBUF_INIT;
731 struct string_list kv = STRING_LIST_INIT_DUP;
732 int retval = -1; /* assume failure */
733 int i, name_i = -2, email_i = -2, date_i = -2, err = 0;
735 if (strbuf_read_file(&buf, path, 256) <= 0) {
736 strbuf_release(&buf);
737 if (errno == ENOENT && allow_missing)
740 return error_errno(_("could not open '%s' for reading"),
744 if (parse_key_value_squoted(buf.buf, &kv))
747 for (i = 0; i < kv.nr; i++) {
748 if (!strcmp(kv.items[i].string, "GIT_AUTHOR_NAME")) {
750 name_i = error(_("'GIT_AUTHOR_NAME' already given"));
753 } else if (!strcmp(kv.items[i].string, "GIT_AUTHOR_EMAIL")) {
755 email_i = error(_("'GIT_AUTHOR_EMAIL' already given"));
758 } else if (!strcmp(kv.items[i].string, "GIT_AUTHOR_DATE")) {
760 date_i = error(_("'GIT_AUTHOR_DATE' already given"));
764 err = error(_("unknown variable '%s'"),
769 error(_("missing 'GIT_AUTHOR_NAME'"));
771 error(_("missing 'GIT_AUTHOR_EMAIL'"));
773 error(_("missing 'GIT_AUTHOR_DATE'"));
774 if (date_i < 0 || email_i < 0 || date_i < 0 || err)
776 *name = kv.items[name_i].util;
777 *email = kv.items[email_i].util;
778 *date = kv.items[date_i].util;
781 string_list_clear(&kv, !!retval);
782 strbuf_release(&buf);
787 * Read a GIT_AUTHOR_NAME, GIT_AUTHOR_EMAIL AND GIT_AUTHOR_DATE from a
788 * file with shell quoting into struct argv_array. Returns -1 on
789 * error, 0 otherwise.
791 static int read_env_script(struct argv_array *env)
793 char *name, *email, *date;
795 if (read_author_script(rebase_path_author_script(),
796 &name, &email, &date, 0))
799 argv_array_pushf(env, "GIT_AUTHOR_NAME=%s", name);
800 argv_array_pushf(env, "GIT_AUTHOR_EMAIL=%s", email);
801 argv_array_pushf(env, "GIT_AUTHOR_DATE=%s", date);
809 static char *get_author(const char *message)
814 a = find_commit_header(message, "author", &len);
816 return xmemdupz(a, len);
821 /* Read author-script and return an ident line (author <email> timestamp) */
822 static const char *read_author_ident(struct strbuf *buf)
824 struct strbuf out = STRBUF_INIT;
825 char *name, *email, *date;
827 if (read_author_script(rebase_path_author_script(),
828 &name, &email, &date, 0))
831 /* validate date since fmt_ident() will die() on bad value */
832 if (parse_date(date, &out)){
833 warning(_("invalid date format '%s' in '%s'"),
834 date, rebase_path_author_script());
835 strbuf_release(&out);
840 strbuf_addstr(&out, fmt_ident(name, email, date, 0));
841 strbuf_swap(buf, &out);
842 strbuf_release(&out);
849 static const char staged_changes_advice[] =
850 N_("you have staged changes in your working tree\n"
851 "If these changes are meant to be squashed into the previous commit, run:\n"
853 " git commit --amend %s\n"
855 "If they are meant to go into a new commit, run:\n"
859 "In both cases, once you're done, continue with:\n"
861 " git rebase --continue\n");
863 #define ALLOW_EMPTY (1<<0)
864 #define EDIT_MSG (1<<1)
865 #define AMEND_MSG (1<<2)
866 #define CLEANUP_MSG (1<<3)
867 #define VERIFY_MSG (1<<4)
868 #define CREATE_ROOT_COMMIT (1<<5)
870 static int run_command_silent_on_success(struct child_process *cmd)
872 struct strbuf buf = STRBUF_INIT;
875 cmd->stdout_to_stderr = 1;
876 rc = pipe_command(cmd,
882 fputs(buf.buf, stderr);
883 strbuf_release(&buf);
888 * If we are cherry-pick, and if the merge did not result in
889 * hand-editing, we will hit this commit and inherit the original
890 * author date and name.
892 * If we are revert, or if our cherry-pick results in a hand merge,
893 * we had better say that the current user is responsible for that.
895 * An exception is when run_git_commit() is called during an
896 * interactive rebase: in that case, we will want to retain the
899 static int run_git_commit(struct repository *r,
901 struct replay_opts *opts,
904 struct child_process cmd = CHILD_PROCESS_INIT;
907 if ((flags & CREATE_ROOT_COMMIT) && !(flags & AMEND_MSG)) {
908 struct strbuf msg = STRBUF_INIT, script = STRBUF_INIT;
909 const char *author = NULL;
910 struct object_id root_commit, *cache_tree_oid;
913 if (is_rebase_i(opts)) {
914 author = read_author_ident(&script);
916 strbuf_release(&script);
922 BUG("root commit without message");
924 if (!(cache_tree_oid = get_cache_tree_oid(r->index)))
928 res = strbuf_read_file(&msg, defmsg, 0);
931 res = error_errno(_("could not read '%s'"), defmsg);
933 res = commit_tree(msg.buf, msg.len, cache_tree_oid,
934 NULL, &root_commit, author,
937 strbuf_release(&msg);
938 strbuf_release(&script);
940 update_ref(NULL, "CHERRY_PICK_HEAD", &root_commit, NULL,
941 REF_NO_DEREF, UPDATE_REFS_MSG_ON_ERR);
942 res = update_ref(NULL, "HEAD", &root_commit, NULL, 0,
943 UPDATE_REFS_MSG_ON_ERR);
945 return res < 0 ? error(_("writing root commit")) : 0;
950 if (is_rebase_i(opts) && read_env_script(&cmd.env_array)) {
951 const char *gpg_opt = gpg_sign_opt_quoted(opts);
953 return error(_(staged_changes_advice),
957 argv_array_push(&cmd.args, "commit");
959 if (!(flags & VERIFY_MSG))
960 argv_array_push(&cmd.args, "-n");
961 if ((flags & AMEND_MSG))
962 argv_array_push(&cmd.args, "--amend");
964 argv_array_pushf(&cmd.args, "-S%s", opts->gpg_sign);
966 argv_array_pushl(&cmd.args, "-F", defmsg, NULL);
967 else if (!(flags & EDIT_MSG))
968 argv_array_pushl(&cmd.args, "-C", "HEAD", NULL);
969 if ((flags & CLEANUP_MSG))
970 argv_array_push(&cmd.args, "--cleanup=strip");
971 if ((flags & EDIT_MSG))
972 argv_array_push(&cmd.args, "-e");
973 else if (!(flags & CLEANUP_MSG) &&
974 !opts->signoff && !opts->record_origin &&
975 git_config_get_value("commit.cleanup", &value))
976 argv_array_push(&cmd.args, "--cleanup=verbatim");
978 if ((flags & ALLOW_EMPTY))
979 argv_array_push(&cmd.args, "--allow-empty");
981 if (!(flags & EDIT_MSG))
982 argv_array_push(&cmd.args, "--allow-empty-message");
984 if (is_rebase_i(opts) && !(flags & EDIT_MSG))
985 return run_command_silent_on_success(&cmd);
987 return run_command(&cmd);
990 static int rest_is_empty(const struct strbuf *sb, int start)
995 /* Check if the rest is just whitespace and Signed-off-by's. */
996 for (i = start; i < sb->len; i++) {
997 nl = memchr(sb->buf + i, '\n', sb->len - i);
1003 if (strlen(sign_off_header) <= eol - i &&
1004 starts_with(sb->buf + i, sign_off_header)) {
1009 if (!isspace(sb->buf[i++]))
1017 * Find out if the message in the strbuf contains only whitespace and
1018 * Signed-off-by lines.
1020 int message_is_empty(const struct strbuf *sb,
1021 enum commit_msg_cleanup_mode cleanup_mode)
1023 if (cleanup_mode == COMMIT_MSG_CLEANUP_NONE && sb->len)
1025 return rest_is_empty(sb, 0);
1029 * See if the user edited the message in the editor or left what
1030 * was in the template intact
1032 int template_untouched(const struct strbuf *sb, const char *template_file,
1033 enum commit_msg_cleanup_mode cleanup_mode)
1035 struct strbuf tmpl = STRBUF_INIT;
1038 if (cleanup_mode == COMMIT_MSG_CLEANUP_NONE && sb->len)
1041 if (!template_file || strbuf_read_file(&tmpl, template_file, 0) <= 0)
1044 strbuf_stripspace(&tmpl, cleanup_mode == COMMIT_MSG_CLEANUP_ALL);
1045 if (!skip_prefix(sb->buf, tmpl.buf, &start))
1047 strbuf_release(&tmpl);
1048 return rest_is_empty(sb, start - sb->buf);
1051 int update_head_with_reflog(const struct commit *old_head,
1052 const struct object_id *new_head,
1053 const char *action, const struct strbuf *msg,
1056 struct ref_transaction *transaction;
1057 struct strbuf sb = STRBUF_INIT;
1062 strbuf_addstr(&sb, action);
1063 strbuf_addstr(&sb, ": ");
1066 nl = strchr(msg->buf, '\n');
1068 strbuf_add(&sb, msg->buf, nl + 1 - msg->buf);
1070 strbuf_addbuf(&sb, msg);
1071 strbuf_addch(&sb, '\n');
1074 transaction = ref_transaction_begin(err);
1076 ref_transaction_update(transaction, "HEAD", new_head,
1077 old_head ? &old_head->object.oid : &null_oid,
1079 ref_transaction_commit(transaction, err)) {
1082 ref_transaction_free(transaction);
1083 strbuf_release(&sb);
1088 static int run_rewrite_hook(const struct object_id *oldoid,
1089 const struct object_id *newoid)
1091 struct child_process proc = CHILD_PROCESS_INIT;
1092 const char *argv[3];
1094 struct strbuf sb = STRBUF_INIT;
1096 argv[0] = find_hook("post-rewrite");
1105 proc.stdout_to_stderr = 1;
1107 code = start_command(&proc);
1110 strbuf_addf(&sb, "%s %s\n", oid_to_hex(oldoid), oid_to_hex(newoid));
1111 sigchain_push(SIGPIPE, SIG_IGN);
1112 write_in_full(proc.in, sb.buf, sb.len);
1114 strbuf_release(&sb);
1115 sigchain_pop(SIGPIPE);
1116 return finish_command(&proc);
1119 void commit_post_rewrite(const struct commit *old_head,
1120 const struct object_id *new_head)
1122 struct notes_rewrite_cfg *cfg;
1124 cfg = init_copy_notes_for_rewrite("amend");
1126 /* we are amending, so old_head is not NULL */
1127 copy_note_for_rewrite(cfg, &old_head->object.oid, new_head);
1128 finish_copy_notes_for_rewrite(cfg, "Notes added by 'git commit --amend'");
1130 run_rewrite_hook(&old_head->object.oid, new_head);
1133 static int run_prepare_commit_msg_hook(struct repository *r,
1137 struct argv_array hook_env = ARGV_ARRAY_INIT;
1141 name = git_path_commit_editmsg();
1142 if (write_message(msg->buf, msg->len, name, 0))
1145 argv_array_pushf(&hook_env, "GIT_INDEX_FILE=%s", r->index_file);
1146 argv_array_push(&hook_env, "GIT_EDITOR=:");
1148 ret = run_hook_le(hook_env.argv, "prepare-commit-msg", name,
1149 "commit", commit, NULL);
1151 ret = run_hook_le(hook_env.argv, "prepare-commit-msg", name,
1154 ret = error(_("'prepare-commit-msg' hook failed"));
1155 argv_array_clear(&hook_env);
1160 static const char implicit_ident_advice_noconfig[] =
1161 N_("Your name and email address were configured automatically based\n"
1162 "on your username and hostname. Please check that they are accurate.\n"
1163 "You can suppress this message by setting them explicitly. Run the\n"
1164 "following command and follow the instructions in your editor to edit\n"
1165 "your configuration file:\n"
1167 " git config --global --edit\n"
1169 "After doing this, you may fix the identity used for this commit with:\n"
1171 " git commit --amend --reset-author\n");
1173 static const char implicit_ident_advice_config[] =
1174 N_("Your name and email address were configured automatically based\n"
1175 "on your username and hostname. Please check that they are accurate.\n"
1176 "You can suppress this message by setting them explicitly:\n"
1178 " git config --global user.name \"Your Name\"\n"
1179 " git config --global user.email you@example.com\n"
1181 "After doing this, you may fix the identity used for this commit with:\n"
1183 " git commit --amend --reset-author\n");
1185 static const char *implicit_ident_advice(void)
1187 char *user_config = expand_user_path("~/.gitconfig", 0);
1188 char *xdg_config = xdg_config_home("config");
1189 int config_exists = file_exists(user_config) || file_exists(xdg_config);
1195 return _(implicit_ident_advice_config);
1197 return _(implicit_ident_advice_noconfig);
1201 void print_commit_summary(struct repository *r,
1203 const struct object_id *oid,
1206 struct rev_info rev;
1207 struct commit *commit;
1208 struct strbuf format = STRBUF_INIT;
1210 struct pretty_print_context pctx = {0};
1211 struct strbuf author_ident = STRBUF_INIT;
1212 struct strbuf committer_ident = STRBUF_INIT;
1214 commit = lookup_commit(r, oid);
1216 die(_("couldn't look up newly created commit"));
1217 if (parse_commit(commit))
1218 die(_("could not parse newly created commit"));
1220 strbuf_addstr(&format, "format:%h] %s");
1222 format_commit_message(commit, "%an <%ae>", &author_ident, &pctx);
1223 format_commit_message(commit, "%cn <%ce>", &committer_ident, &pctx);
1224 if (strbuf_cmp(&author_ident, &committer_ident)) {
1225 strbuf_addstr(&format, "\n Author: ");
1226 strbuf_addbuf_percentquote(&format, &author_ident);
1228 if (flags & SUMMARY_SHOW_AUTHOR_DATE) {
1229 struct strbuf date = STRBUF_INIT;
1231 format_commit_message(commit, "%ad", &date, &pctx);
1232 strbuf_addstr(&format, "\n Date: ");
1233 strbuf_addbuf_percentquote(&format, &date);
1234 strbuf_release(&date);
1236 if (!committer_ident_sufficiently_given()) {
1237 strbuf_addstr(&format, "\n Committer: ");
1238 strbuf_addbuf_percentquote(&format, &committer_ident);
1239 if (advice_implicit_identity) {
1240 strbuf_addch(&format, '\n');
1241 strbuf_addstr(&format, implicit_ident_advice());
1244 strbuf_release(&author_ident);
1245 strbuf_release(&committer_ident);
1247 repo_init_revisions(r, &rev, prefix);
1248 setup_revisions(0, NULL, &rev, NULL);
1251 rev.diffopt.output_format =
1252 DIFF_FORMAT_SHORTSTAT | DIFF_FORMAT_SUMMARY;
1254 rev.verbose_header = 1;
1255 rev.show_root_diff = 1;
1256 get_commit_format(format.buf, &rev);
1257 rev.always_show_header = 0;
1258 rev.diffopt.detect_rename = DIFF_DETECT_RENAME;
1259 rev.diffopt.break_opt = 0;
1260 diff_setup_done(&rev.diffopt);
1262 head = resolve_ref_unsafe("HEAD", 0, NULL, NULL);
1264 die_errno(_("unable to resolve HEAD after creating commit"));
1265 if (!strcmp(head, "HEAD"))
1266 head = _("detached HEAD");
1268 skip_prefix(head, "refs/heads/", &head);
1269 printf("[%s%s ", head, (flags & SUMMARY_INITIAL_COMMIT) ?
1270 _(" (root-commit)") : "");
1272 if (!log_tree_commit(&rev, commit)) {
1273 rev.always_show_header = 1;
1274 rev.use_terminator = 1;
1275 log_tree_commit(&rev, commit);
1278 strbuf_release(&format);
1281 static int parse_head(struct repository *r, struct commit **head)
1283 struct commit *current_head;
1284 struct object_id oid;
1286 if (get_oid("HEAD", &oid)) {
1287 current_head = NULL;
1289 current_head = lookup_commit_reference(r, &oid);
1291 return error(_("could not parse HEAD"));
1292 if (!oideq(&oid, ¤t_head->object.oid)) {
1293 warning(_("HEAD %s is not a commit!"),
1296 if (parse_commit(current_head))
1297 return error(_("could not parse HEAD commit"));
1299 *head = current_head;
1305 * Try to commit without forking 'git commit'. In some cases we need
1306 * to run 'git commit' to display an error message
1309 * -1 - error unable to commit
1311 * 1 - run 'git commit'
1313 static int try_to_commit(struct repository *r,
1314 struct strbuf *msg, const char *author,
1315 struct replay_opts *opts, unsigned int flags,
1316 struct object_id *oid)
1318 struct object_id tree;
1319 struct commit *current_head;
1320 struct commit_list *parents = NULL;
1321 struct commit_extra_header *extra = NULL;
1322 struct strbuf err = STRBUF_INIT;
1323 struct strbuf commit_msg = STRBUF_INIT;
1324 char *amend_author = NULL;
1325 const char *hook_commit = NULL;
1326 enum commit_msg_cleanup_mode cleanup;
1329 if (parse_head(r, ¤t_head))
1332 if (flags & AMEND_MSG) {
1333 const char *exclude_gpgsig[] = { "gpgsig", NULL };
1334 const char *out_enc = get_commit_output_encoding();
1335 const char *message = logmsg_reencode(current_head, NULL,
1339 const char *orig_message = NULL;
1341 find_commit_subject(message, &orig_message);
1343 strbuf_addstr(msg, orig_message);
1344 hook_commit = "HEAD";
1346 author = amend_author = get_author(message);
1347 unuse_commit_buffer(current_head, message);
1349 res = error(_("unable to parse commit author"));
1352 parents = copy_commit_list(current_head->parents);
1353 extra = read_commit_extra_headers(current_head, exclude_gpgsig);
1354 } else if (current_head) {
1355 commit_list_insert(current_head, &parents);
1358 if (write_index_as_tree(&tree, r->index, r->index_file, 0, NULL)) {
1359 res = error(_("git write-tree failed to write a tree"));
1363 if (!(flags & ALLOW_EMPTY) && oideq(current_head ?
1364 get_commit_tree_oid(current_head) :
1365 the_hash_algo->empty_tree, &tree)) {
1366 res = 1; /* run 'git commit' to display error message */
1370 if (find_hook("prepare-commit-msg")) {
1371 res = run_prepare_commit_msg_hook(r, msg, hook_commit);
1374 if (strbuf_read_file(&commit_msg, git_path_commit_editmsg(),
1376 res = error_errno(_("unable to read commit message "
1378 git_path_commit_editmsg());
1384 cleanup = (flags & CLEANUP_MSG) ? COMMIT_MSG_CLEANUP_ALL :
1385 opts->default_msg_cleanup;
1387 if (cleanup != COMMIT_MSG_CLEANUP_NONE)
1388 strbuf_stripspace(msg, cleanup == COMMIT_MSG_CLEANUP_ALL);
1389 if ((flags & EDIT_MSG) && message_is_empty(msg, cleanup)) {
1390 res = 1; /* run 'git commit' to display error message */
1396 if (commit_tree_extended(msg->buf, msg->len, &tree, parents,
1397 oid, author, opts->gpg_sign, extra)) {
1398 res = error(_("failed to write commit object"));
1402 if (update_head_with_reflog(current_head, oid,
1403 getenv("GIT_REFLOG_ACTION"), msg, &err)) {
1404 res = error("%s", err.buf);
1408 if (flags & AMEND_MSG)
1409 commit_post_rewrite(current_head, oid);
1412 free_commit_extra_headers(extra);
1413 strbuf_release(&err);
1414 strbuf_release(&commit_msg);
1420 static int do_commit(struct repository *r,
1421 const char *msg_file, const char *author,
1422 struct replay_opts *opts, unsigned int flags)
1426 if (!(flags & EDIT_MSG) && !(flags & VERIFY_MSG) &&
1427 !(flags & CREATE_ROOT_COMMIT)) {
1428 struct object_id oid;
1429 struct strbuf sb = STRBUF_INIT;
1431 if (msg_file && strbuf_read_file(&sb, msg_file, 2048) < 0)
1432 return error_errno(_("unable to read commit message "
1436 res = try_to_commit(r, msg_file ? &sb : NULL,
1437 author, opts, flags, &oid);
1438 strbuf_release(&sb);
1440 unlink(git_path_cherry_pick_head(r));
1441 unlink(git_path_merge_msg(r));
1442 if (!is_rebase_i(opts))
1443 print_commit_summary(r, NULL, &oid,
1444 SUMMARY_SHOW_AUTHOR_DATE);
1449 return run_git_commit(r, msg_file, opts, flags);
1454 static int is_original_commit_empty(struct commit *commit)
1456 const struct object_id *ptree_oid;
1458 if (parse_commit(commit))
1459 return error(_("could not parse commit %s"),
1460 oid_to_hex(&commit->object.oid));
1461 if (commit->parents) {
1462 struct commit *parent = commit->parents->item;
1463 if (parse_commit(parent))
1464 return error(_("could not parse parent commit %s"),
1465 oid_to_hex(&parent->object.oid));
1466 ptree_oid = get_commit_tree_oid(parent);
1468 ptree_oid = the_hash_algo->empty_tree; /* commit is root */
1471 return oideq(ptree_oid, get_commit_tree_oid(commit));
1475 * Do we run "git commit" with "--allow-empty"?
1477 static int allow_empty(struct repository *r,
1478 struct replay_opts *opts,
1479 struct commit *commit)
1481 int index_unchanged, empty_commit;
1486 * (1) we do not allow empty at all and error out.
1488 * (2) we allow ones that were initially empty, but
1489 * forbid the ones that become empty;
1491 * (3) we allow both.
1493 if (!opts->allow_empty)
1494 return 0; /* let "git commit" barf as necessary */
1496 index_unchanged = is_index_unchanged(r);
1497 if (index_unchanged < 0)
1498 return index_unchanged;
1499 if (!index_unchanged)
1500 return 0; /* we do not have to say --allow-empty */
1502 if (opts->keep_redundant_commits)
1505 empty_commit = is_original_commit_empty(commit);
1506 if (empty_commit < 0)
1507 return empty_commit;
1515 * Note that ordering matters in this enum. Not only must it match the mapping
1516 * below, it is also divided into several sections that matter. When adding
1517 * new commands, make sure you add it in the right section.
1520 /* commands that handle commits */
1527 /* commands that do something else than handling a single commit */
1533 /* commands that do nothing but are counted for reporting progress */
1536 /* comments (not counted for reporting progress) */
1543 } todo_command_info[] = {
1560 static const char *command_to_string(const enum todo_command command)
1562 if (command < TODO_COMMENT)
1563 return todo_command_info[command].str;
1564 die(_("unknown command: %d"), command);
1567 static char command_to_char(const enum todo_command command)
1569 if (command < TODO_COMMENT && todo_command_info[command].c)
1570 return todo_command_info[command].c;
1571 return comment_line_char;
1574 static int is_noop(const enum todo_command command)
1576 return TODO_NOOP <= command;
1579 static int is_fixup(enum todo_command command)
1581 return command == TODO_FIXUP || command == TODO_SQUASH;
1584 /* Does this command create a (non-merge) commit? */
1585 static int is_pick_or_similar(enum todo_command command)
1600 static int update_squash_messages(struct repository *r,
1601 enum todo_command command,
1602 struct commit *commit,
1603 struct replay_opts *opts)
1605 struct strbuf buf = STRBUF_INIT;
1607 const char *message, *body;
1609 if (opts->current_fixup_count > 0) {
1610 struct strbuf header = STRBUF_INIT;
1613 if (strbuf_read_file(&buf, rebase_path_squash_msg(), 9) <= 0)
1614 return error(_("could not read '%s'"),
1615 rebase_path_squash_msg());
1617 eol = buf.buf[0] != comment_line_char ?
1618 buf.buf : strchrnul(buf.buf, '\n');
1620 strbuf_addf(&header, "%c ", comment_line_char);
1621 strbuf_addf(&header, _("This is a combination of %d commits."),
1622 opts->current_fixup_count + 2);
1623 strbuf_splice(&buf, 0, eol - buf.buf, header.buf, header.len);
1624 strbuf_release(&header);
1626 struct object_id head;
1627 struct commit *head_commit;
1628 const char *head_message, *body;
1630 if (get_oid("HEAD", &head))
1631 return error(_("need a HEAD to fixup"));
1632 if (!(head_commit = lookup_commit_reference(r, &head)))
1633 return error(_("could not read HEAD"));
1634 if (!(head_message = get_commit_buffer(head_commit, NULL)))
1635 return error(_("could not read HEAD's commit message"));
1637 find_commit_subject(head_message, &body);
1638 if (write_message(body, strlen(body),
1639 rebase_path_fixup_msg(), 0)) {
1640 unuse_commit_buffer(head_commit, head_message);
1641 return error(_("cannot write '%s'"),
1642 rebase_path_fixup_msg());
1645 strbuf_addf(&buf, "%c ", comment_line_char);
1646 strbuf_addf(&buf, _("This is a combination of %d commits."), 2);
1647 strbuf_addf(&buf, "\n%c ", comment_line_char);
1648 strbuf_addstr(&buf, _("This is the 1st commit message:"));
1649 strbuf_addstr(&buf, "\n\n");
1650 strbuf_addstr(&buf, body);
1652 unuse_commit_buffer(head_commit, head_message);
1655 if (!(message = get_commit_buffer(commit, NULL)))
1656 return error(_("could not read commit message of %s"),
1657 oid_to_hex(&commit->object.oid));
1658 find_commit_subject(message, &body);
1660 if (command == TODO_SQUASH) {
1661 unlink(rebase_path_fixup_msg());
1662 strbuf_addf(&buf, "\n%c ", comment_line_char);
1663 strbuf_addf(&buf, _("This is the commit message #%d:"),
1664 ++opts->current_fixup_count + 1);
1665 strbuf_addstr(&buf, "\n\n");
1666 strbuf_addstr(&buf, body);
1667 } else if (command == TODO_FIXUP) {
1668 strbuf_addf(&buf, "\n%c ", comment_line_char);
1669 strbuf_addf(&buf, _("The commit message #%d will be skipped:"),
1670 ++opts->current_fixup_count + 1);
1671 strbuf_addstr(&buf, "\n\n");
1672 strbuf_add_commented_lines(&buf, body, strlen(body));
1674 return error(_("unknown command: %d"), command);
1675 unuse_commit_buffer(commit, message);
1677 res = write_message(buf.buf, buf.len, rebase_path_squash_msg(), 0);
1678 strbuf_release(&buf);
1681 strbuf_addf(&opts->current_fixups, "%s%s %s",
1682 opts->current_fixups.len ? "\n" : "",
1683 command_to_string(command),
1684 oid_to_hex(&commit->object.oid));
1685 res = write_message(opts->current_fixups.buf,
1686 opts->current_fixups.len,
1687 rebase_path_current_fixups(), 0);
1693 static void flush_rewritten_pending(void)
1695 struct strbuf buf = STRBUF_INIT;
1696 struct object_id newoid;
1699 if (strbuf_read_file(&buf, rebase_path_rewritten_pending(), (GIT_MAX_HEXSZ + 1) * 2) > 0 &&
1700 !get_oid("HEAD", &newoid) &&
1701 (out = fopen_or_warn(rebase_path_rewritten_list(), "a"))) {
1702 char *bol = buf.buf, *eol;
1705 eol = strchrnul(bol, '\n');
1706 fprintf(out, "%.*s %s\n", (int)(eol - bol),
1707 bol, oid_to_hex(&newoid));
1713 unlink(rebase_path_rewritten_pending());
1715 strbuf_release(&buf);
1718 static void record_in_rewritten(struct object_id *oid,
1719 enum todo_command next_command)
1721 FILE *out = fopen_or_warn(rebase_path_rewritten_pending(), "a");
1726 fprintf(out, "%s\n", oid_to_hex(oid));
1729 if (!is_fixup(next_command))
1730 flush_rewritten_pending();
1733 static int do_pick_commit(struct repository *r,
1734 enum todo_command command,
1735 struct commit *commit,
1736 struct replay_opts *opts,
1739 unsigned int flags = opts->edit ? EDIT_MSG : 0;
1740 const char *msg_file = opts->edit ? NULL : git_path_merge_msg(r);
1741 struct object_id head;
1742 struct commit *base, *next, *parent;
1743 const char *base_label, *next_label;
1744 char *author = NULL;
1745 struct commit_message msg = { NULL, NULL, NULL, NULL };
1746 struct strbuf msgbuf = STRBUF_INIT;
1747 int res, unborn = 0, allow;
1749 if (opts->no_commit) {
1751 * We do not intend to commit immediately. We just want to
1752 * merge the differences in, so let's compute the tree
1753 * that represents the "current" state for merge-recursive
1756 if (write_index_as_tree(&head, r->index, r->index_file, 0, NULL))
1757 return error(_("your index file is unmerged."));
1759 unborn = get_oid("HEAD", &head);
1760 /* Do we want to generate a root commit? */
1761 if (is_pick_or_similar(command) && opts->have_squash_onto &&
1762 oideq(&head, &opts->squash_onto)) {
1763 if (is_fixup(command))
1764 return error(_("cannot fixup root commit"));
1765 flags |= CREATE_ROOT_COMMIT;
1768 oidcpy(&head, the_hash_algo->empty_tree);
1769 if (index_differs_from(r, unborn ? empty_tree_oid_hex() : "HEAD",
1771 return error_dirty_index(r->index, opts);
1773 discard_index(r->index);
1775 if (!commit->parents)
1777 else if (commit->parents->next) {
1778 /* Reverting or cherry-picking a merge commit */
1780 struct commit_list *p;
1782 if (!opts->mainline)
1783 return error(_("commit %s is a merge but no -m option was given."),
1784 oid_to_hex(&commit->object.oid));
1786 for (cnt = 1, p = commit->parents;
1787 cnt != opts->mainline && p;
1790 if (cnt != opts->mainline || !p)
1791 return error(_("commit %s does not have parent %d"),
1792 oid_to_hex(&commit->object.oid), opts->mainline);
1794 } else if (1 < opts->mainline)
1796 * Non-first parent explicitly specified as mainline for
1799 return error(_("commit %s does not have parent %d"),
1800 oid_to_hex(&commit->object.oid), opts->mainline);
1802 parent = commit->parents->item;
1804 if (get_message(commit, &msg) != 0)
1805 return error(_("cannot get commit message for %s"),
1806 oid_to_hex(&commit->object.oid));
1808 if (opts->allow_ff && !is_fixup(command) &&
1809 ((parent && oideq(&parent->object.oid, &head)) ||
1810 (!parent && unborn))) {
1811 if (is_rebase_i(opts))
1812 write_author_script(msg.message);
1813 res = fast_forward_to(r, &commit->object.oid, &head, unborn,
1815 if (res || command != TODO_REWORD)
1817 flags |= EDIT_MSG | AMEND_MSG | VERIFY_MSG;
1819 goto fast_forward_edit;
1821 if (parent && parse_commit(parent) < 0)
1822 /* TRANSLATORS: The first %s will be a "todo" command like
1823 "revert" or "pick", the second %s a SHA1. */
1824 return error(_("%s: cannot parse parent commit %s"),
1825 command_to_string(command),
1826 oid_to_hex(&parent->object.oid));
1829 * "commit" is an existing commit. We would want to apply
1830 * the difference it introduces since its first parent "prev"
1831 * on top of the current HEAD if we are cherry-pick. Or the
1832 * reverse of it if we are revert.
1835 if (command == TODO_REVERT) {
1837 base_label = msg.label;
1839 next_label = msg.parent_label;
1840 strbuf_addstr(&msgbuf, "Revert \"");
1841 strbuf_addstr(&msgbuf, msg.subject);
1842 strbuf_addstr(&msgbuf, "\"\n\nThis reverts commit ");
1843 strbuf_addstr(&msgbuf, oid_to_hex(&commit->object.oid));
1845 if (commit->parents && commit->parents->next) {
1846 strbuf_addstr(&msgbuf, ", reversing\nchanges made to ");
1847 strbuf_addstr(&msgbuf, oid_to_hex(&parent->object.oid));
1849 strbuf_addstr(&msgbuf, ".\n");
1854 base_label = msg.parent_label;
1856 next_label = msg.label;
1858 /* Append the commit log message to msgbuf. */
1859 if (find_commit_subject(msg.message, &p))
1860 strbuf_addstr(&msgbuf, p);
1862 if (opts->record_origin) {
1863 strbuf_complete_line(&msgbuf);
1864 if (!has_conforming_footer(&msgbuf, NULL, 0))
1865 strbuf_addch(&msgbuf, '\n');
1866 strbuf_addstr(&msgbuf, cherry_picked_prefix);
1867 strbuf_addstr(&msgbuf, oid_to_hex(&commit->object.oid));
1868 strbuf_addstr(&msgbuf, ")\n");
1870 if (!is_fixup(command))
1871 author = get_author(msg.message);
1874 if (command == TODO_REWORD)
1875 flags |= EDIT_MSG | VERIFY_MSG;
1876 else if (is_fixup(command)) {
1877 if (update_squash_messages(r, command, commit, opts))
1881 msg_file = rebase_path_squash_msg();
1882 else if (file_exists(rebase_path_fixup_msg())) {
1883 flags |= CLEANUP_MSG;
1884 msg_file = rebase_path_fixup_msg();
1886 const char *dest = git_path_squash_msg(r);
1888 if (copy_file(dest, rebase_path_squash_msg(), 0666))
1889 return error(_("could not rename '%s' to '%s'"),
1890 rebase_path_squash_msg(), dest);
1891 unlink(git_path_merge_msg(r));
1897 if (opts->signoff && !is_fixup(command))
1898 append_signoff(&msgbuf, 0, 0);
1900 if (is_rebase_i(opts) && write_author_script(msg.message) < 0)
1902 else if (!opts->strategy || !strcmp(opts->strategy, "recursive") || command == TODO_REVERT) {
1903 res = do_recursive_merge(r, base, next, base_label, next_label,
1904 &head, &msgbuf, opts);
1908 res |= write_message(msgbuf.buf, msgbuf.len,
1909 git_path_merge_msg(r), 0);
1911 struct commit_list *common = NULL;
1912 struct commit_list *remotes = NULL;
1914 res = write_message(msgbuf.buf, msgbuf.len,
1915 git_path_merge_msg(r), 0);
1917 commit_list_insert(base, &common);
1918 commit_list_insert(next, &remotes);
1919 res |= try_merge_command(r, opts->strategy,
1920 opts->xopts_nr, (const char **)opts->xopts,
1921 common, oid_to_hex(&head), remotes);
1922 free_commit_list(common);
1923 free_commit_list(remotes);
1925 strbuf_release(&msgbuf);
1928 * If the merge was clean or if it failed due to conflict, we write
1929 * CHERRY_PICK_HEAD for the subsequent invocation of commit to use.
1930 * However, if the merge did not even start, then we don't want to
1933 if (command == TODO_PICK && !opts->no_commit && (res == 0 || res == 1) &&
1934 update_ref(NULL, "CHERRY_PICK_HEAD", &commit->object.oid, NULL,
1935 REF_NO_DEREF, UPDATE_REFS_MSG_ON_ERR))
1937 if (command == TODO_REVERT && ((opts->no_commit && res == 0) || res == 1) &&
1938 update_ref(NULL, "REVERT_HEAD", &commit->object.oid, NULL,
1939 REF_NO_DEREF, UPDATE_REFS_MSG_ON_ERR))
1943 error(command == TODO_REVERT
1944 ? _("could not revert %s... %s")
1945 : _("could not apply %s... %s"),
1946 short_commit_name(commit), msg.subject);
1947 print_advice(r, res == 1, opts);
1948 repo_rerere(r, opts->allow_rerere_auto);
1952 allow = allow_empty(r, opts, commit);
1957 flags |= ALLOW_EMPTY;
1958 if (!opts->no_commit) {
1960 if (author || command == TODO_REVERT || (flags & AMEND_MSG))
1961 res = do_commit(r, msg_file, author, opts, flags);
1963 res = error(_("unable to parse commit author"));
1966 if (!res && final_fixup) {
1967 unlink(rebase_path_fixup_msg());
1968 unlink(rebase_path_squash_msg());
1969 unlink(rebase_path_current_fixups());
1970 strbuf_reset(&opts->current_fixups);
1971 opts->current_fixup_count = 0;
1975 free_message(commit, &msg);
1977 update_abort_safety_file();
1982 static int prepare_revs(struct replay_opts *opts)
1985 * picking (but not reverting) ranges (but not individual revisions)
1986 * should be done in reverse
1988 if (opts->action == REPLAY_PICK && !opts->revs->no_walk)
1989 opts->revs->reverse ^= 1;
1991 if (prepare_revision_walk(opts->revs))
1992 return error(_("revision walk setup failed"));
1997 static int read_and_refresh_cache(struct repository *r,
1998 struct replay_opts *opts)
2000 struct lock_file index_lock = LOCK_INIT;
2001 int index_fd = hold_locked_index(&index_lock, 0);
2002 if (read_index(r->index) < 0) {
2003 rollback_lock_file(&index_lock);
2004 return error(_("git %s: failed to read the index"),
2005 _(action_name(opts)));
2007 refresh_index(r->index, REFRESH_QUIET|REFRESH_UNMERGED, NULL, NULL, NULL);
2008 if (index_fd >= 0) {
2009 if (write_locked_index(r->index, &index_lock,
2010 COMMIT_LOCK | SKIP_IF_UNCHANGED)) {
2011 return error(_("git %s: failed to refresh the index"),
2012 _(action_name(opts)));
2018 enum todo_item_flags {
2019 TODO_EDIT_MERGE_MSG = 1
2023 enum todo_command command;
2024 struct commit *commit;
2028 size_t offset_in_buf;
2033 struct todo_item *items;
2034 int nr, alloc, current;
2035 int done_nr, total_nr;
2036 struct stat_data stat;
2039 #define TODO_LIST_INIT { STRBUF_INIT }
2041 static void todo_list_release(struct todo_list *todo_list)
2043 strbuf_release(&todo_list->buf);
2044 FREE_AND_NULL(todo_list->items);
2045 todo_list->nr = todo_list->alloc = 0;
2048 static struct todo_item *append_new_todo(struct todo_list *todo_list)
2050 ALLOC_GROW(todo_list->items, todo_list->nr + 1, todo_list->alloc);
2051 return todo_list->items + todo_list->nr++;
2054 static int parse_insn_line(struct repository *r, struct todo_item *item,
2055 const char *bol, char *eol)
2057 struct object_id commit_oid;
2058 char *end_of_object_name;
2059 int i, saved, status, padding;
2064 bol += strspn(bol, " \t");
2066 if (bol == eol || *bol == '\r' || *bol == comment_line_char) {
2067 item->command = TODO_COMMENT;
2068 item->commit = NULL;
2070 item->arg_len = eol - bol;
2074 for (i = 0; i < TODO_COMMENT; i++)
2075 if (skip_prefix(bol, todo_command_info[i].str, &bol)) {
2078 } else if ((bol + 1 == eol || bol[1] == ' ') &&
2079 *bol == todo_command_info[i].c) {
2084 if (i >= TODO_COMMENT)
2087 /* Eat up extra spaces/ tabs before object name */
2088 padding = strspn(bol, " \t");
2091 if (item->command == TODO_NOOP || item->command == TODO_BREAK) {
2093 return error(_("%s does not accept arguments: '%s'"),
2094 command_to_string(item->command), bol);
2095 item->commit = NULL;
2097 item->arg_len = eol - bol;
2102 return error(_("missing arguments for %s"),
2103 command_to_string(item->command));
2105 if (item->command == TODO_EXEC || item->command == TODO_LABEL ||
2106 item->command == TODO_RESET) {
2107 item->commit = NULL;
2109 item->arg_len = (int)(eol - bol);
2113 if (item->command == TODO_MERGE) {
2114 if (skip_prefix(bol, "-C", &bol))
2115 bol += strspn(bol, " \t");
2116 else if (skip_prefix(bol, "-c", &bol)) {
2117 bol += strspn(bol, " \t");
2118 item->flags |= TODO_EDIT_MERGE_MSG;
2120 item->flags |= TODO_EDIT_MERGE_MSG;
2121 item->commit = NULL;
2123 item->arg_len = (int)(eol - bol);
2128 end_of_object_name = (char *) bol + strcspn(bol, " \t\n");
2129 saved = *end_of_object_name;
2130 *end_of_object_name = '\0';
2131 status = get_oid(bol, &commit_oid);
2132 *end_of_object_name = saved;
2134 item->arg = end_of_object_name + strspn(end_of_object_name, " \t");
2135 item->arg_len = (int)(eol - item->arg);
2140 item->commit = lookup_commit_reference(r, &commit_oid);
2141 return !item->commit;
2144 static int parse_insn_buffer(struct repository *r, char *buf,
2145 struct todo_list *todo_list)
2147 struct todo_item *item;
2148 char *p = buf, *next_p;
2149 int i, res = 0, fixup_okay = file_exists(rebase_path_done());
2151 for (i = 1; *p; i++, p = next_p) {
2152 char *eol = strchrnul(p, '\n');
2154 next_p = *eol ? eol + 1 /* skip LF */ : eol;
2156 if (p != eol && eol[-1] == '\r')
2157 eol--; /* strip Carriage Return */
2159 item = append_new_todo(todo_list);
2160 item->offset_in_buf = p - todo_list->buf.buf;
2161 if (parse_insn_line(r, item, p, eol)) {
2162 res = error(_("invalid line %d: %.*s"),
2163 i, (int)(eol - p), p);
2164 item->command = TODO_NOOP;
2169 else if (is_fixup(item->command))
2170 return error(_("cannot '%s' without a previous commit"),
2171 command_to_string(item->command));
2172 else if (!is_noop(item->command))
2179 static int count_commands(struct todo_list *todo_list)
2183 for (i = 0; i < todo_list->nr; i++)
2184 if (todo_list->items[i].command != TODO_COMMENT)
2190 static int get_item_line_offset(struct todo_list *todo_list, int index)
2192 return index < todo_list->nr ?
2193 todo_list->items[index].offset_in_buf : todo_list->buf.len;
2196 static const char *get_item_line(struct todo_list *todo_list, int index)
2198 return todo_list->buf.buf + get_item_line_offset(todo_list, index);
2201 static int get_item_line_length(struct todo_list *todo_list, int index)
2203 return get_item_line_offset(todo_list, index + 1)
2204 - get_item_line_offset(todo_list, index);
2207 static ssize_t strbuf_read_file_or_whine(struct strbuf *sb, const char *path)
2212 fd = open(path, O_RDONLY);
2214 return error_errno(_("could not open '%s'"), path);
2215 len = strbuf_read(sb, fd, 0);
2218 return error(_("could not read '%s'."), path);
2222 static int read_populate_todo(struct repository *r,
2223 struct todo_list *todo_list,
2224 struct replay_opts *opts)
2227 const char *todo_file = get_todo_path(opts);
2230 strbuf_reset(&todo_list->buf);
2231 if (strbuf_read_file_or_whine(&todo_list->buf, todo_file) < 0)
2234 res = stat(todo_file, &st);
2236 return error(_("could not stat '%s'"), todo_file);
2237 fill_stat_data(&todo_list->stat, &st);
2239 res = parse_insn_buffer(r, todo_list->buf.buf, todo_list);
2241 if (is_rebase_i(opts))
2242 return error(_("please fix this using "
2243 "'git rebase --edit-todo'."));
2244 return error(_("unusable instruction sheet: '%s'"), todo_file);
2247 if (!todo_list->nr &&
2248 (!is_rebase_i(opts) || !file_exists(rebase_path_done())))
2249 return error(_("no commits parsed."));
2251 if (!is_rebase_i(opts)) {
2252 enum todo_command valid =
2253 opts->action == REPLAY_PICK ? TODO_PICK : TODO_REVERT;
2256 for (i = 0; i < todo_list->nr; i++)
2257 if (valid == todo_list->items[i].command)
2259 else if (valid == TODO_PICK)
2260 return error(_("cannot cherry-pick during a revert."));
2262 return error(_("cannot revert during a cherry-pick."));
2265 if (is_rebase_i(opts)) {
2266 struct todo_list done = TODO_LIST_INIT;
2267 FILE *f = fopen_or_warn(rebase_path_msgtotal(), "w");
2269 if (strbuf_read_file(&done.buf, rebase_path_done(), 0) > 0 &&
2270 !parse_insn_buffer(r, done.buf.buf, &done))
2271 todo_list->done_nr = count_commands(&done);
2273 todo_list->done_nr = 0;
2275 todo_list->total_nr = todo_list->done_nr
2276 + count_commands(todo_list);
2277 todo_list_release(&done);
2280 fprintf(f, "%d\n", todo_list->total_nr);
2288 static int git_config_string_dup(char **dest,
2289 const char *var, const char *value)
2292 return config_error_nonbool(var);
2294 *dest = xstrdup(value);
2298 static int populate_opts_cb(const char *key, const char *value, void *data)
2300 struct replay_opts *opts = data;
2305 else if (!strcmp(key, "options.no-commit"))
2306 opts->no_commit = git_config_bool_or_int(key, value, &error_flag);
2307 else if (!strcmp(key, "options.edit"))
2308 opts->edit = git_config_bool_or_int(key, value, &error_flag);
2309 else if (!strcmp(key, "options.signoff"))
2310 opts->signoff = git_config_bool_or_int(key, value, &error_flag);
2311 else if (!strcmp(key, "options.record-origin"))
2312 opts->record_origin = git_config_bool_or_int(key, value, &error_flag);
2313 else if (!strcmp(key, "options.allow-ff"))
2314 opts->allow_ff = git_config_bool_or_int(key, value, &error_flag);
2315 else if (!strcmp(key, "options.mainline"))
2316 opts->mainline = git_config_int(key, value);
2317 else if (!strcmp(key, "options.strategy"))
2318 git_config_string_dup(&opts->strategy, key, value);
2319 else if (!strcmp(key, "options.gpg-sign"))
2320 git_config_string_dup(&opts->gpg_sign, key, value);
2321 else if (!strcmp(key, "options.strategy-option")) {
2322 ALLOC_GROW(opts->xopts, opts->xopts_nr + 1, opts->xopts_alloc);
2323 opts->xopts[opts->xopts_nr++] = xstrdup(value);
2324 } else if (!strcmp(key, "options.allow-rerere-auto"))
2325 opts->allow_rerere_auto =
2326 git_config_bool_or_int(key, value, &error_flag) ?
2327 RERERE_AUTOUPDATE : RERERE_NOAUTOUPDATE;
2329 return error(_("invalid key: %s"), key);
2332 return error(_("invalid value for %s: %s"), key, value);
2337 void parse_strategy_opts(struct replay_opts *opts, char *raw_opts)
2340 char *strategy_opts_string = raw_opts;
2342 if (*strategy_opts_string == ' ')
2343 strategy_opts_string++;
2345 opts->xopts_nr = split_cmdline(strategy_opts_string,
2346 (const char ***)&opts->xopts);
2347 for (i = 0; i < opts->xopts_nr; i++) {
2348 const char *arg = opts->xopts[i];
2350 skip_prefix(arg, "--", &arg);
2351 opts->xopts[i] = xstrdup(arg);
2355 static void read_strategy_opts(struct replay_opts *opts, struct strbuf *buf)
2358 if (!read_oneliner(buf, rebase_path_strategy(), 0))
2360 opts->strategy = strbuf_detach(buf, NULL);
2361 if (!read_oneliner(buf, rebase_path_strategy_opts(), 0))
2364 parse_strategy_opts(opts, buf->buf);
2367 static int read_populate_opts(struct replay_opts *opts)
2369 if (is_rebase_i(opts)) {
2370 struct strbuf buf = STRBUF_INIT;
2372 if (read_oneliner(&buf, rebase_path_gpg_sign_opt(), 1)) {
2373 if (!starts_with(buf.buf, "-S"))
2376 free(opts->gpg_sign);
2377 opts->gpg_sign = xstrdup(buf.buf + 2);
2382 if (read_oneliner(&buf, rebase_path_allow_rerere_autoupdate(), 1)) {
2383 if (!strcmp(buf.buf, "--rerere-autoupdate"))
2384 opts->allow_rerere_auto = RERERE_AUTOUPDATE;
2385 else if (!strcmp(buf.buf, "--no-rerere-autoupdate"))
2386 opts->allow_rerere_auto = RERERE_NOAUTOUPDATE;
2390 if (file_exists(rebase_path_verbose()))
2393 if (file_exists(rebase_path_quiet()))
2396 if (file_exists(rebase_path_signoff())) {
2401 if (file_exists(rebase_path_reschedule_failed_exec()))
2402 opts->reschedule_failed_exec = 1;
2404 read_strategy_opts(opts, &buf);
2405 strbuf_release(&buf);
2407 if (read_oneliner(&opts->current_fixups,
2408 rebase_path_current_fixups(), 1)) {
2409 const char *p = opts->current_fixups.buf;
2410 opts->current_fixup_count = 1;
2411 while ((p = strchr(p, '\n'))) {
2412 opts->current_fixup_count++;
2417 if (read_oneliner(&buf, rebase_path_squash_onto(), 0)) {
2418 if (get_oid_hex(buf.buf, &opts->squash_onto) < 0)
2419 return error(_("unusable squash-onto"));
2420 opts->have_squash_onto = 1;
2426 if (!file_exists(git_path_opts_file()))
2429 * The function git_parse_source(), called from git_config_from_file(),
2430 * may die() in case of a syntactically incorrect file. We do not care
2431 * about this case, though, because we wrote that file ourselves, so we
2432 * are pretty certain that it is syntactically correct.
2434 if (git_config_from_file(populate_opts_cb, git_path_opts_file(), opts) < 0)
2435 return error(_("malformed options sheet: '%s'"),
2436 git_path_opts_file());
2440 static void write_strategy_opts(struct replay_opts *opts)
2443 struct strbuf buf = STRBUF_INIT;
2445 for (i = 0; i < opts->xopts_nr; ++i)
2446 strbuf_addf(&buf, " --%s", opts->xopts[i]);
2448 write_file(rebase_path_strategy_opts(), "%s\n", buf.buf);
2449 strbuf_release(&buf);
2452 int write_basic_state(struct replay_opts *opts, const char *head_name,
2453 const char *onto, const char *orig_head)
2455 const char *quiet = getenv("GIT_QUIET");
2458 write_file(rebase_path_head_name(), "%s\n", head_name);
2460 write_file(rebase_path_onto(), "%s\n", onto);
2462 write_file(rebase_path_orig_head(), "%s\n", orig_head);
2465 write_file(rebase_path_quiet(), "%s\n", quiet);
2467 write_file(rebase_path_verbose(), "%s", "");
2469 write_file(rebase_path_strategy(), "%s\n", opts->strategy);
2470 if (opts->xopts_nr > 0)
2471 write_strategy_opts(opts);
2473 if (opts->allow_rerere_auto == RERERE_AUTOUPDATE)
2474 write_file(rebase_path_allow_rerere_autoupdate(), "--rerere-autoupdate\n");
2475 else if (opts->allow_rerere_auto == RERERE_NOAUTOUPDATE)
2476 write_file(rebase_path_allow_rerere_autoupdate(), "--no-rerere-autoupdate\n");
2479 write_file(rebase_path_gpg_sign_opt(), "-S%s\n", opts->gpg_sign);
2481 write_file(rebase_path_signoff(), "--signoff\n");
2482 if (opts->reschedule_failed_exec)
2483 write_file(rebase_path_reschedule_failed_exec(), "%s", "");
2488 static int walk_revs_populate_todo(struct todo_list *todo_list,
2489 struct replay_opts *opts)
2491 enum todo_command command = opts->action == REPLAY_PICK ?
2492 TODO_PICK : TODO_REVERT;
2493 const char *command_string = todo_command_info[command].str;
2494 struct commit *commit;
2496 if (prepare_revs(opts))
2499 while ((commit = get_revision(opts->revs))) {
2500 struct todo_item *item = append_new_todo(todo_list);
2501 const char *commit_buffer = get_commit_buffer(commit, NULL);
2502 const char *subject;
2505 item->command = command;
2506 item->commit = commit;
2509 item->offset_in_buf = todo_list->buf.len;
2510 subject_len = find_commit_subject(commit_buffer, &subject);
2511 strbuf_addf(&todo_list->buf, "%s %s %.*s\n", command_string,
2512 short_commit_name(commit), subject_len, subject);
2513 unuse_commit_buffer(commit, commit_buffer);
2517 return error(_("empty commit set passed"));
2522 static int create_seq_dir(void)
2524 if (file_exists(git_path_seq_dir())) {
2525 error(_("a cherry-pick or revert is already in progress"));
2526 advise(_("try \"git cherry-pick (--continue | --quit | --abort)\""));
2528 } else if (mkdir(git_path_seq_dir(), 0777) < 0)
2529 return error_errno(_("could not create sequencer directory '%s'"),
2530 git_path_seq_dir());
2534 static int save_head(const char *head)
2536 struct lock_file head_lock = LOCK_INIT;
2537 struct strbuf buf = STRBUF_INIT;
2541 fd = hold_lock_file_for_update(&head_lock, git_path_head_file(), 0);
2543 return error_errno(_("could not lock HEAD"));
2544 strbuf_addf(&buf, "%s\n", head);
2545 written = write_in_full(fd, buf.buf, buf.len);
2546 strbuf_release(&buf);
2548 error_errno(_("could not write to '%s'"), git_path_head_file());
2549 rollback_lock_file(&head_lock);
2552 if (commit_lock_file(&head_lock) < 0)
2553 return error(_("failed to finalize '%s'"), git_path_head_file());
2557 static int rollback_is_safe(void)
2559 struct strbuf sb = STRBUF_INIT;
2560 struct object_id expected_head, actual_head;
2562 if (strbuf_read_file(&sb, git_path_abort_safety_file(), 0) >= 0) {
2564 if (get_oid_hex(sb.buf, &expected_head)) {
2565 strbuf_release(&sb);
2566 die(_("could not parse %s"), git_path_abort_safety_file());
2568 strbuf_release(&sb);
2570 else if (errno == ENOENT)
2571 oidclr(&expected_head);
2573 die_errno(_("could not read '%s'"), git_path_abort_safety_file());
2575 if (get_oid("HEAD", &actual_head))
2576 oidclr(&actual_head);
2578 return oideq(&actual_head, &expected_head);
2581 static int reset_for_rollback(const struct object_id *oid)
2583 const char *argv[4]; /* reset --merge <arg> + NULL */
2586 argv[1] = "--merge";
2587 argv[2] = oid_to_hex(oid);
2589 return run_command_v_opt(argv, RUN_GIT_CMD);
2592 static int rollback_single_pick(struct repository *r)
2594 struct object_id head_oid;
2596 if (!file_exists(git_path_cherry_pick_head(r)) &&
2597 !file_exists(git_path_revert_head(r)))
2598 return error(_("no cherry-pick or revert in progress"));
2599 if (read_ref_full("HEAD", 0, &head_oid, NULL))
2600 return error(_("cannot resolve HEAD"));
2601 if (is_null_oid(&head_oid))
2602 return error(_("cannot abort from a branch yet to be born"));
2603 return reset_for_rollback(&head_oid);
2606 int sequencer_rollback(struct repository *r, struct replay_opts *opts)
2609 struct object_id oid;
2610 struct strbuf buf = STRBUF_INIT;
2613 f = fopen(git_path_head_file(), "r");
2614 if (!f && errno == ENOENT) {
2616 * There is no multiple-cherry-pick in progress.
2617 * If CHERRY_PICK_HEAD or REVERT_HEAD indicates
2618 * a single-cherry-pick in progress, abort that.
2620 return rollback_single_pick(r);
2623 return error_errno(_("cannot open '%s'"), git_path_head_file());
2624 if (strbuf_getline_lf(&buf, f)) {
2625 error(_("cannot read '%s': %s"), git_path_head_file(),
2626 ferror(f) ? strerror(errno) : _("unexpected end of file"));
2631 if (parse_oid_hex(buf.buf, &oid, &p) || *p != '\0') {
2632 error(_("stored pre-cherry-pick HEAD file '%s' is corrupt"),
2633 git_path_head_file());
2636 if (is_null_oid(&oid)) {
2637 error(_("cannot abort from a branch yet to be born"));
2641 if (!rollback_is_safe()) {
2642 /* Do not error, just do not rollback */
2643 warning(_("You seem to have moved HEAD. "
2644 "Not rewinding, check your HEAD!"));
2646 if (reset_for_rollback(&oid))
2648 strbuf_release(&buf);
2649 return sequencer_remove_state(opts);
2651 strbuf_release(&buf);
2655 static int save_todo(struct todo_list *todo_list, struct replay_opts *opts)
2657 struct lock_file todo_lock = LOCK_INIT;
2658 const char *todo_path = get_todo_path(opts);
2659 int next = todo_list->current, offset, fd;
2662 * rebase -i writes "git-rebase-todo" without the currently executing
2663 * command, appending it to "done" instead.
2665 if (is_rebase_i(opts))
2668 fd = hold_lock_file_for_update(&todo_lock, todo_path, 0);
2670 return error_errno(_("could not lock '%s'"), todo_path);
2671 offset = get_item_line_offset(todo_list, next);
2672 if (write_in_full(fd, todo_list->buf.buf + offset,
2673 todo_list->buf.len - offset) < 0)
2674 return error_errno(_("could not write to '%s'"), todo_path);
2675 if (commit_lock_file(&todo_lock) < 0)
2676 return error(_("failed to finalize '%s'"), todo_path);
2678 if (is_rebase_i(opts) && next > 0) {
2679 const char *done = rebase_path_done();
2680 int fd = open(done, O_CREAT | O_WRONLY | O_APPEND, 0666);
2685 if (write_in_full(fd, get_item_line(todo_list, next - 1),
2686 get_item_line_length(todo_list, next - 1))
2688 ret = error_errno(_("could not write to '%s'"), done);
2690 ret = error_errno(_("failed to finalize '%s'"), done);
2696 static int save_opts(struct replay_opts *opts)
2698 const char *opts_file = git_path_opts_file();
2701 if (opts->no_commit)
2702 res |= git_config_set_in_file_gently(opts_file, "options.no-commit", "true");
2704 res |= git_config_set_in_file_gently(opts_file, "options.edit", "true");
2706 res |= git_config_set_in_file_gently(opts_file, "options.signoff", "true");
2707 if (opts->record_origin)
2708 res |= git_config_set_in_file_gently(opts_file, "options.record-origin", "true");
2710 res |= git_config_set_in_file_gently(opts_file, "options.allow-ff", "true");
2711 if (opts->mainline) {
2712 struct strbuf buf = STRBUF_INIT;
2713 strbuf_addf(&buf, "%d", opts->mainline);
2714 res |= git_config_set_in_file_gently(opts_file, "options.mainline", buf.buf);
2715 strbuf_release(&buf);
2718 res |= git_config_set_in_file_gently(opts_file, "options.strategy", opts->strategy);
2720 res |= git_config_set_in_file_gently(opts_file, "options.gpg-sign", opts->gpg_sign);
2723 for (i = 0; i < opts->xopts_nr; i++)
2724 res |= git_config_set_multivar_in_file_gently(opts_file,
2725 "options.strategy-option",
2726 opts->xopts[i], "^$", 0);
2728 if (opts->allow_rerere_auto)
2729 res |= git_config_set_in_file_gently(opts_file, "options.allow-rerere-auto",
2730 opts->allow_rerere_auto == RERERE_AUTOUPDATE ?
2735 static int make_patch(struct repository *r,
2736 struct commit *commit,
2737 struct replay_opts *opts)
2739 struct strbuf buf = STRBUF_INIT;
2740 struct rev_info log_tree_opt;
2741 const char *subject, *p;
2744 p = short_commit_name(commit);
2745 if (write_message(p, strlen(p), rebase_path_stopped_sha(), 1) < 0)
2747 if (update_ref("rebase", "REBASE_HEAD", &commit->object.oid,
2748 NULL, REF_NO_DEREF, UPDATE_REFS_MSG_ON_ERR))
2749 res |= error(_("could not update %s"), "REBASE_HEAD");
2751 strbuf_addf(&buf, "%s/patch", get_dir(opts));
2752 memset(&log_tree_opt, 0, sizeof(log_tree_opt));
2753 repo_init_revisions(r, &log_tree_opt, NULL);
2754 log_tree_opt.abbrev = 0;
2755 log_tree_opt.diff = 1;
2756 log_tree_opt.diffopt.output_format = DIFF_FORMAT_PATCH;
2757 log_tree_opt.disable_stdin = 1;
2758 log_tree_opt.no_commit_id = 1;
2759 log_tree_opt.diffopt.file = fopen(buf.buf, "w");
2760 log_tree_opt.diffopt.use_color = GIT_COLOR_NEVER;
2761 if (!log_tree_opt.diffopt.file)
2762 res |= error_errno(_("could not open '%s'"), buf.buf);
2764 res |= log_tree_commit(&log_tree_opt, commit);
2765 fclose(log_tree_opt.diffopt.file);
2769 strbuf_addf(&buf, "%s/message", get_dir(opts));
2770 if (!file_exists(buf.buf)) {
2771 const char *commit_buffer = get_commit_buffer(commit, NULL);
2772 find_commit_subject(commit_buffer, &subject);
2773 res |= write_message(subject, strlen(subject), buf.buf, 1);
2774 unuse_commit_buffer(commit, commit_buffer);
2776 strbuf_release(&buf);
2781 static int intend_to_amend(void)
2783 struct object_id head;
2786 if (get_oid("HEAD", &head))
2787 return error(_("cannot read HEAD"));
2789 p = oid_to_hex(&head);
2790 return write_message(p, strlen(p), rebase_path_amend(), 1);
2793 static int error_with_patch(struct repository *r,
2794 struct commit *commit,
2795 const char *subject, int subject_len,
2796 struct replay_opts *opts,
2797 int exit_code, int to_amend)
2800 if (make_patch(r, commit, opts))
2802 } else if (copy_file(rebase_path_message(),
2803 git_path_merge_msg(r), 0666))
2804 return error(_("unable to copy '%s' to '%s'"),
2805 git_path_merge_msg(r), rebase_path_message());
2808 if (intend_to_amend())
2812 _("You can amend the commit now, with\n"
2814 " git commit --amend %s\n"
2816 "Once you are satisfied with your changes, run\n"
2818 " git rebase --continue\n"),
2819 gpg_sign_opt_quoted(opts));
2820 } else if (exit_code) {
2822 fprintf_ln(stderr, _("Could not apply %s... %.*s"),
2823 short_commit_name(commit), subject_len, subject);
2826 * We don't have the hash of the parent so
2827 * just print the line from the todo file.
2829 fprintf_ln(stderr, _("Could not merge %.*s"),
2830 subject_len, subject);
2836 static int error_failed_squash(struct repository *r,
2837 struct commit *commit,
2838 struct replay_opts *opts,
2840 const char *subject)
2842 if (copy_file(rebase_path_message(), rebase_path_squash_msg(), 0666))
2843 return error(_("could not copy '%s' to '%s'"),
2844 rebase_path_squash_msg(), rebase_path_message());
2845 unlink(git_path_merge_msg(r));
2846 if (copy_file(git_path_merge_msg(r), rebase_path_message(), 0666))
2847 return error(_("could not copy '%s' to '%s'"),
2848 rebase_path_message(),
2849 git_path_merge_msg(r));
2850 return error_with_patch(r, commit, subject, subject_len, opts, 1, 0);
2853 static int do_exec(struct repository *r, const char *command_line)
2855 struct argv_array child_env = ARGV_ARRAY_INIT;
2856 const char *child_argv[] = { NULL, NULL };
2859 fprintf(stderr, "Executing: %s\n", command_line);
2860 child_argv[0] = command_line;
2861 argv_array_pushf(&child_env, "GIT_DIR=%s", absolute_path(get_git_dir()));
2862 argv_array_pushf(&child_env, "GIT_WORK_TREE=%s",
2863 absolute_path(get_git_work_tree()));
2864 status = run_command_v_opt_cd_env(child_argv, RUN_USING_SHELL, NULL,
2867 /* force re-reading of the cache */
2868 if (discard_index(r->index) < 0 || read_index(r->index) < 0)
2869 return error(_("could not read index"));
2871 dirty = require_clean_work_tree(r, "rebase", NULL, 1, 1);
2874 warning(_("execution failed: %s\n%s"
2875 "You can fix the problem, and then run\n"
2877 " git rebase --continue\n"
2880 dirty ? N_("and made changes to the index and/or the "
2881 "working tree\n") : "");
2883 /* command not found */
2886 warning(_("execution succeeded: %s\nbut "
2887 "left changes to the index and/or the working tree\n"
2888 "Commit or stash your changes, and then run\n"
2890 " git rebase --continue\n"
2891 "\n"), command_line);
2895 argv_array_clear(&child_env);
2900 static int safe_append(const char *filename, const char *fmt, ...)
2903 struct lock_file lock = LOCK_INIT;
2904 int fd = hold_lock_file_for_update(&lock, filename,
2905 LOCK_REPORT_ON_ERROR);
2906 struct strbuf buf = STRBUF_INIT;
2911 if (strbuf_read_file(&buf, filename, 0) < 0 && errno != ENOENT) {
2912 error_errno(_("could not read '%s'"), filename);
2913 rollback_lock_file(&lock);
2916 strbuf_complete(&buf, '\n');
2918 strbuf_vaddf(&buf, fmt, ap);
2921 if (write_in_full(fd, buf.buf, buf.len) < 0) {
2922 error_errno(_("could not write to '%s'"), filename);
2923 strbuf_release(&buf);
2924 rollback_lock_file(&lock);
2927 if (commit_lock_file(&lock) < 0) {
2928 strbuf_release(&buf);
2929 rollback_lock_file(&lock);
2930 return error(_("failed to finalize '%s'"), filename);
2933 strbuf_release(&buf);
2937 static int do_label(struct repository *r, const char *name, int len)
2939 struct ref_store *refs = get_main_ref_store(r);
2940 struct ref_transaction *transaction;
2941 struct strbuf ref_name = STRBUF_INIT, err = STRBUF_INIT;
2942 struct strbuf msg = STRBUF_INIT;
2944 struct object_id head_oid;
2946 if (len == 1 && *name == '#')
2947 return error(_("illegal label name: '%.*s'"), len, name);
2949 strbuf_addf(&ref_name, "refs/rewritten/%.*s", len, name);
2950 strbuf_addf(&msg, "rebase -i (label) '%.*s'", len, name);
2952 transaction = ref_store_transaction_begin(refs, &err);
2954 error("%s", err.buf);
2956 } else if (get_oid("HEAD", &head_oid)) {
2957 error(_("could not read HEAD"));
2959 } else if (ref_transaction_update(transaction, ref_name.buf, &head_oid,
2960 NULL, 0, msg.buf, &err) < 0 ||
2961 ref_transaction_commit(transaction, &err)) {
2962 error("%s", err.buf);
2965 ref_transaction_free(transaction);
2966 strbuf_release(&err);
2967 strbuf_release(&msg);
2970 ret = safe_append(rebase_path_refs_to_delete(),
2971 "%s\n", ref_name.buf);
2972 strbuf_release(&ref_name);
2977 static const char *reflog_message(struct replay_opts *opts,
2978 const char *sub_action, const char *fmt, ...);
2980 static int do_reset(struct repository *r,
2981 const char *name, int len,
2982 struct replay_opts *opts)
2984 struct strbuf ref_name = STRBUF_INIT;
2985 struct object_id oid;
2986 struct lock_file lock = LOCK_INIT;
2987 struct tree_desc desc;
2989 struct unpack_trees_options unpack_tree_opts;
2992 if (hold_locked_index(&lock, LOCK_REPORT_ON_ERROR) < 0)
2995 if (len == 10 && !strncmp("[new root]", name, len)) {
2996 if (!opts->have_squash_onto) {
2998 if (commit_tree("", 0, the_hash_algo->empty_tree,
2999 NULL, &opts->squash_onto,
3001 return error(_("writing fake root commit"));
3002 opts->have_squash_onto = 1;
3003 hex = oid_to_hex(&opts->squash_onto);
3004 if (write_message(hex, strlen(hex),
3005 rebase_path_squash_onto(), 0))
3006 return error(_("writing squash-onto"));
3008 oidcpy(&oid, &opts->squash_onto);
3012 /* Determine the length of the label */
3013 for (i = 0; i < len; i++)
3014 if (isspace(name[i]))
3018 strbuf_addf(&ref_name, "refs/rewritten/%.*s", len, name);
3019 if (get_oid(ref_name.buf, &oid) &&
3020 get_oid(ref_name.buf + strlen("refs/rewritten/"), &oid)) {
3021 error(_("could not read '%s'"), ref_name.buf);
3022 rollback_lock_file(&lock);
3023 strbuf_release(&ref_name);
3028 memset(&unpack_tree_opts, 0, sizeof(unpack_tree_opts));
3029 setup_unpack_trees_porcelain(&unpack_tree_opts, "reset");
3030 unpack_tree_opts.head_idx = 1;
3031 unpack_tree_opts.src_index = r->index;
3032 unpack_tree_opts.dst_index = r->index;
3033 unpack_tree_opts.fn = oneway_merge;
3034 unpack_tree_opts.merge = 1;
3035 unpack_tree_opts.update = 1;
3037 if (read_index_unmerged(r->index)) {
3038 rollback_lock_file(&lock);
3039 strbuf_release(&ref_name);
3040 return error_resolve_conflict(_(action_name(opts)));
3043 if (!fill_tree_descriptor(&desc, &oid)) {
3044 error(_("failed to find tree of %s"), oid_to_hex(&oid));
3045 rollback_lock_file(&lock);
3046 free((void *)desc.buffer);
3047 strbuf_release(&ref_name);
3051 if (unpack_trees(1, &desc, &unpack_tree_opts)) {
3052 rollback_lock_file(&lock);
3053 free((void *)desc.buffer);
3054 strbuf_release(&ref_name);
3058 tree = parse_tree_indirect(&oid);
3059 prime_cache_tree(r, r->index, tree);
3061 if (write_locked_index(r->index, &lock, COMMIT_LOCK) < 0)
3062 ret = error(_("could not write index"));
3063 free((void *)desc.buffer);
3066 ret = update_ref(reflog_message(opts, "reset", "'%.*s'",
3067 len, name), "HEAD", &oid,
3068 NULL, 0, UPDATE_REFS_MSG_ON_ERR);
3070 strbuf_release(&ref_name);
3074 static struct commit *lookup_label(const char *label, int len,
3077 struct commit *commit;
3080 strbuf_addf(buf, "refs/rewritten/%.*s", len, label);
3081 commit = lookup_commit_reference_by_name(buf->buf);
3083 /* fall back to non-rewritten ref or commit */
3084 strbuf_splice(buf, 0, strlen("refs/rewritten/"), "", 0);
3085 commit = lookup_commit_reference_by_name(buf->buf);
3089 error(_("could not resolve '%s'"), buf->buf);
3094 static int do_merge(struct repository *r,
3095 struct commit *commit,
3096 const char *arg, int arg_len,
3097 int flags, struct replay_opts *opts)
3099 int run_commit_flags = (flags & TODO_EDIT_MERGE_MSG) ?
3100 EDIT_MSG | VERIFY_MSG : 0;
3101 struct strbuf ref_name = STRBUF_INIT;
3102 struct commit *head_commit, *merge_commit, *i;
3103 struct commit_list *bases, *j, *reversed = NULL;
3104 struct commit_list *to_merge = NULL, **tail = &to_merge;
3105 struct merge_options o;
3106 int merge_arg_len, oneline_offset, can_fast_forward, ret, k;
3107 static struct lock_file lock;
3110 if (hold_locked_index(&lock, LOCK_REPORT_ON_ERROR) < 0) {
3115 head_commit = lookup_commit_reference_by_name("HEAD");
3117 ret = error(_("cannot merge without a current revision"));
3122 * For octopus merges, the arg starts with the list of revisions to be
3123 * merged. The list is optionally followed by '#' and the oneline.
3125 merge_arg_len = oneline_offset = arg_len;
3126 for (p = arg; p - arg < arg_len; p += strspn(p, " \t\n")) {
3129 if (*p == '#' && (!p[1] || isspace(p[1]))) {
3130 p += 1 + strspn(p + 1, " \t\n");
3131 oneline_offset = p - arg;
3134 k = strcspn(p, " \t\n");
3137 merge_commit = lookup_label(p, k, &ref_name);
3138 if (!merge_commit) {
3139 ret = error(_("unable to parse '%.*s'"), k, p);
3142 tail = &commit_list_insert(merge_commit, tail)->next;
3144 merge_arg_len = p - arg;
3148 ret = error(_("nothing to merge: '%.*s'"), arg_len, arg);
3152 if (opts->have_squash_onto &&
3153 oideq(&head_commit->object.oid, &opts->squash_onto)) {
3155 * When the user tells us to "merge" something into a
3156 * "[new root]", let's simply fast-forward to the merge head.
3158 rollback_lock_file(&lock);
3160 ret = error(_("octopus merge cannot be executed on "
3161 "top of a [new root]"));
3163 ret = fast_forward_to(r, &to_merge->item->object.oid,
3164 &head_commit->object.oid, 0,
3170 const char *message = get_commit_buffer(commit, NULL);
3175 ret = error(_("could not get commit message of '%s'"),
3176 oid_to_hex(&commit->object.oid));
3179 write_author_script(message);
3180 find_commit_subject(message, &body);
3182 ret = write_message(body, len, git_path_merge_msg(r), 0);
3183 unuse_commit_buffer(commit, message);
3185 error_errno(_("could not write '%s'"),
3186 git_path_merge_msg(r));
3190 struct strbuf buf = STRBUF_INIT;
3193 strbuf_addf(&buf, "author %s", git_author_info(0));
3194 write_author_script(buf.buf);
3197 if (oneline_offset < arg_len) {
3198 p = arg + oneline_offset;
3199 len = arg_len - oneline_offset;
3201 strbuf_addf(&buf, "Merge %s '%.*s'",
3202 to_merge->next ? "branches" : "branch",
3203 merge_arg_len, arg);
3208 ret = write_message(p, len, git_path_merge_msg(r), 0);
3209 strbuf_release(&buf);
3211 error_errno(_("could not write '%s'"),
3212 git_path_merge_msg(r));
3218 * If HEAD is not identical to the first parent of the original merge
3219 * commit, we cannot fast-forward.
3221 can_fast_forward = opts->allow_ff && commit && commit->parents &&
3222 oideq(&commit->parents->item->object.oid,
3223 &head_commit->object.oid);
3226 * If any merge head is different from the original one, we cannot
3229 if (can_fast_forward) {
3230 struct commit_list *p = commit->parents->next;
3232 for (j = to_merge; j && p; j = j->next, p = p->next)
3233 if (!oideq(&j->item->object.oid,
3234 &p->item->object.oid)) {
3235 can_fast_forward = 0;
3239 * If the number of merge heads differs from the original merge
3240 * commit, we cannot fast-forward.
3243 can_fast_forward = 0;
3246 if (can_fast_forward) {
3247 rollback_lock_file(&lock);
3248 ret = fast_forward_to(r, &commit->object.oid,
3249 &head_commit->object.oid, 0, opts);
3253 if (to_merge->next) {
3255 struct child_process cmd = CHILD_PROCESS_INIT;
3257 if (read_env_script(&cmd.env_array)) {
3258 const char *gpg_opt = gpg_sign_opt_quoted(opts);
3260 ret = error(_(staged_changes_advice), gpg_opt, gpg_opt);
3265 argv_array_push(&cmd.args, "merge");
3266 argv_array_push(&cmd.args, "-s");
3267 argv_array_push(&cmd.args, "octopus");
3268 argv_array_push(&cmd.args, "--no-edit");
3269 argv_array_push(&cmd.args, "--no-ff");
3270 argv_array_push(&cmd.args, "--no-log");
3271 argv_array_push(&cmd.args, "--no-stat");
3272 argv_array_push(&cmd.args, "-F");
3273 argv_array_push(&cmd.args, git_path_merge_msg(r));
3275 argv_array_push(&cmd.args, opts->gpg_sign);
3277 /* Add the tips to be merged */
3278 for (j = to_merge; j; j = j->next)
3279 argv_array_push(&cmd.args,
3280 oid_to_hex(&j->item->object.oid));
3282 strbuf_release(&ref_name);
3283 unlink(git_path_cherry_pick_head(r));
3284 rollback_lock_file(&lock);
3286 rollback_lock_file(&lock);
3287 ret = run_command(&cmd);
3289 /* force re-reading of the cache */
3290 if (!ret && (discard_index(r->index) < 0 ||
3291 read_index(r->index) < 0))
3292 ret = error(_("could not read index"));
3296 merge_commit = to_merge->item;
3297 bases = get_merge_bases(head_commit, merge_commit);
3298 if (bases && oideq(&merge_commit->object.oid,
3299 &bases->item->object.oid)) {
3301 /* skip merging an ancestor of HEAD */
3305 write_message(oid_to_hex(&merge_commit->object.oid), GIT_SHA1_HEXSZ,
3306 git_path_merge_head(r), 0);
3307 write_message("no-ff", 5, git_path_merge_mode(r), 0);
3309 for (j = bases; j; j = j->next)
3310 commit_list_insert(j->item, &reversed);
3311 free_commit_list(bases);
3313 read_index(r->index);
3314 init_merge_options(&o);
3316 o.branch2 = ref_name.buf;
3317 o.buffer_output = 2;
3319 ret = merge_recursive(&o, head_commit, merge_commit, reversed, &i);
3321 fputs(o.obuf.buf, stdout);
3322 strbuf_release(&o.obuf);
3324 error(_("could not even attempt to merge '%.*s'"),
3325 merge_arg_len, arg);
3329 * The return value of merge_recursive() is 1 on clean, and 0 on
3332 * Let's reverse that, so that do_merge() returns 0 upon success and
3333 * 1 upon failed merge (keeping the return value -1 for the cases where
3334 * we will want to reschedule the `merge` command).
3338 if (r->index->cache_changed &&
3339 write_locked_index(r->index, &lock, COMMIT_LOCK)) {
3340 ret = error(_("merge: Unable to write new index file"));
3344 rollback_lock_file(&lock);
3346 repo_rerere(r, opts->allow_rerere_auto);
3349 * In case of problems, we now want to return a positive
3350 * value (a negative one would indicate that the `merge`
3351 * command needs to be rescheduled).
3353 ret = !!run_git_commit(r, git_path_merge_msg(r), opts,
3357 strbuf_release(&ref_name);
3358 rollback_lock_file(&lock);
3359 free_commit_list(to_merge);
3363 static int is_final_fixup(struct todo_list *todo_list)
3365 int i = todo_list->current;
3367 if (!is_fixup(todo_list->items[i].command))
3370 while (++i < todo_list->nr)
3371 if (is_fixup(todo_list->items[i].command))
3373 else if (!is_noop(todo_list->items[i].command))
3378 static enum todo_command peek_command(struct todo_list *todo_list, int offset)
3382 for (i = todo_list->current + offset; i < todo_list->nr; i++)
3383 if (!is_noop(todo_list->items[i].command))
3384 return todo_list->items[i].command;
3389 static int apply_autostash(struct replay_opts *opts)
3391 struct strbuf stash_sha1 = STRBUF_INIT;
3392 struct child_process child = CHILD_PROCESS_INIT;
3395 if (!read_oneliner(&stash_sha1, rebase_path_autostash(), 1)) {
3396 strbuf_release(&stash_sha1);
3399 strbuf_trim(&stash_sha1);
3402 child.no_stdout = 1;
3403 child.no_stderr = 1;
3404 argv_array_push(&child.args, "stash");
3405 argv_array_push(&child.args, "apply");
3406 argv_array_push(&child.args, stash_sha1.buf);
3407 if (!run_command(&child))
3408 fprintf(stderr, _("Applied autostash.\n"));
3410 struct child_process store = CHILD_PROCESS_INIT;
3413 argv_array_push(&store.args, "stash");
3414 argv_array_push(&store.args, "store");
3415 argv_array_push(&store.args, "-m");
3416 argv_array_push(&store.args, "autostash");
3417 argv_array_push(&store.args, "-q");
3418 argv_array_push(&store.args, stash_sha1.buf);
3419 if (run_command(&store))
3420 ret = error(_("cannot store %s"), stash_sha1.buf);
3423 _("Applying autostash resulted in conflicts.\n"
3424 "Your changes are safe in the stash.\n"
3425 "You can run \"git stash pop\" or"
3426 " \"git stash drop\" at any time.\n"));
3429 strbuf_release(&stash_sha1);
3433 static const char *reflog_message(struct replay_opts *opts,
3434 const char *sub_action, const char *fmt, ...)
3437 static struct strbuf buf = STRBUF_INIT;
3441 strbuf_addstr(&buf, action_name(opts));
3443 strbuf_addf(&buf, " (%s)", sub_action);
3445 strbuf_addstr(&buf, ": ");
3446 strbuf_vaddf(&buf, fmt, ap);
3453 static int run_git_checkout(struct replay_opts *opts, const char *commit,
3456 struct child_process cmd = CHILD_PROCESS_INIT;
3460 argv_array_push(&cmd.args, "checkout");
3461 argv_array_push(&cmd.args, commit);
3462 argv_array_pushf(&cmd.env_array, GIT_REFLOG_ACTION "=%s", action);
3465 return run_command(&cmd);
3467 return run_command_silent_on_success(&cmd);
3470 int prepare_branch_to_be_rebased(struct replay_opts *opts, const char *commit)
3474 if (commit && *commit) {
3475 action = reflog_message(opts, "start", "checkout %s", commit);
3476 if (run_git_checkout(opts, commit, action))
3477 return error(_("could not checkout %s"), commit);
3483 static int checkout_onto(struct replay_opts *opts,
3484 const char *onto_name, const char *onto,
3485 const char *orig_head)
3487 struct object_id oid;
3488 const char *action = reflog_message(opts, "start", "checkout %s", onto_name);
3490 if (get_oid(orig_head, &oid))
3491 return error(_("%s: not a valid OID"), orig_head);
3493 if (run_git_checkout(opts, onto, action)) {
3494 apply_autostash(opts);
3495 sequencer_remove_state(opts);
3496 return error(_("could not detach HEAD"));
3499 return update_ref(NULL, "ORIG_HEAD", &oid, NULL, 0, UPDATE_REFS_MSG_ON_ERR);
3502 static int stopped_at_head(struct repository *r)
3504 struct object_id head;
3505 struct commit *commit;
3506 struct commit_message message;
3508 if (get_oid("HEAD", &head) ||
3509 !(commit = lookup_commit(r, &head)) ||
3510 parse_commit(commit) || get_message(commit, &message))
3511 fprintf(stderr, _("Stopped at HEAD\n"));
3513 fprintf(stderr, _("Stopped at %s\n"), message.label);
3514 free_message(commit, &message);
3520 static const char rescheduled_advice[] =
3521 N_("Could not execute the todo command\n"
3525 "It has been rescheduled; To edit the command before continuing, please\n"
3526 "edit the todo list first:\n"
3528 " git rebase --edit-todo\n"
3529 " git rebase --continue\n");
3531 static int pick_commits(struct repository *r,
3532 struct todo_list *todo_list,
3533 struct replay_opts *opts)
3535 int res = 0, reschedule = 0;
3537 setenv(GIT_REFLOG_ACTION, action_name(opts), 0);
3539 assert(!(opts->signoff || opts->no_commit ||
3540 opts->record_origin || opts->edit));
3541 if (read_and_refresh_cache(r, opts))
3544 while (todo_list->current < todo_list->nr) {
3545 struct todo_item *item = todo_list->items + todo_list->current;
3546 if (save_todo(todo_list, opts))
3548 if (is_rebase_i(opts)) {
3549 if (item->command != TODO_COMMENT) {
3550 FILE *f = fopen(rebase_path_msgnum(), "w");
3552 todo_list->done_nr++;
3555 fprintf(f, "%d\n", todo_list->done_nr);
3559 fprintf(stderr, "Rebasing (%d/%d)%s",
3561 todo_list->total_nr,
3562 opts->verbose ? "\n" : "\r");
3564 unlink(rebase_path_message());
3565 unlink(rebase_path_author_script());
3566 unlink(rebase_path_stopped_sha());
3567 unlink(rebase_path_amend());
3568 unlink(git_path_merge_head(the_repository));
3569 delete_ref(NULL, "REBASE_HEAD", NULL, REF_NO_DEREF);
3571 if (item->command == TODO_BREAK)
3572 return stopped_at_head(r);
3574 if (item->command <= TODO_SQUASH) {
3575 if (is_rebase_i(opts))
3576 setenv("GIT_REFLOG_ACTION", reflog_message(opts,
3577 command_to_string(item->command), NULL),
3579 res = do_pick_commit(r, item->command, item->commit,
3580 opts, is_final_fixup(todo_list));
3581 if (is_rebase_i(opts) && res < 0) {
3583 advise(_(rescheduled_advice),
3584 get_item_line_length(todo_list,
3585 todo_list->current),
3586 get_item_line(todo_list,
3587 todo_list->current));
3588 todo_list->current--;
3589 if (save_todo(todo_list, opts))
3592 if (item->command == TODO_EDIT) {
3593 struct commit *commit = item->commit;
3596 _("Stopped at %s... %.*s\n"),
3597 short_commit_name(commit),
3598 item->arg_len, item->arg);
3599 return error_with_patch(r, commit,
3600 item->arg, item->arg_len, opts, res,
3603 if (is_rebase_i(opts) && !res)
3604 record_in_rewritten(&item->commit->object.oid,
3605 peek_command(todo_list, 1));
3606 if (res && is_fixup(item->command)) {
3609 return error_failed_squash(r, item->commit, opts,
3610 item->arg_len, item->arg);
3611 } else if (res && is_rebase_i(opts) && item->commit) {
3613 struct object_id oid;
3616 * If we are rewording and have either
3617 * fast-forwarded already, or are about to
3618 * create a new root commit, we want to amend,
3619 * otherwise we do not.
3621 if (item->command == TODO_REWORD &&
3622 !get_oid("HEAD", &oid) &&
3623 (oideq(&item->commit->object.oid, &oid) ||
3624 (opts->have_squash_onto &&
3625 oideq(&opts->squash_onto, &oid))))
3628 return res | error_with_patch(r, item->commit,
3629 item->arg, item->arg_len, opts,
3632 } else if (item->command == TODO_EXEC) {
3633 char *end_of_arg = (char *)(item->arg + item->arg_len);
3634 int saved = *end_of_arg;
3638 res = do_exec(r, item->arg);
3639 *end_of_arg = saved;
3641 /* Reread the todo file if it has changed. */
3643 if (opts->reschedule_failed_exec)
3645 } else if (stat(get_todo_path(opts), &st))
3646 res = error_errno(_("could not stat '%s'"),
3647 get_todo_path(opts));
3648 else if (match_stat_data(&todo_list->stat, &st)) {
3649 todo_list_release(todo_list);
3650 if (read_populate_todo(r, todo_list, opts))
3651 res = -1; /* message was printed */
3652 /* `current` will be incremented below */
3653 todo_list->current = -1;
3655 } else if (item->command == TODO_LABEL) {
3656 if ((res = do_label(r, item->arg, item->arg_len)))
3658 } else if (item->command == TODO_RESET) {
3659 if ((res = do_reset(r, item->arg, item->arg_len, opts)))
3661 } else if (item->command == TODO_MERGE) {
3662 if ((res = do_merge(r, item->commit,
3663 item->arg, item->arg_len,
3664 item->flags, opts)) < 0)
3666 else if (item->commit)
3667 record_in_rewritten(&item->commit->object.oid,
3668 peek_command(todo_list, 1));
3670 /* failed with merge conflicts */
3671 return error_with_patch(r, item->commit,
3673 item->arg_len, opts,
3675 } else if (!is_noop(item->command))
3676 return error(_("unknown command %d"), item->command);
3679 advise(_(rescheduled_advice),
3680 get_item_line_length(todo_list,
3681 todo_list->current),
3682 get_item_line(todo_list, todo_list->current));
3683 todo_list->current--;
3684 if (save_todo(todo_list, opts))
3687 return error_with_patch(r,
3690 item->arg_len, opts,
3694 todo_list->current++;
3699 if (is_rebase_i(opts)) {
3700 struct strbuf head_ref = STRBUF_INIT, buf = STRBUF_INIT;
3703 /* Stopped in the middle, as planned? */
3704 if (todo_list->current < todo_list->nr)
3707 if (read_oneliner(&head_ref, rebase_path_head_name(), 0) &&
3708 starts_with(head_ref.buf, "refs/")) {
3710 struct object_id head, orig;
3713 if (get_oid("HEAD", &head)) {
3714 res = error(_("cannot read HEAD"));
3716 strbuf_release(&head_ref);
3717 strbuf_release(&buf);
3720 if (!read_oneliner(&buf, rebase_path_orig_head(), 0) ||
3721 get_oid_hex(buf.buf, &orig)) {
3722 res = error(_("could not read orig-head"));
3723 goto cleanup_head_ref;
3726 if (!read_oneliner(&buf, rebase_path_onto(), 0)) {
3727 res = error(_("could not read 'onto'"));
3728 goto cleanup_head_ref;
3730 msg = reflog_message(opts, "finish", "%s onto %s",
3731 head_ref.buf, buf.buf);
3732 if (update_ref(msg, head_ref.buf, &head, &orig,
3733 REF_NO_DEREF, UPDATE_REFS_MSG_ON_ERR)) {
3734 res = error(_("could not update %s"),
3736 goto cleanup_head_ref;
3738 msg = reflog_message(opts, "finish", "returning to %s",
3740 if (create_symref("HEAD", head_ref.buf, msg)) {
3741 res = error(_("could not update HEAD to %s"),
3743 goto cleanup_head_ref;
3748 if (opts->verbose) {
3749 struct rev_info log_tree_opt;
3750 struct object_id orig, head;
3752 memset(&log_tree_opt, 0, sizeof(log_tree_opt));
3753 repo_init_revisions(r, &log_tree_opt, NULL);
3754 log_tree_opt.diff = 1;
3755 log_tree_opt.diffopt.output_format =
3756 DIFF_FORMAT_DIFFSTAT;
3757 log_tree_opt.disable_stdin = 1;
3759 if (read_oneliner(&buf, rebase_path_orig_head(), 0) &&
3760 !get_oid(buf.buf, &orig) &&
3761 !get_oid("HEAD", &head)) {
3762 diff_tree_oid(&orig, &head, "",
3763 &log_tree_opt.diffopt);
3764 log_tree_diff_flush(&log_tree_opt);
3767 flush_rewritten_pending();
3768 if (!stat(rebase_path_rewritten_list(), &st) &&
3770 struct child_process child = CHILD_PROCESS_INIT;
3771 const char *post_rewrite_hook =
3772 find_hook("post-rewrite");
3774 child.in = open(rebase_path_rewritten_list(), O_RDONLY);
3776 argv_array_push(&child.args, "notes");
3777 argv_array_push(&child.args, "copy");
3778 argv_array_push(&child.args, "--for-rewrite=rebase");
3779 /* we don't care if this copying failed */
3780 run_command(&child);
3782 if (post_rewrite_hook) {
3783 struct child_process hook = CHILD_PROCESS_INIT;
3785 hook.in = open(rebase_path_rewritten_list(),
3787 hook.stdout_to_stderr = 1;
3788 argv_array_push(&hook.args, post_rewrite_hook);
3789 argv_array_push(&hook.args, "rebase");
3790 /* we don't care if this hook failed */
3794 apply_autostash(opts);
3798 "Successfully rebased and updated %s.\n",
3801 strbuf_release(&buf);
3802 strbuf_release(&head_ref);
3806 * Sequence of picks finished successfully; cleanup by
3807 * removing the .git/sequencer directory
3809 return sequencer_remove_state(opts);
3812 static int continue_single_pick(struct repository *r)
3814 const char *argv[] = { "commit", NULL };
3816 if (!file_exists(git_path_cherry_pick_head(r)) &&
3817 !file_exists(git_path_revert_head(r)))
3818 return error(_("no cherry-pick or revert in progress"));
3819 return run_command_v_opt(argv, RUN_GIT_CMD);
3822 static int commit_staged_changes(struct repository *r,
3823 struct replay_opts *opts,
3824 struct todo_list *todo_list)
3826 unsigned int flags = ALLOW_EMPTY | EDIT_MSG;
3827 unsigned int final_fixup = 0, is_clean;
3829 if (has_unstaged_changes(r, 1))
3830 return error(_("cannot rebase: You have unstaged changes."));
3832 is_clean = !has_uncommitted_changes(r, 0);
3834 if (file_exists(rebase_path_amend())) {
3835 struct strbuf rev = STRBUF_INIT;
3836 struct object_id head, to_amend;
3838 if (get_oid("HEAD", &head))
3839 return error(_("cannot amend non-existing commit"));
3840 if (!read_oneliner(&rev, rebase_path_amend(), 0))
3841 return error(_("invalid file: '%s'"), rebase_path_amend());
3842 if (get_oid_hex(rev.buf, &to_amend))
3843 return error(_("invalid contents: '%s'"),
3844 rebase_path_amend());
3845 if (!is_clean && !oideq(&head, &to_amend))
3846 return error(_("\nYou have uncommitted changes in your "
3847 "working tree. Please, commit them\n"
3848 "first and then run 'git rebase "
3849 "--continue' again."));
3851 * When skipping a failed fixup/squash, we need to edit the
3852 * commit message, the current fixup list and count, and if it
3853 * was the last fixup/squash in the chain, we need to clean up
3854 * the commit message and if there was a squash, let the user
3857 if (!is_clean || !opts->current_fixup_count)
3858 ; /* this is not the final fixup */
3859 else if (!oideq(&head, &to_amend) ||
3860 !file_exists(rebase_path_stopped_sha())) {
3861 /* was a final fixup or squash done manually? */
3862 if (!is_fixup(peek_command(todo_list, 0))) {
3863 unlink(rebase_path_fixup_msg());
3864 unlink(rebase_path_squash_msg());
3865 unlink(rebase_path_current_fixups());
3866 strbuf_reset(&opts->current_fixups);
3867 opts->current_fixup_count = 0;
3870 /* we are in a fixup/squash chain */
3871 const char *p = opts->current_fixups.buf;
3872 int len = opts->current_fixups.len;
3874 opts->current_fixup_count--;
3876 BUG("Incorrect current_fixups:\n%s", p);
3877 while (len && p[len - 1] != '\n')
3879 strbuf_setlen(&opts->current_fixups, len);
3880 if (write_message(p, len, rebase_path_current_fixups(),
3882 return error(_("could not write file: '%s'"),
3883 rebase_path_current_fixups());
3886 * If a fixup/squash in a fixup/squash chain failed, the
3887 * commit message is already correct, no need to commit
3890 * Only if it is the final command in the fixup/squash
3891 * chain, and only if the chain is longer than a single
3892 * fixup/squash command (which was just skipped), do we
3893 * actually need to re-commit with a cleaned up commit
3896 if (opts->current_fixup_count > 0 &&
3897 !is_fixup(peek_command(todo_list, 0))) {
3900 * If there was not a single "squash" in the
3901 * chain, we only need to clean up the commit
3902 * message, no need to bother the user with
3903 * opening the commit message in the editor.
3905 if (!starts_with(p, "squash ") &&
3906 !strstr(p, "\nsquash "))
3907 flags = (flags & ~EDIT_MSG) | CLEANUP_MSG;
3908 } else if (is_fixup(peek_command(todo_list, 0))) {
3910 * We need to update the squash message to skip
3911 * the latest commit message.
3913 struct commit *commit;
3914 const char *path = rebase_path_squash_msg();
3916 if (parse_head(r, &commit) ||
3917 !(p = get_commit_buffer(commit, NULL)) ||
3918 write_message(p, strlen(p), path, 0)) {
3919 unuse_commit_buffer(commit, p);
3920 return error(_("could not write file: "
3923 unuse_commit_buffer(commit, p);
3927 strbuf_release(&rev);
3932 const char *cherry_pick_head = git_path_cherry_pick_head(r);
3934 if (file_exists(cherry_pick_head) && unlink(cherry_pick_head))
3935 return error(_("could not remove CHERRY_PICK_HEAD"));
3940 if (run_git_commit(r, final_fixup ? NULL : rebase_path_message(),
3942 return error(_("could not commit staged changes."));
3943 unlink(rebase_path_amend());
3944 unlink(git_path_merge_head(the_repository));
3946 unlink(rebase_path_fixup_msg());
3947 unlink(rebase_path_squash_msg());
3949 if (opts->current_fixup_count > 0) {
3951 * Whether final fixup or not, we just cleaned up the commit
3954 unlink(rebase_path_current_fixups());
3955 strbuf_reset(&opts->current_fixups);
3956 opts->current_fixup_count = 0;
3961 int sequencer_continue(struct repository *r, struct replay_opts *opts)
3963 struct todo_list todo_list = TODO_LIST_INIT;
3966 if (read_and_refresh_cache(r, opts))
3969 if (read_populate_opts(opts))
3971 if (is_rebase_i(opts)) {
3972 if ((res = read_populate_todo(r, &todo_list, opts)))
3973 goto release_todo_list;
3974 if (commit_staged_changes(r, opts, &todo_list))
3976 } else if (!file_exists(get_todo_path(opts)))
3977 return continue_single_pick(r);
3978 else if ((res = read_populate_todo(r, &todo_list, opts)))
3979 goto release_todo_list;
3981 if (!is_rebase_i(opts)) {
3982 /* Verify that the conflict has been resolved */
3983 if (file_exists(git_path_cherry_pick_head(r)) ||
3984 file_exists(git_path_revert_head(r))) {
3985 res = continue_single_pick(r);
3987 goto release_todo_list;
3989 if (index_differs_from(r, "HEAD", NULL, 0)) {
3990 res = error_dirty_index(r->index, opts);
3991 goto release_todo_list;
3993 todo_list.current++;
3994 } else if (file_exists(rebase_path_stopped_sha())) {
3995 struct strbuf buf = STRBUF_INIT;
3996 struct object_id oid;
3998 if (read_oneliner(&buf, rebase_path_stopped_sha(), 1) &&
3999 !get_oid_committish(buf.buf, &oid))
4000 record_in_rewritten(&oid, peek_command(&todo_list, 0));
4001 strbuf_release(&buf);
4004 res = pick_commits(r, &todo_list, opts);
4006 todo_list_release(&todo_list);
4010 static int single_pick(struct repository *r,
4011 struct commit *cmit,
4012 struct replay_opts *opts)
4014 setenv(GIT_REFLOG_ACTION, action_name(opts), 0);
4015 return do_pick_commit(r, opts->action == REPLAY_PICK ?
4016 TODO_PICK : TODO_REVERT, cmit, opts, 0);
4019 int sequencer_pick_revisions(struct repository *r,
4020 struct replay_opts *opts)
4022 struct todo_list todo_list = TODO_LIST_INIT;
4023 struct object_id oid;
4027 if (read_and_refresh_cache(r, opts))
4030 for (i = 0; i < opts->revs->pending.nr; i++) {
4031 struct object_id oid;
4032 const char *name = opts->revs->pending.objects[i].name;
4034 /* This happens when using --stdin. */
4038 if (!get_oid(name, &oid)) {
4039 if (!lookup_commit_reference_gently(r, &oid, 1)) {
4040 enum object_type type = oid_object_info(r,
4043 return error(_("%s: can't cherry-pick a %s"),
4044 name, type_name(type));
4047 return error(_("%s: bad revision"), name);
4051 * If we were called as "git cherry-pick <commit>", just
4052 * cherry-pick/revert it, set CHERRY_PICK_HEAD /
4053 * REVERT_HEAD, and don't touch the sequencer state.
4054 * This means it is possible to cherry-pick in the middle
4055 * of a cherry-pick sequence.
4057 if (opts->revs->cmdline.nr == 1 &&
4058 opts->revs->cmdline.rev->whence == REV_CMD_REV &&
4059 opts->revs->no_walk &&
4060 !opts->revs->cmdline.rev->flags) {
4061 struct commit *cmit;
4062 if (prepare_revision_walk(opts->revs))
4063 return error(_("revision walk setup failed"));
4064 cmit = get_revision(opts->revs);
4066 return error(_("empty commit set passed"));
4067 if (get_revision(opts->revs))
4068 BUG("unexpected extra commit from walk");
4069 return single_pick(r, cmit, opts);
4073 * Start a new cherry-pick/ revert sequence; but
4074 * first, make sure that an existing one isn't in
4078 if (walk_revs_populate_todo(&todo_list, opts) ||
4079 create_seq_dir() < 0)
4081 if (get_oid("HEAD", &oid) && (opts->action == REPLAY_REVERT))
4082 return error(_("can't revert as initial commit"));
4083 if (save_head(oid_to_hex(&oid)))
4085 if (save_opts(opts))
4087 update_abort_safety_file();
4088 res = pick_commits(r, &todo_list, opts);
4089 todo_list_release(&todo_list);
4093 void append_signoff(struct strbuf *msgbuf, size_t ignore_footer, unsigned flag)
4095 unsigned no_dup_sob = flag & APPEND_SIGNOFF_DEDUP;
4096 struct strbuf sob = STRBUF_INIT;
4099 strbuf_addstr(&sob, sign_off_header);
4100 strbuf_addstr(&sob, fmt_name(getenv("GIT_COMMITTER_NAME"),
4101 getenv("GIT_COMMITTER_EMAIL")));
4102 strbuf_addch(&sob, '\n');
4105 strbuf_complete_line(msgbuf);
4108 * If the whole message buffer is equal to the sob, pretend that we
4109 * found a conforming footer with a matching sob
4111 if (msgbuf->len - ignore_footer == sob.len &&
4112 !strncmp(msgbuf->buf, sob.buf, sob.len))
4115 has_footer = has_conforming_footer(msgbuf, &sob, ignore_footer);
4118 const char *append_newlines = NULL;
4119 size_t len = msgbuf->len - ignore_footer;
4123 * The buffer is completely empty. Leave foom for
4124 * the title and body to be filled in by the user.
4126 append_newlines = "\n\n";
4127 } else if (len == 1) {
4129 * Buffer contains a single newline. Add another
4130 * so that we leave room for the title and body.
4132 append_newlines = "\n";
4133 } else if (msgbuf->buf[len - 2] != '\n') {
4135 * Buffer ends with a single newline. Add another
4136 * so that there is an empty line between the message
4139 append_newlines = "\n";
4140 } /* else, the buffer already ends with two newlines. */
4142 if (append_newlines)
4143 strbuf_splice(msgbuf, msgbuf->len - ignore_footer, 0,
4144 append_newlines, strlen(append_newlines));
4147 if (has_footer != 3 && (!no_dup_sob || has_footer != 2))
4148 strbuf_splice(msgbuf, msgbuf->len - ignore_footer, 0,
4151 strbuf_release(&sob);
4154 struct labels_entry {
4155 struct hashmap_entry entry;
4156 char label[FLEX_ARRAY];
4159 static int labels_cmp(const void *fndata, const struct labels_entry *a,
4160 const struct labels_entry *b, const void *key)
4162 return key ? strcmp(a->label, key) : strcmp(a->label, b->label);
4165 struct string_entry {
4166 struct oidmap_entry entry;
4167 char string[FLEX_ARRAY];
4170 struct label_state {
4171 struct oidmap commit2label;
4172 struct hashmap labels;
4176 static const char *label_oid(struct object_id *oid, const char *label,
4177 struct label_state *state)
4179 struct labels_entry *labels_entry;
4180 struct string_entry *string_entry;
4181 struct object_id dummy;
4185 string_entry = oidmap_get(&state->commit2label, oid);
4187 return string_entry->string;
4190 * For "uninteresting" commits, i.e. commits that are not to be
4191 * rebased, and which can therefore not be labeled, we use a unique
4192 * abbreviation of the commit name. This is slightly more complicated
4193 * than calling find_unique_abbrev() because we also need to make
4194 * sure that the abbreviation does not conflict with any other
4197 * We disallow "interesting" commits to be labeled by a string that
4198 * is a valid full-length hash, to ensure that we always can find an
4199 * abbreviation for any uninteresting commit's names that does not
4200 * clash with any other label.
4205 strbuf_reset(&state->buf);
4206 strbuf_grow(&state->buf, GIT_SHA1_HEXSZ);
4207 label = p = state->buf.buf;
4209 find_unique_abbrev_r(p, oid, default_abbrev);
4212 * We may need to extend the abbreviated hash so that there is
4213 * no conflicting label.
4215 if (hashmap_get_from_hash(&state->labels, strihash(p), p)) {
4216 size_t i = strlen(p) + 1;
4218 oid_to_hex_r(p, oid);
4219 for (; i < GIT_SHA1_HEXSZ; i++) {
4222 if (!hashmap_get_from_hash(&state->labels,
4228 } else if (((len = strlen(label)) == the_hash_algo->hexsz &&
4229 !get_oid_hex(label, &dummy)) ||
4230 (len == 1 && *label == '#') ||
4231 hashmap_get_from_hash(&state->labels,
4232 strihash(label), label)) {
4234 * If the label already exists, or if the label is a valid full
4235 * OID, or the label is a '#' (which we use as a separator
4236 * between merge heads and oneline), we append a dash and a
4237 * number to make it unique.
4239 struct strbuf *buf = &state->buf;
4242 strbuf_add(buf, label, len);
4244 for (i = 2; ; i++) {
4245 strbuf_setlen(buf, len);
4246 strbuf_addf(buf, "-%d", i);
4247 if (!hashmap_get_from_hash(&state->labels,
4256 FLEX_ALLOC_STR(labels_entry, label, label);
4257 hashmap_entry_init(labels_entry, strihash(label));
4258 hashmap_add(&state->labels, labels_entry);
4260 FLEX_ALLOC_STR(string_entry, string, label);
4261 oidcpy(&string_entry->entry.oid, oid);
4262 oidmap_put(&state->commit2label, string_entry);
4264 return string_entry->string;
4267 static int make_script_with_merges(struct pretty_print_context *pp,
4268 struct rev_info *revs, FILE *out,
4271 int keep_empty = flags & TODO_LIST_KEEP_EMPTY;
4272 int rebase_cousins = flags & TODO_LIST_REBASE_COUSINS;
4273 struct strbuf buf = STRBUF_INIT, oneline = STRBUF_INIT;
4274 struct strbuf label = STRBUF_INIT;
4275 struct commit_list *commits = NULL, **tail = &commits, *iter;
4276 struct commit_list *tips = NULL, **tips_tail = &tips;
4277 struct commit *commit;
4278 struct oidmap commit2todo = OIDMAP_INIT;
4279 struct string_entry *entry;
4280 struct oidset interesting = OIDSET_INIT, child_seen = OIDSET_INIT,
4281 shown = OIDSET_INIT;
4282 struct label_state state = { OIDMAP_INIT, { NULL }, STRBUF_INIT };
4284 int abbr = flags & TODO_LIST_ABBREVIATE_CMDS;
4285 const char *cmd_pick = abbr ? "p" : "pick",
4286 *cmd_label = abbr ? "l" : "label",
4287 *cmd_reset = abbr ? "t" : "reset",
4288 *cmd_merge = abbr ? "m" : "merge";
4290 oidmap_init(&commit2todo, 0);
4291 oidmap_init(&state.commit2label, 0);
4292 hashmap_init(&state.labels, (hashmap_cmp_fn) labels_cmp, NULL, 0);
4293 strbuf_init(&state.buf, 32);
4295 if (revs->cmdline.nr && (revs->cmdline.rev[0].flags & BOTTOM)) {
4296 struct object_id *oid = &revs->cmdline.rev[0].item->oid;
4297 FLEX_ALLOC_STR(entry, string, "onto");
4298 oidcpy(&entry->entry.oid, oid);
4299 oidmap_put(&state.commit2label, entry);
4304 * - get onelines for all commits
4305 * - gather all branch tips (i.e. 2nd or later parents of merges)
4306 * - label all branch tips
4308 while ((commit = get_revision(revs))) {
4309 struct commit_list *to_merge;
4310 const char *p1, *p2;
4311 struct object_id *oid;
4314 tail = &commit_list_insert(commit, tail)->next;
4315 oidset_insert(&interesting, &commit->object.oid);
4317 is_empty = is_original_commit_empty(commit);
4318 if (!is_empty && (commit->object.flags & PATCHSAME))
4321 strbuf_reset(&oneline);
4322 pretty_print_commit(pp, commit, &oneline);
4324 to_merge = commit->parents ? commit->parents->next : NULL;
4326 /* non-merge commit: easy case */
4328 if (!keep_empty && is_empty)
4329 strbuf_addf(&buf, "%c ", comment_line_char);
4330 strbuf_addf(&buf, "%s %s %s", cmd_pick,
4331 oid_to_hex(&commit->object.oid),
4334 FLEX_ALLOC_STR(entry, string, buf.buf);
4335 oidcpy(&entry->entry.oid, &commit->object.oid);
4336 oidmap_put(&commit2todo, entry);
4341 /* Create a label */
4342 strbuf_reset(&label);
4343 if (skip_prefix(oneline.buf, "Merge ", &p1) &&
4344 (p1 = strchr(p1, '\'')) &&
4345 (p2 = strchr(++p1, '\'')))
4346 strbuf_add(&label, p1, p2 - p1);
4347 else if (skip_prefix(oneline.buf, "Merge pull request ",
4349 (p1 = strstr(p1, " from ")))
4350 strbuf_addstr(&label, p1 + strlen(" from "));
4352 strbuf_addbuf(&label, &oneline);
4354 for (p1 = label.buf; *p1; p1++)
4359 strbuf_addf(&buf, "%s -C %s",
4360 cmd_merge, oid_to_hex(&commit->object.oid));
4362 /* label the tips of merged branches */
4363 for (; to_merge; to_merge = to_merge->next) {
4364 oid = &to_merge->item->object.oid;
4365 strbuf_addch(&buf, ' ');
4367 if (!oidset_contains(&interesting, oid)) {
4368 strbuf_addstr(&buf, label_oid(oid, NULL,
4373 tips_tail = &commit_list_insert(to_merge->item,
4376 strbuf_addstr(&buf, label_oid(oid, label.buf, &state));
4378 strbuf_addf(&buf, " # %s", oneline.buf);
4380 FLEX_ALLOC_STR(entry, string, buf.buf);
4381 oidcpy(&entry->entry.oid, &commit->object.oid);
4382 oidmap_put(&commit2todo, entry);
4387 * - label branch points
4388 * - add HEAD to the branch tips
4390 for (iter = commits; iter; iter = iter->next) {
4391 struct commit_list *parent = iter->item->parents;
4392 for (; parent; parent = parent->next) {
4393 struct object_id *oid = &parent->item->object.oid;
4394 if (!oidset_contains(&interesting, oid))
4396 if (oidset_insert(&child_seen, oid))
4397 label_oid(oid, "branch-point", &state);
4400 /* Add HEAD as implict "tip of branch" */
4402 tips_tail = &commit_list_insert(iter->item,
4407 * Third phase: output the todo list. This is a bit tricky, as we
4408 * want to avoid jumping back and forth between revisions. To
4409 * accomplish that goal, we walk backwards from the branch tips,
4410 * gathering commits not yet shown, reversing the list on the fly,
4411 * then outputting that list (labeling revisions as needed).
4413 fprintf(out, "%s onto\n", cmd_label);
4414 for (iter = tips; iter; iter = iter->next) {
4415 struct commit_list *list = NULL, *iter2;
4417 commit = iter->item;
4418 if (oidset_contains(&shown, &commit->object.oid))
4420 entry = oidmap_get(&state.commit2label, &commit->object.oid);
4423 fprintf(out, "\n%c Branch %s\n", comment_line_char, entry->string);
4427 while (oidset_contains(&interesting, &commit->object.oid) &&
4428 !oidset_contains(&shown, &commit->object.oid)) {
4429 commit_list_insert(commit, &list);
4430 if (!commit->parents) {
4434 commit = commit->parents->item;
4438 fprintf(out, "%s %s\n", cmd_reset,
4439 rebase_cousins ? "onto" : "[new root]");
4441 const char *to = NULL;
4443 entry = oidmap_get(&state.commit2label,
4444 &commit->object.oid);
4447 else if (!rebase_cousins)
4448 to = label_oid(&commit->object.oid, NULL,
4451 if (!to || !strcmp(to, "onto"))
4452 fprintf(out, "%s onto\n", cmd_reset);
4454 strbuf_reset(&oneline);
4455 pretty_print_commit(pp, commit, &oneline);
4456 fprintf(out, "%s %s # %s\n",
4457 cmd_reset, to, oneline.buf);
4461 for (iter2 = list; iter2; iter2 = iter2->next) {
4462 struct object_id *oid = &iter2->item->object.oid;
4463 entry = oidmap_get(&commit2todo, oid);
4464 /* only show if not already upstream */
4466 fprintf(out, "%s\n", entry->string);
4467 entry = oidmap_get(&state.commit2label, oid);
4469 fprintf(out, "%s %s\n",
4470 cmd_label, entry->string);
4471 oidset_insert(&shown, oid);
4474 free_commit_list(list);
4477 free_commit_list(commits);
4478 free_commit_list(tips);
4480 strbuf_release(&label);
4481 strbuf_release(&oneline);
4482 strbuf_release(&buf);
4484 oidmap_free(&commit2todo, 1);
4485 oidmap_free(&state.commit2label, 1);
4486 hashmap_free(&state.labels, 1);
4487 strbuf_release(&state.buf);
4492 int sequencer_make_script(struct repository *r, FILE *out,
4493 int argc, const char **argv,
4496 char *format = NULL;
4497 struct pretty_print_context pp = {0};
4498 struct strbuf buf = STRBUF_INIT;
4499 struct rev_info revs;
4500 struct commit *commit;
4501 int keep_empty = flags & TODO_LIST_KEEP_EMPTY;
4502 const char *insn = flags & TODO_LIST_ABBREVIATE_CMDS ? "p" : "pick";
4503 int rebase_merges = flags & TODO_LIST_REBASE_MERGES;
4505 repo_init_revisions(r, &revs, NULL);
4506 revs.verbose_header = 1;
4508 revs.max_parents = 1;
4509 revs.cherry_mark = 1;
4512 revs.right_only = 1;
4513 revs.sort_order = REV_SORT_IN_GRAPH_ORDER;
4514 revs.topo_order = 1;
4516 revs.pretty_given = 1;
4517 git_config_get_string("rebase.instructionFormat", &format);
4518 if (!format || !*format) {
4520 format = xstrdup("%s");
4522 get_commit_format(format, &revs);
4524 pp.fmt = revs.commit_format;
4525 pp.output_encoding = get_log_output_encoding();
4527 if (setup_revisions(argc, argv, &revs, NULL) > 1)
4528 return error(_("make_script: unhandled options"));
4530 if (prepare_revision_walk(&revs) < 0)
4531 return error(_("make_script: error preparing revisions"));
4534 return make_script_with_merges(&pp, &revs, out, flags);
4536 while ((commit = get_revision(&revs))) {
4537 int is_empty = is_original_commit_empty(commit);
4539 if (!is_empty && (commit->object.flags & PATCHSAME))
4542 if (!keep_empty && is_empty)
4543 strbuf_addf(&buf, "%c ", comment_line_char);
4544 strbuf_addf(&buf, "%s %s ", insn,
4545 oid_to_hex(&commit->object.oid));
4546 pretty_print_commit(&pp, commit, &buf);
4547 strbuf_addch(&buf, '\n');
4548 fputs(buf.buf, out);
4550 strbuf_release(&buf);
4555 * Add commands after pick and (series of) squash/fixup commands
4558 int sequencer_add_exec_commands(struct repository *r,
4559 const char *commands)
4561 const char *todo_file = rebase_path_todo();
4562 struct todo_list todo_list = TODO_LIST_INIT;
4563 struct strbuf *buf = &todo_list.buf;
4564 size_t offset = 0, commands_len = strlen(commands);
4567 if (strbuf_read_file(&todo_list.buf, todo_file, 0) < 0)
4568 return error(_("could not read '%s'."), todo_file);
4570 if (parse_insn_buffer(r, todo_list.buf.buf, &todo_list)) {
4571 todo_list_release(&todo_list);
4572 return error(_("unusable todo list: '%s'"), todo_file);
4576 * Insert <commands> after every pick. Here, fixup/squash chains
4577 * are considered part of the pick, so we insert the commands *after*
4578 * those chains if there are any.
4581 for (i = 0; i < todo_list.nr; i++) {
4582 enum todo_command command = todo_list.items[i].command;
4585 /* skip fixup/squash chains */
4586 if (command == TODO_COMMENT)
4588 else if (is_fixup(command)) {
4593 todo_list.items[insert].offset_in_buf +
4594 offset, commands, commands_len);
4595 offset += commands_len;
4599 if (command == TODO_PICK || command == TODO_MERGE)
4603 /* insert or append final <commands> */
4604 if (insert >= 0 && insert < todo_list.nr)
4605 strbuf_insert(buf, todo_list.items[insert].offset_in_buf +
4606 offset, commands, commands_len);
4607 else if (insert >= 0 || !offset)
4608 strbuf_add(buf, commands, commands_len);
4610 i = write_message(buf->buf, buf->len, todo_file, 0);
4611 todo_list_release(&todo_list);
4615 int transform_todos(struct repository *r, unsigned flags)
4617 const char *todo_file = rebase_path_todo();
4618 struct todo_list todo_list = TODO_LIST_INIT;
4619 struct strbuf buf = STRBUF_INIT;
4620 struct todo_item *item;
4623 if (strbuf_read_file(&todo_list.buf, todo_file, 0) < 0)
4624 return error(_("could not read '%s'."), todo_file);
4626 if (parse_insn_buffer(r, todo_list.buf.buf, &todo_list)) {
4627 todo_list_release(&todo_list);
4628 return error(_("unusable todo list: '%s'"), todo_file);
4631 for (item = todo_list.items, i = 0; i < todo_list.nr; i++, item++) {
4632 /* if the item is not a command write it and continue */
4633 if (item->command >= TODO_COMMENT) {
4634 strbuf_addf(&buf, "%.*s\n", item->arg_len, item->arg);
4638 /* add command to the buffer */
4639 if (flags & TODO_LIST_ABBREVIATE_CMDS)
4640 strbuf_addch(&buf, command_to_char(item->command));
4642 strbuf_addstr(&buf, command_to_string(item->command));
4646 const char *oid = flags & TODO_LIST_SHORTEN_IDS ?
4647 short_commit_name(item->commit) :
4648 oid_to_hex(&item->commit->object.oid);
4650 if (item->command == TODO_MERGE) {
4651 if (item->flags & TODO_EDIT_MERGE_MSG)
4652 strbuf_addstr(&buf, " -c");
4654 strbuf_addstr(&buf, " -C");
4657 strbuf_addf(&buf, " %s", oid);
4660 /* add all the rest */
4662 strbuf_addch(&buf, '\n');
4664 strbuf_addf(&buf, " %.*s\n", item->arg_len, item->arg);
4667 i = write_message(buf.buf, buf.len, todo_file, 0);
4668 todo_list_release(&todo_list);
4672 enum missing_commit_check_level get_missing_commit_check_level(void)
4676 if (git_config_get_value("rebase.missingcommitscheck", &value) ||
4677 !strcasecmp("ignore", value))
4678 return MISSING_COMMIT_CHECK_IGNORE;
4679 if (!strcasecmp("warn", value))
4680 return MISSING_COMMIT_CHECK_WARN;
4681 if (!strcasecmp("error", value))
4682 return MISSING_COMMIT_CHECK_ERROR;
4683 warning(_("unrecognized setting %s for option "
4684 "rebase.missingCommitsCheck. Ignoring."), value);
4685 return MISSING_COMMIT_CHECK_IGNORE;
4688 define_commit_slab(commit_seen, unsigned char);
4690 * Check if the user dropped some commits by mistake
4691 * Behaviour determined by rebase.missingCommitsCheck.
4692 * Check if there is an unrecognized command or a
4693 * bad SHA-1 in a command.
4695 int check_todo_list(struct repository *r)
4697 enum missing_commit_check_level check_level = get_missing_commit_check_level();
4698 struct strbuf todo_file = STRBUF_INIT;
4699 struct todo_list todo_list = TODO_LIST_INIT;
4700 struct strbuf missing = STRBUF_INIT;
4701 int advise_to_edit_todo = 0, res = 0, i;
4702 struct commit_seen commit_seen;
4704 init_commit_seen(&commit_seen);
4706 strbuf_addstr(&todo_file, rebase_path_todo());
4707 if (strbuf_read_file_or_whine(&todo_list.buf, todo_file.buf) < 0) {
4711 advise_to_edit_todo = res =
4712 parse_insn_buffer(r, todo_list.buf.buf, &todo_list);
4714 if (res || check_level == MISSING_COMMIT_CHECK_IGNORE)
4717 /* Mark the commits in git-rebase-todo as seen */
4718 for (i = 0; i < todo_list.nr; i++) {
4719 struct commit *commit = todo_list.items[i].commit;
4721 *commit_seen_at(&commit_seen, commit) = 1;
4724 todo_list_release(&todo_list);
4725 strbuf_addstr(&todo_file, ".backup");
4726 if (strbuf_read_file_or_whine(&todo_list.buf, todo_file.buf) < 0) {
4730 strbuf_release(&todo_file);
4731 res = !!parse_insn_buffer(r, todo_list.buf.buf, &todo_list);
4733 /* Find commits in git-rebase-todo.backup yet unseen */
4734 for (i = todo_list.nr - 1; i >= 0; i--) {
4735 struct todo_item *item = todo_list.items + i;
4736 struct commit *commit = item->commit;
4737 if (commit && !*commit_seen_at(&commit_seen, commit)) {
4738 strbuf_addf(&missing, " - %s %.*s\n",
4739 short_commit_name(commit),
4740 item->arg_len, item->arg);
4741 *commit_seen_at(&commit_seen, commit) = 1;
4745 /* Warn about missing commits */
4749 if (check_level == MISSING_COMMIT_CHECK_ERROR)
4750 advise_to_edit_todo = res = 1;
4753 _("Warning: some commits may have been dropped accidentally.\n"
4754 "Dropped commits (newer to older):\n"));
4756 /* Make the list user-friendly and display */
4757 fputs(missing.buf, stderr);
4758 strbuf_release(&missing);
4760 fprintf(stderr, _("To avoid this message, use \"drop\" to "
4761 "explicitly remove a commit.\n\n"
4762 "Use 'git config rebase.missingCommitsCheck' to change "
4763 "the level of warnings.\n"
4764 "The possible behaviours are: ignore, warn, error.\n\n"));
4767 clear_commit_seen(&commit_seen);
4768 strbuf_release(&todo_file);
4769 todo_list_release(&todo_list);
4771 if (advise_to_edit_todo)
4773 _("You can fix this with 'git rebase --edit-todo' "
4774 "and then run 'git rebase --continue'.\n"
4775 "Or you can abort the rebase with 'git rebase"
4781 static int rewrite_file(const char *path, const char *buf, size_t len)
4784 int fd = open(path, O_WRONLY | O_TRUNC);
4786 return error_errno(_("could not open '%s' for writing"), path);
4787 if (write_in_full(fd, buf, len) < 0)
4788 rc = error_errno(_("could not write to '%s'"), path);
4789 if (close(fd) && !rc)
4790 rc = error_errno(_("could not close '%s'"), path);
4794 /* skip picking commits whose parents are unchanged */
4795 static int skip_unnecessary_picks(struct repository *r, struct object_id *output_oid)
4797 const char *todo_file = rebase_path_todo();
4798 struct strbuf buf = STRBUF_INIT;
4799 struct todo_list todo_list = TODO_LIST_INIT;
4800 struct object_id *parent_oid;
4803 if (!read_oneliner(&buf, rebase_path_onto(), 0))
4804 return error(_("could not read 'onto'"));
4805 if (get_oid(buf.buf, output_oid)) {
4806 strbuf_release(&buf);
4807 return error(_("need a HEAD to fixup"));
4809 strbuf_release(&buf);
4811 if (strbuf_read_file_or_whine(&todo_list.buf, todo_file) < 0)
4813 if (parse_insn_buffer(r, todo_list.buf.buf, &todo_list) < 0) {
4814 todo_list_release(&todo_list);
4818 for (i = 0; i < todo_list.nr; i++) {
4819 struct todo_item *item = todo_list.items + i;
4821 if (item->command >= TODO_NOOP)
4823 if (item->command != TODO_PICK)
4825 if (parse_commit(item->commit)) {
4826 todo_list_release(&todo_list);
4827 return error(_("could not parse commit '%s'"),
4828 oid_to_hex(&item->commit->object.oid));
4830 if (!item->commit->parents)
4831 break; /* root commit */
4832 if (item->commit->parents->next)
4833 break; /* merge commit */
4834 parent_oid = &item->commit->parents->item->object.oid;
4835 if (!oideq(parent_oid, output_oid))
4837 oidcpy(output_oid, &item->commit->object.oid);
4840 int offset = get_item_line_offset(&todo_list, i);
4841 const char *done_path = rebase_path_done();
4843 fd = open(done_path, O_CREAT | O_WRONLY | O_APPEND, 0666);
4845 error_errno(_("could not open '%s' for writing"),
4847 todo_list_release(&todo_list);
4850 if (write_in_full(fd, todo_list.buf.buf, offset) < 0) {
4851 error_errno(_("could not write to '%s'"), done_path);
4852 todo_list_release(&todo_list);
4858 if (rewrite_file(rebase_path_todo(), todo_list.buf.buf + offset,
4859 todo_list.buf.len - offset) < 0) {
4860 todo_list_release(&todo_list);
4864 todo_list.current = i;
4865 if (is_fixup(peek_command(&todo_list, 0)))
4866 record_in_rewritten(output_oid, peek_command(&todo_list, 0));
4869 todo_list_release(&todo_list);
4874 int complete_action(struct repository *r, struct replay_opts *opts, unsigned flags,
4875 const char *shortrevisions, const char *onto_name,
4876 const char *onto, const char *orig_head, const char *cmd,
4877 unsigned autosquash)
4879 const char *shortonto, *todo_file = rebase_path_todo();
4880 struct todo_list todo_list = TODO_LIST_INIT;
4881 struct strbuf *buf = &(todo_list.buf);
4882 struct object_id oid;
4885 get_oid(onto, &oid);
4886 shortonto = find_unique_abbrev(&oid, DEFAULT_ABBREV);
4888 if (!lstat(todo_file, &st) && st.st_size == 0 &&
4889 write_message("noop\n", 5, todo_file, 0))
4892 if (autosquash && rearrange_squash(r))
4896 sequencer_add_exec_commands(r, cmd);
4898 if (strbuf_read_file(buf, todo_file, 0) < 0)
4899 return error_errno(_("could not read '%s'."), todo_file);
4901 if (parse_insn_buffer(r, buf->buf, &todo_list)) {
4902 todo_list_release(&todo_list);
4903 return error(_("unusable todo list: '%s'"), todo_file);
4906 if (count_commands(&todo_list) == 0) {
4907 apply_autostash(opts);
4908 sequencer_remove_state(opts);
4909 todo_list_release(&todo_list);
4911 return error(_("nothing to do"));
4914 strbuf_addch(buf, '\n');
4915 strbuf_commented_addf(buf, Q_("Rebase %s onto %s (%d command)",
4916 "Rebase %s onto %s (%d commands)",
4917 count_commands(&todo_list)),
4918 shortrevisions, shortonto, count_commands(&todo_list));
4919 append_todo_help(0, flags & TODO_LIST_KEEP_EMPTY, buf);
4921 if (write_message(buf->buf, buf->len, todo_file, 0)) {
4922 todo_list_release(&todo_list);
4926 if (copy_file(rebase_path_todo_backup(), todo_file, 0666))
4927 return error(_("could not copy '%s' to '%s'."), todo_file,
4928 rebase_path_todo_backup());
4930 if (transform_todos(r, flags | TODO_LIST_SHORTEN_IDS))
4931 return error(_("could not transform the todo list"));
4935 if (launch_sequence_editor(todo_file, buf, NULL)) {
4936 apply_autostash(opts);
4937 sequencer_remove_state(opts);
4938 todo_list_release(&todo_list);
4943 strbuf_stripspace(buf, 1);
4944 if (buf->len == 0) {
4945 apply_autostash(opts);
4946 sequencer_remove_state(opts);
4947 todo_list_release(&todo_list);
4949 return error(_("nothing to do"));
4952 todo_list_release(&todo_list);
4954 if (check_todo_list(r)) {
4955 checkout_onto(opts, onto_name, onto, orig_head);
4959 if (transform_todos(r, flags & ~(TODO_LIST_SHORTEN_IDS)))
4960 return error(_("could not transform the todo list"));
4962 if (opts->allow_ff && skip_unnecessary_picks(r, &oid))
4963 return error(_("could not skip unnecessary pick commands"));
4965 if (checkout_onto(opts, onto_name, oid_to_hex(&oid), orig_head))
4968 if (require_clean_work_tree(r, "rebase", "", 1, 1))
4971 return sequencer_continue(r, opts);
4974 struct subject2item_entry {
4975 struct hashmap_entry entry;
4977 char subject[FLEX_ARRAY];
4980 static int subject2item_cmp(const void *fndata,
4981 const struct subject2item_entry *a,
4982 const struct subject2item_entry *b, const void *key)
4984 return key ? strcmp(a->subject, key) : strcmp(a->subject, b->subject);
4987 define_commit_slab(commit_todo_item, struct todo_item *);
4990 * Rearrange the todo list that has both "pick commit-id msg" and "pick
4991 * commit-id fixup!/squash! msg" in it so that the latter is put immediately
4992 * after the former, and change "pick" to "fixup"/"squash".
4994 * Note that if the config has specified a custom instruction format, each log
4995 * message will have to be retrieved from the commit (as the oneline in the
4996 * script cannot be trusted) in order to normalize the autosquash arrangement.
4998 int rearrange_squash(struct repository *r)
5000 const char *todo_file = rebase_path_todo();
5001 struct todo_list todo_list = TODO_LIST_INIT;
5002 struct hashmap subject2item;
5003 int res = 0, rearranged = 0, *next, *tail, i;
5005 struct commit_todo_item commit_todo;
5007 if (strbuf_read_file_or_whine(&todo_list.buf, todo_file) < 0)
5009 if (parse_insn_buffer(r, todo_list.buf.buf, &todo_list) < 0) {
5010 todo_list_release(&todo_list);
5014 init_commit_todo_item(&commit_todo);
5016 * The hashmap maps onelines to the respective todo list index.
5018 * If any items need to be rearranged, the next[i] value will indicate
5019 * which item was moved directly after the i'th.
5021 * In that case, last[i] will indicate the index of the latest item to
5022 * be moved to appear after the i'th.
5024 hashmap_init(&subject2item, (hashmap_cmp_fn) subject2item_cmp,
5025 NULL, todo_list.nr);
5026 ALLOC_ARRAY(next, todo_list.nr);
5027 ALLOC_ARRAY(tail, todo_list.nr);
5028 ALLOC_ARRAY(subjects, todo_list.nr);
5029 for (i = 0; i < todo_list.nr; i++) {
5030 struct strbuf buf = STRBUF_INIT;
5031 struct todo_item *item = todo_list.items + i;
5032 const char *commit_buffer, *subject, *p;
5035 struct subject2item_entry *entry;
5037 next[i] = tail[i] = -1;
5038 if (!item->commit || item->command == TODO_DROP) {
5043 if (is_fixup(item->command)) {
5044 todo_list_release(&todo_list);
5045 clear_commit_todo_item(&commit_todo);
5046 return error(_("the script was already rearranged."));
5049 *commit_todo_item_at(&commit_todo, item->commit) = item;
5051 parse_commit(item->commit);
5052 commit_buffer = get_commit_buffer(item->commit, NULL);
5053 find_commit_subject(commit_buffer, &subject);
5054 format_subject(&buf, subject, " ");
5055 subject = subjects[i] = strbuf_detach(&buf, &subject_len);
5056 unuse_commit_buffer(item->commit, commit_buffer);
5057 if ((skip_prefix(subject, "fixup! ", &p) ||
5058 skip_prefix(subject, "squash! ", &p))) {
5059 struct commit *commit2;
5064 if (!skip_prefix(p, "fixup! ", &p) &&
5065 !skip_prefix(p, "squash! ", &p))
5069 if ((entry = hashmap_get_from_hash(&subject2item,
5071 /* found by title */
5073 else if (!strchr(p, ' ') &&
5075 lookup_commit_reference_by_name(p)) &&
5076 *commit_todo_item_at(&commit_todo, commit2))
5077 /* found by commit name */
5078 i2 = *commit_todo_item_at(&commit_todo, commit2)
5081 /* copy can be a prefix of the commit subject */
5082 for (i2 = 0; i2 < i; i2++)
5084 starts_with(subjects[i2], p))
5092 todo_list.items[i].command =
5093 starts_with(subject, "fixup!") ?
5094 TODO_FIXUP : TODO_SQUASH;
5100 } else if (!hashmap_get_from_hash(&subject2item,
5101 strhash(subject), subject)) {
5102 FLEX_ALLOC_MEM(entry, subject, subject, subject_len);
5104 hashmap_entry_init(entry, strhash(entry->subject));
5105 hashmap_put(&subject2item, entry);
5110 struct strbuf buf = STRBUF_INIT;
5112 for (i = 0; i < todo_list.nr; i++) {
5113 enum todo_command command = todo_list.items[i].command;
5117 * Initially, all commands are 'pick's. If it is a
5118 * fixup or a squash now, we have rearranged it.
5120 if (is_fixup(command))
5125 get_item_line(&todo_list, cur);
5127 get_item_line(&todo_list, cur + 1);
5129 /* replace 'pick', by 'fixup' or 'squash' */
5130 command = todo_list.items[cur].command;
5131 if (is_fixup(command)) {
5133 todo_command_info[command].str);
5134 bol += strcspn(bol, " \t");
5137 strbuf_add(&buf, bol, eol - bol);
5143 res = rewrite_file(todo_file, buf.buf, buf.len);
5144 strbuf_release(&buf);
5149 for (i = 0; i < todo_list.nr; i++)
5152 hashmap_free(&subject2item, 1);
5153 todo_list_release(&todo_list);
5155 clear_commit_todo_item(&commit_todo);