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 static 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 GIT_PATH_FUNC(rebase_path_todo_backup, "rebase-merge/git-rebase-todo.backup")
60 GIT_PATH_FUNC(rebase_path_dropped, "rebase-merge/dropped")
63 * The rebase command lines that have already been processed. A line
64 * is moved here when it is first handled, before any associated user
67 static GIT_PATH_FUNC(rebase_path_done, "rebase-merge/done")
69 * The file to keep track of how many commands were already processed (e.g.
72 static GIT_PATH_FUNC(rebase_path_msgnum, "rebase-merge/msgnum")
74 * The file to keep track of how many commands are to be processed in total
75 * (e.g. for the prompt).
77 static GIT_PATH_FUNC(rebase_path_msgtotal, "rebase-merge/end")
79 * The commit message that is planned to be used for any changes that
80 * need to be committed following a user interaction.
82 static GIT_PATH_FUNC(rebase_path_message, "rebase-merge/message")
84 * The file into which is accumulated the suggested commit message for
85 * squash/fixup commands. When the first of a series of squash/fixups
86 * is seen, the file is created and the commit message from the
87 * previous commit and from the first squash/fixup commit are written
88 * to it. The commit message for each subsequent squash/fixup commit
89 * is appended to the file as it is processed.
91 static GIT_PATH_FUNC(rebase_path_squash_msg, "rebase-merge/message-squash")
93 * If the current series of squash/fixups has not yet included a squash
94 * command, then this file exists and holds the commit message of the
95 * original "pick" commit. (If the series ends without a "squash"
96 * command, then this can be used as the commit message of the combined
97 * commit without opening the editor.)
99 static GIT_PATH_FUNC(rebase_path_fixup_msg, "rebase-merge/message-fixup")
101 * This file contains the list fixup/squash commands that have been
102 * accumulated into message-fixup or message-squash so far.
104 static GIT_PATH_FUNC(rebase_path_current_fixups, "rebase-merge/current-fixups")
106 * A script to set the GIT_AUTHOR_NAME, GIT_AUTHOR_EMAIL, and
107 * GIT_AUTHOR_DATE that will be used for the commit that is currently
110 static GIT_PATH_FUNC(rebase_path_author_script, "rebase-merge/author-script")
112 * When an "edit" rebase command is being processed, the SHA1 of the
113 * commit to be edited is recorded in this file. When "git rebase
114 * --continue" is executed, if there are any staged changes then they
115 * will be amended to the HEAD commit, but only provided the HEAD
116 * commit is still the commit to be edited. When any other rebase
117 * command is processed, this file is deleted.
119 static GIT_PATH_FUNC(rebase_path_amend, "rebase-merge/amend")
121 * When we stop at a given patch via the "edit" command, this file contains
122 * the abbreviated commit name of the corresponding patch.
124 static GIT_PATH_FUNC(rebase_path_stopped_sha, "rebase-merge/stopped-sha")
126 * For the post-rewrite hook, we make a list of rewritten commits and
127 * their new sha1s. The rewritten-pending list keeps the sha1s of
128 * commits that have been processed, but not committed yet,
129 * e.g. because they are waiting for a 'squash' command.
131 static GIT_PATH_FUNC(rebase_path_rewritten_list, "rebase-merge/rewritten-list")
132 static GIT_PATH_FUNC(rebase_path_rewritten_pending,
133 "rebase-merge/rewritten-pending")
136 * The path of the file containing the OID of the "squash onto" commit, i.e.
137 * the dummy commit used for `reset [new root]`.
139 static GIT_PATH_FUNC(rebase_path_squash_onto, "rebase-merge/squash-onto")
142 * The path of the file listing refs that need to be deleted after the rebase
143 * finishes. This is used by the `label` command to record the need for cleanup.
145 static GIT_PATH_FUNC(rebase_path_refs_to_delete, "rebase-merge/refs-to-delete")
148 * The following files are written by git-rebase just after parsing the
151 static GIT_PATH_FUNC(rebase_path_gpg_sign_opt, "rebase-merge/gpg_sign_opt")
152 static GIT_PATH_FUNC(rebase_path_orig_head, "rebase-merge/orig-head")
153 static GIT_PATH_FUNC(rebase_path_verbose, "rebase-merge/verbose")
154 static GIT_PATH_FUNC(rebase_path_quiet, "rebase-merge/quiet")
155 static GIT_PATH_FUNC(rebase_path_signoff, "rebase-merge/signoff")
156 static GIT_PATH_FUNC(rebase_path_head_name, "rebase-merge/head-name")
157 static GIT_PATH_FUNC(rebase_path_onto, "rebase-merge/onto")
158 static GIT_PATH_FUNC(rebase_path_autostash, "rebase-merge/autostash")
159 static GIT_PATH_FUNC(rebase_path_strategy, "rebase-merge/strategy")
160 static GIT_PATH_FUNC(rebase_path_strategy_opts, "rebase-merge/strategy_opts")
161 static GIT_PATH_FUNC(rebase_path_allow_rerere_autoupdate, "rebase-merge/allow_rerere_autoupdate")
162 static GIT_PATH_FUNC(rebase_path_reschedule_failed_exec, "rebase-merge/reschedule-failed-exec")
163 static GIT_PATH_FUNC(rebase_path_drop_redundant_commits, "rebase-merge/drop_redundant_commits")
164 static GIT_PATH_FUNC(rebase_path_keep_redundant_commits, "rebase-merge/keep_redundant_commits")
166 static int git_sequencer_config(const char *k, const char *v, void *cb)
168 struct replay_opts *opts = cb;
171 if (!strcmp(k, "commit.cleanup")) {
174 status = git_config_string(&s, k, v);
178 if (!strcmp(s, "verbatim")) {
179 opts->default_msg_cleanup = COMMIT_MSG_CLEANUP_NONE;
180 opts->explicit_cleanup = 1;
181 } else if (!strcmp(s, "whitespace")) {
182 opts->default_msg_cleanup = COMMIT_MSG_CLEANUP_SPACE;
183 opts->explicit_cleanup = 1;
184 } else if (!strcmp(s, "strip")) {
185 opts->default_msg_cleanup = COMMIT_MSG_CLEANUP_ALL;
186 opts->explicit_cleanup = 1;
187 } else if (!strcmp(s, "scissors")) {
188 opts->default_msg_cleanup = COMMIT_MSG_CLEANUP_SCISSORS;
189 opts->explicit_cleanup = 1;
191 warning(_("invalid commit message cleanup mode '%s'"),
199 if (!strcmp(k, "commit.gpgsign")) {
200 opts->gpg_sign = git_config_bool(k, v) ? xstrdup("") : NULL;
204 status = git_gpg_config(k, v, NULL);
208 return git_diff_basic_config(k, v, NULL);
211 void sequencer_init_config(struct replay_opts *opts)
213 opts->default_msg_cleanup = COMMIT_MSG_CLEANUP_NONE;
214 git_config(git_sequencer_config, opts);
217 static inline int is_rebase_i(const struct replay_opts *opts)
219 return opts->action == REPLAY_INTERACTIVE_REBASE;
222 static const char *get_dir(const struct replay_opts *opts)
224 if (is_rebase_i(opts))
225 return rebase_path();
226 return git_path_seq_dir();
229 static const char *get_todo_path(const struct replay_opts *opts)
231 if (is_rebase_i(opts))
232 return rebase_path_todo();
233 return git_path_todo_file();
237 * Returns 0 for non-conforming footer
238 * Returns 1 for conforming footer
239 * Returns 2 when sob exists within conforming footer
240 * Returns 3 when sob exists within conforming footer as last entry
242 static int has_conforming_footer(struct strbuf *sb, struct strbuf *sob,
243 size_t ignore_footer)
245 struct process_trailer_options opts = PROCESS_TRAILER_OPTIONS_INIT;
246 struct trailer_info info;
248 int found_sob = 0, found_sob_last = 0;
252 trailer_info_get(&info, sb->buf, &opts);
254 if (info.trailer_start == info.trailer_end)
257 for (i = 0; i < info.trailer_nr; i++)
258 if (sob && !strncmp(info.trailers[i], sob->buf, sob->len)) {
260 if (i == info.trailer_nr - 1)
264 trailer_info_release(&info);
273 static const char *gpg_sign_opt_quoted(struct replay_opts *opts)
275 static struct strbuf buf = STRBUF_INIT;
279 sq_quotef(&buf, "-S%s", opts->gpg_sign);
283 int sequencer_remove_state(struct replay_opts *opts)
285 struct strbuf buf = STRBUF_INIT;
288 if (is_rebase_i(opts) &&
289 strbuf_read_file(&buf, rebase_path_refs_to_delete(), 0) > 0) {
292 char *eol = strchr(p, '\n');
295 if (delete_ref("(rebase) cleanup", p, NULL, 0) < 0) {
296 warning(_("could not delete '%s'"), p);
305 free(opts->gpg_sign);
306 free(opts->strategy);
307 for (i = 0; i < opts->xopts_nr; i++)
308 free(opts->xopts[i]);
310 strbuf_release(&opts->current_fixups);
313 strbuf_addstr(&buf, get_dir(opts));
314 if (remove_dir_recursively(&buf, 0))
315 ret = error(_("could not remove '%s'"), buf.buf);
316 strbuf_release(&buf);
321 static const char *action_name(const struct replay_opts *opts)
323 switch (opts->action) {
327 return N_("cherry-pick");
328 case REPLAY_INTERACTIVE_REBASE:
331 die(_("unknown action: %d"), opts->action);
334 struct commit_message {
341 static const char *short_commit_name(struct commit *commit)
343 return find_unique_abbrev(&commit->object.oid, DEFAULT_ABBREV);
346 static int get_message(struct commit *commit, struct commit_message *out)
348 const char *abbrev, *subject;
351 out->message = logmsg_reencode(commit, NULL, get_commit_output_encoding());
352 abbrev = short_commit_name(commit);
354 subject_len = find_commit_subject(out->message, &subject);
356 out->subject = xmemdupz(subject, subject_len);
357 out->label = xstrfmt("%s... %s", abbrev, out->subject);
358 out->parent_label = xstrfmt("parent of %s", out->label);
363 static void free_message(struct commit *commit, struct commit_message *msg)
365 free(msg->parent_label);
368 unuse_commit_buffer(commit, msg->message);
371 static void print_advice(struct repository *r, int show_hint,
372 struct replay_opts *opts)
374 char *msg = getenv("GIT_CHERRY_PICK_HELP");
377 fprintf(stderr, "%s\n", msg);
379 * A conflict has occurred but the porcelain
380 * (typically rebase --interactive) wants to take care
381 * of the commit itself so remove CHERRY_PICK_HEAD
383 unlink(git_path_cherry_pick_head(r));
389 advise(_("after resolving the conflicts, mark the corrected paths\n"
390 "with 'git add <paths>' or 'git rm <paths>'"));
392 advise(_("after resolving the conflicts, mark the corrected paths\n"
393 "with 'git add <paths>' or 'git rm <paths>'\n"
394 "and commit the result with 'git commit'"));
398 static int write_message(const void *buf, size_t len, const char *filename,
401 struct lock_file msg_file = LOCK_INIT;
403 int msg_fd = hold_lock_file_for_update(&msg_file, filename, 0);
405 return error_errno(_("could not lock '%s'"), filename);
406 if (write_in_full(msg_fd, buf, len) < 0) {
407 error_errno(_("could not write to '%s'"), filename);
408 rollback_lock_file(&msg_file);
411 if (append_eol && write(msg_fd, "\n", 1) < 0) {
412 error_errno(_("could not write eol to '%s'"), filename);
413 rollback_lock_file(&msg_file);
416 if (commit_lock_file(&msg_file) < 0)
417 return error(_("failed to finalize '%s'"), filename);
423 * Reads a file that was presumably written by a shell script, i.e. with an
424 * end-of-line marker that needs to be stripped.
426 * Note that only the last end-of-line marker is stripped, consistent with the
427 * behavior of "$(cat path)" in a shell script.
429 * Returns 1 if the file was read, 0 if it could not be read or does not exist.
431 static int read_oneliner(struct strbuf *buf,
432 const char *path, int skip_if_empty)
434 int orig_len = buf->len;
436 if (!file_exists(path))
439 if (strbuf_read_file(buf, path, 0) < 0) {
440 warning_errno(_("could not read '%s'"), path);
444 if (buf->len > orig_len && buf->buf[buf->len - 1] == '\n') {
445 if (--buf->len > orig_len && buf->buf[buf->len - 1] == '\r')
447 buf->buf[buf->len] = '\0';
450 if (skip_if_empty && buf->len == orig_len)
456 static struct tree *empty_tree(struct repository *r)
458 return lookup_tree(r, the_hash_algo->empty_tree);
461 static int error_dirty_index(struct repository *repo, struct replay_opts *opts)
463 if (repo_read_index_unmerged(repo))
464 return error_resolve_conflict(_(action_name(opts)));
466 error(_("your local changes would be overwritten by %s."),
467 _(action_name(opts)));
469 if (advice_commit_before_merge)
470 advise(_("commit your changes or stash them to proceed."));
474 static void update_abort_safety_file(void)
476 struct object_id head;
478 /* Do nothing on a single-pick */
479 if (!file_exists(git_path_seq_dir()))
482 if (!get_oid("HEAD", &head))
483 write_file(git_path_abort_safety_file(), "%s", oid_to_hex(&head));
485 write_file(git_path_abort_safety_file(), "%s", "");
488 static int fast_forward_to(struct repository *r,
489 const struct object_id *to,
490 const struct object_id *from,
492 struct replay_opts *opts)
494 struct ref_transaction *transaction;
495 struct strbuf sb = STRBUF_INIT;
496 struct strbuf err = STRBUF_INIT;
499 if (checkout_fast_forward(r, from, to, 1))
500 return -1; /* the callee should have complained already */
502 strbuf_addf(&sb, _("%s: fast-forward"), _(action_name(opts)));
504 transaction = ref_transaction_begin(&err);
506 ref_transaction_update(transaction, "HEAD",
507 to, unborn && !is_rebase_i(opts) ?
510 ref_transaction_commit(transaction, &err)) {
511 ref_transaction_free(transaction);
512 error("%s", err.buf);
514 strbuf_release(&err);
519 strbuf_release(&err);
520 ref_transaction_free(transaction);
521 update_abort_safety_file();
525 enum commit_msg_cleanup_mode get_cleanup_mode(const char *cleanup_arg,
528 if (!cleanup_arg || !strcmp(cleanup_arg, "default"))
529 return use_editor ? COMMIT_MSG_CLEANUP_ALL :
530 COMMIT_MSG_CLEANUP_SPACE;
531 else if (!strcmp(cleanup_arg, "verbatim"))
532 return COMMIT_MSG_CLEANUP_NONE;
533 else if (!strcmp(cleanup_arg, "whitespace"))
534 return COMMIT_MSG_CLEANUP_SPACE;
535 else if (!strcmp(cleanup_arg, "strip"))
536 return COMMIT_MSG_CLEANUP_ALL;
537 else if (!strcmp(cleanup_arg, "scissors"))
538 return use_editor ? COMMIT_MSG_CLEANUP_SCISSORS :
539 COMMIT_MSG_CLEANUP_SPACE;
541 die(_("Invalid cleanup mode %s"), cleanup_arg);
545 * NB using int rather than enum cleanup_mode to stop clang's
546 * -Wtautological-constant-out-of-range-compare complaining that the comparison
549 static const char *describe_cleanup_mode(int cleanup_mode)
551 static const char *modes[] = { "whitespace",
556 if (cleanup_mode < ARRAY_SIZE(modes))
557 return modes[cleanup_mode];
559 BUG("invalid cleanup_mode provided (%d)", cleanup_mode);
562 void append_conflicts_hint(struct index_state *istate,
563 struct strbuf *msgbuf, enum commit_msg_cleanup_mode cleanup_mode)
567 if (cleanup_mode == COMMIT_MSG_CLEANUP_SCISSORS) {
568 strbuf_addch(msgbuf, '\n');
569 wt_status_append_cut_line(msgbuf);
570 strbuf_addch(msgbuf, comment_line_char);
573 strbuf_addch(msgbuf, '\n');
574 strbuf_commented_addf(msgbuf, "Conflicts:\n");
575 for (i = 0; i < istate->cache_nr;) {
576 const struct cache_entry *ce = istate->cache[i++];
578 strbuf_commented_addf(msgbuf, "\t%s\n", ce->name);
579 while (i < istate->cache_nr &&
580 !strcmp(ce->name, istate->cache[i]->name))
586 static int do_recursive_merge(struct repository *r,
587 struct commit *base, struct commit *next,
588 const char *base_label, const char *next_label,
589 struct object_id *head, struct strbuf *msgbuf,
590 struct replay_opts *opts)
592 struct merge_options o;
593 struct tree *next_tree, *base_tree, *head_tree;
596 struct lock_file index_lock = LOCK_INIT;
598 if (repo_hold_locked_index(r, &index_lock, LOCK_REPORT_ON_ERROR) < 0)
603 init_merge_options(&o, r);
604 o.ancestor = base ? base_label : "(empty tree)";
606 o.branch2 = next ? next_label : "(empty tree)";
607 if (is_rebase_i(opts))
609 o.show_rename_progress = 1;
611 head_tree = parse_tree_indirect(head);
612 next_tree = next ? get_commit_tree(next) : empty_tree(r);
613 base_tree = base ? get_commit_tree(base) : empty_tree(r);
615 for (i = 0; i < opts->xopts_nr; i++)
616 parse_merge_opt(&o, opts->xopts[i]);
618 clean = merge_trees(&o,
620 next_tree, base_tree);
621 if (is_rebase_i(opts) && clean <= 0)
622 fputs(o.obuf.buf, stdout);
623 strbuf_release(&o.obuf);
625 rollback_lock_file(&index_lock);
629 if (write_locked_index(r->index, &index_lock,
630 COMMIT_LOCK | SKIP_IF_UNCHANGED))
632 * TRANSLATORS: %s will be "revert", "cherry-pick" or
635 return error(_("%s: Unable to write new index file"),
636 _(action_name(opts)));
639 append_conflicts_hint(r->index, msgbuf,
640 opts->default_msg_cleanup);
645 static struct object_id *get_cache_tree_oid(struct index_state *istate)
647 if (!istate->cache_tree)
648 istate->cache_tree = cache_tree();
650 if (!cache_tree_fully_valid(istate->cache_tree))
651 if (cache_tree_update(istate, 0)) {
652 error(_("unable to update cache tree"));
656 return &istate->cache_tree->oid;
659 static int is_index_unchanged(struct repository *r)
661 struct object_id head_oid, *cache_tree_oid;
662 struct commit *head_commit;
663 struct index_state *istate = r->index;
665 if (!resolve_ref_unsafe("HEAD", RESOLVE_REF_READING, &head_oid, NULL))
666 return error(_("could not resolve HEAD commit"));
668 head_commit = lookup_commit(r, &head_oid);
671 * If head_commit is NULL, check_commit, called from
672 * lookup_commit, would have indicated that head_commit is not
673 * a commit object already. parse_commit() will return failure
674 * without further complaints in such a case. Otherwise, if
675 * the commit is invalid, parse_commit() will complain. So
676 * there is nothing for us to say here. Just return failure.
678 if (parse_commit(head_commit))
681 if (!(cache_tree_oid = get_cache_tree_oid(istate)))
684 return oideq(cache_tree_oid, get_commit_tree_oid(head_commit));
687 static int write_author_script(const char *message)
689 struct strbuf buf = STRBUF_INIT;
694 if (!*message || starts_with(message, "\n")) {
696 /* Missing 'author' line? */
697 unlink(rebase_path_author_script());
699 } else if (skip_prefix(message, "author ", &message))
701 else if ((eol = strchr(message, '\n')))
706 strbuf_addstr(&buf, "GIT_AUTHOR_NAME='");
707 while (*message && *message != '\n' && *message != '\r')
708 if (skip_prefix(message, " <", &message))
710 else if (*message != '\'')
711 strbuf_addch(&buf, *(message++));
713 strbuf_addf(&buf, "'\\%c'", *(message++));
714 strbuf_addstr(&buf, "'\nGIT_AUTHOR_EMAIL='");
715 while (*message && *message != '\n' && *message != '\r')
716 if (skip_prefix(message, "> ", &message))
718 else if (*message != '\'')
719 strbuf_addch(&buf, *(message++));
721 strbuf_addf(&buf, "'\\%c'", *(message++));
722 strbuf_addstr(&buf, "'\nGIT_AUTHOR_DATE='@");
723 while (*message && *message != '\n' && *message != '\r')
724 if (*message != '\'')
725 strbuf_addch(&buf, *(message++));
727 strbuf_addf(&buf, "'\\%c'", *(message++));
728 strbuf_addch(&buf, '\'');
729 res = write_message(buf.buf, buf.len, rebase_path_author_script(), 1);
730 strbuf_release(&buf);
735 * Take a series of KEY='VALUE' lines where VALUE part is
736 * sq-quoted, and append <KEY, VALUE> at the end of the string list
738 static int parse_key_value_squoted(char *buf, struct string_list *list)
741 struct string_list_item *item;
743 char *cp = strchr(buf, '=');
745 np = strchrnul(buf, '\n');
746 return error(_("no key present in '%.*s'"),
747 (int) (np - buf), buf);
749 np = strchrnul(cp, '\n');
751 item = string_list_append(list, buf);
753 buf = np + (*np == '\n');
757 return error(_("unable to dequote value of '%s'"),
759 item->util = xstrdup(cp);
765 * Reads and parses the state directory's "author-script" file, and sets name,
766 * email and date accordingly.
767 * Returns 0 on success, -1 if the file could not be parsed.
769 * The author script is of the format:
771 * GIT_AUTHOR_NAME='$author_name'
772 * GIT_AUTHOR_EMAIL='$author_email'
773 * GIT_AUTHOR_DATE='$author_date'
775 * where $author_name, $author_email and $author_date are quoted. We are strict
776 * with our parsing, as the file was meant to be eval'd in the now-removed
777 * git-am.sh/git-rebase--interactive.sh scripts, and thus if the file differs
778 * from what this function expects, it is better to bail out than to do
779 * something that the user does not expect.
781 int read_author_script(const char *path, char **name, char **email, char **date,
784 struct strbuf buf = STRBUF_INIT;
785 struct string_list kv = STRING_LIST_INIT_DUP;
786 int retval = -1; /* assume failure */
787 int i, name_i = -2, email_i = -2, date_i = -2, err = 0;
789 if (strbuf_read_file(&buf, path, 256) <= 0) {
790 strbuf_release(&buf);
791 if (errno == ENOENT && allow_missing)
794 return error_errno(_("could not open '%s' for reading"),
798 if (parse_key_value_squoted(buf.buf, &kv))
801 for (i = 0; i < kv.nr; i++) {
802 if (!strcmp(kv.items[i].string, "GIT_AUTHOR_NAME")) {
804 name_i = error(_("'GIT_AUTHOR_NAME' already given"));
807 } else if (!strcmp(kv.items[i].string, "GIT_AUTHOR_EMAIL")) {
809 email_i = error(_("'GIT_AUTHOR_EMAIL' already given"));
812 } else if (!strcmp(kv.items[i].string, "GIT_AUTHOR_DATE")) {
814 date_i = error(_("'GIT_AUTHOR_DATE' already given"));
818 err = error(_("unknown variable '%s'"),
823 error(_("missing 'GIT_AUTHOR_NAME'"));
825 error(_("missing 'GIT_AUTHOR_EMAIL'"));
827 error(_("missing 'GIT_AUTHOR_DATE'"));
828 if (date_i < 0 || email_i < 0 || date_i < 0 || err)
830 *name = kv.items[name_i].util;
831 *email = kv.items[email_i].util;
832 *date = kv.items[date_i].util;
835 string_list_clear(&kv, !!retval);
836 strbuf_release(&buf);
841 * Read a GIT_AUTHOR_NAME, GIT_AUTHOR_EMAIL AND GIT_AUTHOR_DATE from a
842 * file with shell quoting into struct argv_array. Returns -1 on
843 * error, 0 otherwise.
845 static int read_env_script(struct argv_array *env)
847 char *name, *email, *date;
849 if (read_author_script(rebase_path_author_script(),
850 &name, &email, &date, 0))
853 argv_array_pushf(env, "GIT_AUTHOR_NAME=%s", name);
854 argv_array_pushf(env, "GIT_AUTHOR_EMAIL=%s", email);
855 argv_array_pushf(env, "GIT_AUTHOR_DATE=%s", date);
863 static char *get_author(const char *message)
868 a = find_commit_header(message, "author", &len);
870 return xmemdupz(a, len);
875 static const char staged_changes_advice[] =
876 N_("you have staged changes in your working tree\n"
877 "If these changes are meant to be squashed into the previous commit, run:\n"
879 " git commit --amend %s\n"
881 "If they are meant to go into a new commit, run:\n"
885 "In both cases, once you're done, continue with:\n"
887 " git rebase --continue\n");
889 #define ALLOW_EMPTY (1<<0)
890 #define EDIT_MSG (1<<1)
891 #define AMEND_MSG (1<<2)
892 #define CLEANUP_MSG (1<<3)
893 #define VERIFY_MSG (1<<4)
894 #define CREATE_ROOT_COMMIT (1<<5)
896 static int run_command_silent_on_success(struct child_process *cmd)
898 struct strbuf buf = STRBUF_INIT;
901 cmd->stdout_to_stderr = 1;
902 rc = pipe_command(cmd,
908 fputs(buf.buf, stderr);
909 strbuf_release(&buf);
914 * If we are cherry-pick, and if the merge did not result in
915 * hand-editing, we will hit this commit and inherit the original
916 * author date and name.
918 * If we are revert, or if our cherry-pick results in a hand merge,
919 * we had better say that the current user is responsible for that.
921 * An exception is when run_git_commit() is called during an
922 * interactive rebase: in that case, we will want to retain the
925 static int run_git_commit(struct repository *r,
927 struct replay_opts *opts,
930 struct child_process cmd = CHILD_PROCESS_INIT;
934 if (is_rebase_i(opts) && read_env_script(&cmd.env_array)) {
935 const char *gpg_opt = gpg_sign_opt_quoted(opts);
937 return error(_(staged_changes_advice),
941 argv_array_push(&cmd.args, "commit");
943 if (!(flags & VERIFY_MSG))
944 argv_array_push(&cmd.args, "-n");
945 if ((flags & AMEND_MSG))
946 argv_array_push(&cmd.args, "--amend");
948 argv_array_pushf(&cmd.args, "-S%s", opts->gpg_sign);
950 argv_array_pushl(&cmd.args, "-F", defmsg, NULL);
951 else if (!(flags & EDIT_MSG))
952 argv_array_pushl(&cmd.args, "-C", "HEAD", NULL);
953 if ((flags & CLEANUP_MSG))
954 argv_array_push(&cmd.args, "--cleanup=strip");
955 if ((flags & EDIT_MSG))
956 argv_array_push(&cmd.args, "-e");
957 else if (!(flags & CLEANUP_MSG) &&
958 !opts->signoff && !opts->record_origin &&
959 !opts->explicit_cleanup)
960 argv_array_push(&cmd.args, "--cleanup=verbatim");
962 if ((flags & ALLOW_EMPTY))
963 argv_array_push(&cmd.args, "--allow-empty");
965 if (!(flags & EDIT_MSG))
966 argv_array_push(&cmd.args, "--allow-empty-message");
968 if (is_rebase_i(opts) && !(flags & EDIT_MSG))
969 return run_command_silent_on_success(&cmd);
971 return run_command(&cmd);
974 static int rest_is_empty(const struct strbuf *sb, int start)
979 /* Check if the rest is just whitespace and Signed-off-by's. */
980 for (i = start; i < sb->len; i++) {
981 nl = memchr(sb->buf + i, '\n', sb->len - i);
987 if (strlen(sign_off_header) <= eol - i &&
988 starts_with(sb->buf + i, sign_off_header)) {
993 if (!isspace(sb->buf[i++]))
1000 void cleanup_message(struct strbuf *msgbuf,
1001 enum commit_msg_cleanup_mode cleanup_mode, int verbose)
1003 if (verbose || /* Truncate the message just before the diff, if any. */
1004 cleanup_mode == COMMIT_MSG_CLEANUP_SCISSORS)
1005 strbuf_setlen(msgbuf, wt_status_locate_end(msgbuf->buf, msgbuf->len));
1006 if (cleanup_mode != COMMIT_MSG_CLEANUP_NONE)
1007 strbuf_stripspace(msgbuf, cleanup_mode == COMMIT_MSG_CLEANUP_ALL);
1011 * Find out if the message in the strbuf contains only whitespace and
1012 * Signed-off-by lines.
1014 int message_is_empty(const struct strbuf *sb,
1015 enum commit_msg_cleanup_mode cleanup_mode)
1017 if (cleanup_mode == COMMIT_MSG_CLEANUP_NONE && sb->len)
1019 return rest_is_empty(sb, 0);
1023 * See if the user edited the message in the editor or left what
1024 * was in the template intact
1026 int template_untouched(const struct strbuf *sb, const char *template_file,
1027 enum commit_msg_cleanup_mode cleanup_mode)
1029 struct strbuf tmpl = STRBUF_INIT;
1032 if (cleanup_mode == COMMIT_MSG_CLEANUP_NONE && sb->len)
1035 if (!template_file || strbuf_read_file(&tmpl, template_file, 0) <= 0)
1038 strbuf_stripspace(&tmpl, cleanup_mode == COMMIT_MSG_CLEANUP_ALL);
1039 if (!skip_prefix(sb->buf, tmpl.buf, &start))
1041 strbuf_release(&tmpl);
1042 return rest_is_empty(sb, start - sb->buf);
1045 int update_head_with_reflog(const struct commit *old_head,
1046 const struct object_id *new_head,
1047 const char *action, const struct strbuf *msg,
1050 struct ref_transaction *transaction;
1051 struct strbuf sb = STRBUF_INIT;
1056 strbuf_addstr(&sb, action);
1057 strbuf_addstr(&sb, ": ");
1060 nl = strchr(msg->buf, '\n');
1062 strbuf_add(&sb, msg->buf, nl + 1 - msg->buf);
1064 strbuf_addbuf(&sb, msg);
1065 strbuf_addch(&sb, '\n');
1068 transaction = ref_transaction_begin(err);
1070 ref_transaction_update(transaction, "HEAD", new_head,
1071 old_head ? &old_head->object.oid : &null_oid,
1073 ref_transaction_commit(transaction, err)) {
1076 ref_transaction_free(transaction);
1077 strbuf_release(&sb);
1082 static int run_rewrite_hook(const struct object_id *oldoid,
1083 const struct object_id *newoid)
1085 struct child_process proc = CHILD_PROCESS_INIT;
1086 const char *argv[3];
1088 struct strbuf sb = STRBUF_INIT;
1090 argv[0] = find_hook("post-rewrite");
1099 proc.stdout_to_stderr = 1;
1100 proc.trace2_hook_name = "post-rewrite";
1102 code = start_command(&proc);
1105 strbuf_addf(&sb, "%s %s\n", oid_to_hex(oldoid), oid_to_hex(newoid));
1106 sigchain_push(SIGPIPE, SIG_IGN);
1107 write_in_full(proc.in, sb.buf, sb.len);
1109 strbuf_release(&sb);
1110 sigchain_pop(SIGPIPE);
1111 return finish_command(&proc);
1114 void commit_post_rewrite(struct repository *r,
1115 const struct commit *old_head,
1116 const struct object_id *new_head)
1118 struct notes_rewrite_cfg *cfg;
1120 cfg = init_copy_notes_for_rewrite("amend");
1122 /* we are amending, so old_head is not NULL */
1123 copy_note_for_rewrite(cfg, &old_head->object.oid, new_head);
1124 finish_copy_notes_for_rewrite(r, cfg, "Notes added by 'git commit --amend'");
1126 run_rewrite_hook(&old_head->object.oid, new_head);
1129 static int run_prepare_commit_msg_hook(struct repository *r,
1134 const char *name, *arg1 = NULL, *arg2 = NULL;
1136 name = git_path_commit_editmsg();
1137 if (write_message(msg->buf, msg->len, name, 0))
1146 if (run_commit_hook(0, r->index_file, "prepare-commit-msg", name,
1148 ret = error(_("'prepare-commit-msg' hook failed"));
1153 static const char implicit_ident_advice_noconfig[] =
1154 N_("Your name and email address were configured automatically based\n"
1155 "on your username and hostname. Please check that they are accurate.\n"
1156 "You can suppress this message by setting them explicitly. Run the\n"
1157 "following command and follow the instructions in your editor to edit\n"
1158 "your configuration file:\n"
1160 " git config --global --edit\n"
1162 "After doing this, you may fix the identity used for this commit with:\n"
1164 " git commit --amend --reset-author\n");
1166 static const char implicit_ident_advice_config[] =
1167 N_("Your name and email address were configured automatically based\n"
1168 "on your username and hostname. Please check that they are accurate.\n"
1169 "You can suppress this message by setting them explicitly:\n"
1171 " git config --global user.name \"Your Name\"\n"
1172 " git config --global user.email you@example.com\n"
1174 "After doing this, you may fix the identity used for this commit with:\n"
1176 " git commit --amend --reset-author\n");
1178 static const char *implicit_ident_advice(void)
1180 char *user_config = expand_user_path("~/.gitconfig", 0);
1181 char *xdg_config = xdg_config_home("config");
1182 int config_exists = file_exists(user_config) || file_exists(xdg_config);
1188 return _(implicit_ident_advice_config);
1190 return _(implicit_ident_advice_noconfig);
1194 void print_commit_summary(struct repository *r,
1196 const struct object_id *oid,
1199 struct rev_info rev;
1200 struct commit *commit;
1201 struct strbuf format = STRBUF_INIT;
1203 struct pretty_print_context pctx = {0};
1204 struct strbuf author_ident = STRBUF_INIT;
1205 struct strbuf committer_ident = STRBUF_INIT;
1207 commit = lookup_commit(r, oid);
1209 die(_("couldn't look up newly created commit"));
1210 if (parse_commit(commit))
1211 die(_("could not parse newly created commit"));
1213 strbuf_addstr(&format, "format:%h] %s");
1215 format_commit_message(commit, "%an <%ae>", &author_ident, &pctx);
1216 format_commit_message(commit, "%cn <%ce>", &committer_ident, &pctx);
1217 if (strbuf_cmp(&author_ident, &committer_ident)) {
1218 strbuf_addstr(&format, "\n Author: ");
1219 strbuf_addbuf_percentquote(&format, &author_ident);
1221 if (flags & SUMMARY_SHOW_AUTHOR_DATE) {
1222 struct strbuf date = STRBUF_INIT;
1224 format_commit_message(commit, "%ad", &date, &pctx);
1225 strbuf_addstr(&format, "\n Date: ");
1226 strbuf_addbuf_percentquote(&format, &date);
1227 strbuf_release(&date);
1229 if (!committer_ident_sufficiently_given()) {
1230 strbuf_addstr(&format, "\n Committer: ");
1231 strbuf_addbuf_percentquote(&format, &committer_ident);
1232 if (advice_implicit_identity) {
1233 strbuf_addch(&format, '\n');
1234 strbuf_addstr(&format, implicit_ident_advice());
1237 strbuf_release(&author_ident);
1238 strbuf_release(&committer_ident);
1240 repo_init_revisions(r, &rev, prefix);
1241 setup_revisions(0, NULL, &rev, NULL);
1244 rev.diffopt.output_format =
1245 DIFF_FORMAT_SHORTSTAT | DIFF_FORMAT_SUMMARY;
1247 rev.verbose_header = 1;
1248 rev.show_root_diff = 1;
1249 get_commit_format(format.buf, &rev);
1250 rev.always_show_header = 0;
1251 rev.diffopt.detect_rename = DIFF_DETECT_RENAME;
1252 rev.diffopt.break_opt = 0;
1253 diff_setup_done(&rev.diffopt);
1255 head = resolve_ref_unsafe("HEAD", 0, NULL, NULL);
1257 die_errno(_("unable to resolve HEAD after creating commit"));
1258 if (!strcmp(head, "HEAD"))
1259 head = _("detached HEAD");
1261 skip_prefix(head, "refs/heads/", &head);
1262 printf("[%s%s ", head, (flags & SUMMARY_INITIAL_COMMIT) ?
1263 _(" (root-commit)") : "");
1265 if (!log_tree_commit(&rev, commit)) {
1266 rev.always_show_header = 1;
1267 rev.use_terminator = 1;
1268 log_tree_commit(&rev, commit);
1271 strbuf_release(&format);
1274 static int parse_head(struct repository *r, struct commit **head)
1276 struct commit *current_head;
1277 struct object_id oid;
1279 if (get_oid("HEAD", &oid)) {
1280 current_head = NULL;
1282 current_head = lookup_commit_reference(r, &oid);
1284 return error(_("could not parse HEAD"));
1285 if (!oideq(&oid, ¤t_head->object.oid)) {
1286 warning(_("HEAD %s is not a commit!"),
1289 if (parse_commit(current_head))
1290 return error(_("could not parse HEAD commit"));
1292 *head = current_head;
1298 * Try to commit without forking 'git commit'. In some cases we need
1299 * to run 'git commit' to display an error message
1302 * -1 - error unable to commit
1304 * 1 - run 'git commit'
1306 static int try_to_commit(struct repository *r,
1307 struct strbuf *msg, const char *author,
1308 struct replay_opts *opts, unsigned int flags,
1309 struct object_id *oid)
1311 struct object_id tree;
1312 struct commit *current_head = NULL;
1313 struct commit_list *parents = NULL;
1314 struct commit_extra_header *extra = NULL;
1315 struct strbuf err = STRBUF_INIT;
1316 struct strbuf commit_msg = STRBUF_INIT;
1317 char *amend_author = NULL;
1318 const char *hook_commit = NULL;
1319 enum commit_msg_cleanup_mode cleanup;
1322 if (parse_head(r, ¤t_head))
1325 if (flags & AMEND_MSG) {
1326 const char *exclude_gpgsig[] = { "gpgsig", NULL };
1327 const char *out_enc = get_commit_output_encoding();
1328 const char *message = logmsg_reencode(current_head, NULL,
1332 const char *orig_message = NULL;
1334 find_commit_subject(message, &orig_message);
1336 strbuf_addstr(msg, orig_message);
1337 hook_commit = "HEAD";
1339 author = amend_author = get_author(message);
1340 unuse_commit_buffer(current_head, message);
1342 res = error(_("unable to parse commit author"));
1345 parents = copy_commit_list(current_head->parents);
1346 extra = read_commit_extra_headers(current_head, exclude_gpgsig);
1347 } else if (current_head &&
1348 (!(flags & CREATE_ROOT_COMMIT) || (flags & AMEND_MSG))) {
1349 commit_list_insert(current_head, &parents);
1352 if (write_index_as_tree(&tree, r->index, r->index_file, 0, NULL)) {
1353 res = error(_("git write-tree failed to write a tree"));
1357 if (!(flags & ALLOW_EMPTY)) {
1358 struct commit *first_parent = current_head;
1360 if (flags & AMEND_MSG) {
1361 if (current_head->parents) {
1362 first_parent = current_head->parents->item;
1363 if (repo_parse_commit(r, first_parent)) {
1364 res = error(_("could not parse HEAD commit"));
1368 first_parent = NULL;
1371 if (oideq(first_parent
1372 ? get_commit_tree_oid(first_parent)
1373 : the_hash_algo->empty_tree,
1375 res = 1; /* run 'git commit' to display error message */
1380 if (find_hook("prepare-commit-msg")) {
1381 res = run_prepare_commit_msg_hook(r, msg, hook_commit);
1384 if (strbuf_read_file(&commit_msg, git_path_commit_editmsg(),
1386 res = error_errno(_("unable to read commit message "
1388 git_path_commit_editmsg());
1394 if (flags & CLEANUP_MSG)
1395 cleanup = COMMIT_MSG_CLEANUP_ALL;
1396 else if ((opts->signoff || opts->record_origin) &&
1397 !opts->explicit_cleanup)
1398 cleanup = COMMIT_MSG_CLEANUP_SPACE;
1400 cleanup = opts->default_msg_cleanup;
1402 if (cleanup != COMMIT_MSG_CLEANUP_NONE)
1403 strbuf_stripspace(msg, cleanup == COMMIT_MSG_CLEANUP_ALL);
1404 if ((flags & EDIT_MSG) && message_is_empty(msg, cleanup)) {
1405 res = 1; /* run 'git commit' to display error message */
1411 if (commit_tree_extended(msg->buf, msg->len, &tree, parents,
1412 oid, author, opts->gpg_sign, extra)) {
1413 res = error(_("failed to write commit object"));
1417 if (update_head_with_reflog(current_head, oid,
1418 getenv("GIT_REFLOG_ACTION"), msg, &err)) {
1419 res = error("%s", err.buf);
1423 run_commit_hook(0, r->index_file, "post-commit", NULL);
1424 if (flags & AMEND_MSG)
1425 commit_post_rewrite(r, current_head, oid);
1428 free_commit_extra_headers(extra);
1429 strbuf_release(&err);
1430 strbuf_release(&commit_msg);
1436 static int do_commit(struct repository *r,
1437 const char *msg_file, const char *author,
1438 struct replay_opts *opts, unsigned int flags)
1442 if (!(flags & EDIT_MSG) && !(flags & VERIFY_MSG)) {
1443 struct object_id oid;
1444 struct strbuf sb = STRBUF_INIT;
1446 if (msg_file && strbuf_read_file(&sb, msg_file, 2048) < 0)
1447 return error_errno(_("unable to read commit message "
1451 res = try_to_commit(r, msg_file ? &sb : NULL,
1452 author, opts, flags, &oid);
1453 strbuf_release(&sb);
1455 unlink(git_path_cherry_pick_head(r));
1456 unlink(git_path_merge_msg(r));
1457 if (!is_rebase_i(opts))
1458 print_commit_summary(r, NULL, &oid,
1459 SUMMARY_SHOW_AUTHOR_DATE);
1464 return run_git_commit(r, msg_file, opts, flags);
1469 static int is_original_commit_empty(struct commit *commit)
1471 const struct object_id *ptree_oid;
1473 if (parse_commit(commit))
1474 return error(_("could not parse commit %s"),
1475 oid_to_hex(&commit->object.oid));
1476 if (commit->parents) {
1477 struct commit *parent = commit->parents->item;
1478 if (parse_commit(parent))
1479 return error(_("could not parse parent commit %s"),
1480 oid_to_hex(&parent->object.oid));
1481 ptree_oid = get_commit_tree_oid(parent);
1483 ptree_oid = the_hash_algo->empty_tree; /* commit is root */
1486 return oideq(ptree_oid, get_commit_tree_oid(commit));
1490 * Should empty commits be allowed? Return status:
1491 * <0: Error in is_index_unchanged(r) or is_original_commit_empty(commit)
1492 * 0: Halt on empty commit
1493 * 1: Allow empty commit
1494 * 2: Drop empty commit
1496 static int allow_empty(struct repository *r,
1497 struct replay_opts *opts,
1498 struct commit *commit)
1500 int index_unchanged, originally_empty;
1505 * (1) we do not allow empty at all and error out.
1507 * (2) we allow ones that were initially empty, and
1508 * just drop the ones that become empty
1510 * (3) we allow ones that were initially empty, but
1511 * halt for the ones that become empty;
1513 * (4) we allow both.
1515 if (!opts->allow_empty)
1516 return 0; /* let "git commit" barf as necessary */
1518 index_unchanged = is_index_unchanged(r);
1519 if (index_unchanged < 0)
1520 return index_unchanged;
1521 if (!index_unchanged)
1522 return 0; /* we do not have to say --allow-empty */
1524 if (opts->keep_redundant_commits)
1527 originally_empty = is_original_commit_empty(commit);
1528 if (originally_empty < 0)
1529 return originally_empty;
1530 if (originally_empty)
1532 else if (opts->drop_redundant_commits)
1541 } todo_command_info[] = {
1558 static const char *command_to_string(const enum todo_command command)
1560 if (command < TODO_COMMENT)
1561 return todo_command_info[command].str;
1562 die(_("unknown command: %d"), command);
1565 static char command_to_char(const enum todo_command command)
1567 if (command < TODO_COMMENT && todo_command_info[command].c)
1568 return todo_command_info[command].c;
1569 return comment_line_char;
1572 static int is_noop(const enum todo_command command)
1574 return TODO_NOOP <= command;
1577 static int is_fixup(enum todo_command command)
1579 return command == TODO_FIXUP || command == TODO_SQUASH;
1582 /* Does this command create a (non-merge) commit? */
1583 static int is_pick_or_similar(enum todo_command command)
1598 static int update_squash_messages(struct repository *r,
1599 enum todo_command command,
1600 struct commit *commit,
1601 struct replay_opts *opts)
1603 struct strbuf buf = STRBUF_INIT;
1605 const char *message, *body;
1606 const char *encoding = get_commit_output_encoding();
1608 if (opts->current_fixup_count > 0) {
1609 struct strbuf header = STRBUF_INIT;
1612 if (strbuf_read_file(&buf, rebase_path_squash_msg(), 9) <= 0)
1613 return error(_("could not read '%s'"),
1614 rebase_path_squash_msg());
1616 eol = buf.buf[0] != comment_line_char ?
1617 buf.buf : strchrnul(buf.buf, '\n');
1619 strbuf_addf(&header, "%c ", comment_line_char);
1620 strbuf_addf(&header, _("This is a combination of %d commits."),
1621 opts->current_fixup_count + 2);
1622 strbuf_splice(&buf, 0, eol - buf.buf, header.buf, header.len);
1623 strbuf_release(&header);
1625 struct object_id head;
1626 struct commit *head_commit;
1627 const char *head_message, *body;
1629 if (get_oid("HEAD", &head))
1630 return error(_("need a HEAD to fixup"));
1631 if (!(head_commit = lookup_commit_reference(r, &head)))
1632 return error(_("could not read HEAD"));
1633 if (!(head_message = logmsg_reencode(head_commit, NULL, encoding)))
1634 return error(_("could not read HEAD's commit message"));
1636 find_commit_subject(head_message, &body);
1637 if (write_message(body, strlen(body),
1638 rebase_path_fixup_msg(), 0)) {
1639 unuse_commit_buffer(head_commit, head_message);
1640 return error(_("cannot write '%s'"),
1641 rebase_path_fixup_msg());
1644 strbuf_addf(&buf, "%c ", comment_line_char);
1645 strbuf_addf(&buf, _("This is a combination of %d commits."), 2);
1646 strbuf_addf(&buf, "\n%c ", comment_line_char);
1647 strbuf_addstr(&buf, _("This is the 1st commit message:"));
1648 strbuf_addstr(&buf, "\n\n");
1649 strbuf_addstr(&buf, body);
1651 unuse_commit_buffer(head_commit, head_message);
1654 if (!(message = logmsg_reencode(commit, NULL, encoding)))
1655 return error(_("could not read commit message of %s"),
1656 oid_to_hex(&commit->object.oid));
1657 find_commit_subject(message, &body);
1659 if (command == TODO_SQUASH) {
1660 unlink(rebase_path_fixup_msg());
1661 strbuf_addf(&buf, "\n%c ", comment_line_char);
1662 strbuf_addf(&buf, _("This is the commit message #%d:"),
1663 ++opts->current_fixup_count + 1);
1664 strbuf_addstr(&buf, "\n\n");
1665 strbuf_addstr(&buf, body);
1666 } else if (command == TODO_FIXUP) {
1667 strbuf_addf(&buf, "\n%c ", comment_line_char);
1668 strbuf_addf(&buf, _("The commit message #%d will be skipped:"),
1669 ++opts->current_fixup_count + 1);
1670 strbuf_addstr(&buf, "\n\n");
1671 strbuf_add_commented_lines(&buf, body, strlen(body));
1673 return error(_("unknown command: %d"), command);
1674 unuse_commit_buffer(commit, message);
1676 res = write_message(buf.buf, buf.len, rebase_path_squash_msg(), 0);
1677 strbuf_release(&buf);
1680 strbuf_addf(&opts->current_fixups, "%s%s %s",
1681 opts->current_fixups.len ? "\n" : "",
1682 command_to_string(command),
1683 oid_to_hex(&commit->object.oid));
1684 res = write_message(opts->current_fixups.buf,
1685 opts->current_fixups.len,
1686 rebase_path_current_fixups(), 0);
1692 static void flush_rewritten_pending(void)
1694 struct strbuf buf = STRBUF_INIT;
1695 struct object_id newoid;
1698 if (strbuf_read_file(&buf, rebase_path_rewritten_pending(), (GIT_MAX_HEXSZ + 1) * 2) > 0 &&
1699 !get_oid("HEAD", &newoid) &&
1700 (out = fopen_or_warn(rebase_path_rewritten_list(), "a"))) {
1701 char *bol = buf.buf, *eol;
1704 eol = strchrnul(bol, '\n');
1705 fprintf(out, "%.*s %s\n", (int)(eol - bol),
1706 bol, oid_to_hex(&newoid));
1712 unlink(rebase_path_rewritten_pending());
1714 strbuf_release(&buf);
1717 static void record_in_rewritten(struct object_id *oid,
1718 enum todo_command next_command)
1720 FILE *out = fopen_or_warn(rebase_path_rewritten_pending(), "a");
1725 fprintf(out, "%s\n", oid_to_hex(oid));
1728 if (!is_fixup(next_command))
1729 flush_rewritten_pending();
1732 static int do_pick_commit(struct repository *r,
1733 enum todo_command command,
1734 struct commit *commit,
1735 struct replay_opts *opts,
1736 int final_fixup, int *check_todo)
1738 unsigned int flags = opts->edit ? EDIT_MSG : 0;
1739 const char *msg_file = opts->edit ? NULL : git_path_merge_msg(r);
1740 struct object_id head;
1741 struct commit *base, *next, *parent;
1742 const char *base_label, *next_label;
1743 char *author = NULL;
1744 struct commit_message msg = { NULL, NULL, NULL, NULL };
1745 struct strbuf msgbuf = STRBUF_INIT;
1746 int res, unborn = 0, reword = 0, allow, drop_commit;
1748 if (opts->no_commit) {
1750 * We do not intend to commit immediately. We just want to
1751 * merge the differences in, so let's compute the tree
1752 * that represents the "current" state for merge-recursive
1755 if (write_index_as_tree(&head, r->index, r->index_file, 0, NULL))
1756 return error(_("your index file is unmerged."));
1758 unborn = get_oid("HEAD", &head);
1759 /* Do we want to generate a root commit? */
1760 if (is_pick_or_similar(command) && opts->have_squash_onto &&
1761 oideq(&head, &opts->squash_onto)) {
1762 if (is_fixup(command))
1763 return error(_("cannot fixup root commit"));
1764 flags |= CREATE_ROOT_COMMIT;
1767 oidcpy(&head, the_hash_algo->empty_tree);
1768 if (index_differs_from(r, unborn ? empty_tree_oid_hex() : "HEAD",
1770 return error_dirty_index(r, opts);
1772 discard_index(r->index);
1774 if (!commit->parents)
1776 else if (commit->parents->next) {
1777 /* Reverting or cherry-picking a merge commit */
1779 struct commit_list *p;
1781 if (!opts->mainline)
1782 return error(_("commit %s is a merge but no -m option was given."),
1783 oid_to_hex(&commit->object.oid));
1785 for (cnt = 1, p = commit->parents;
1786 cnt != opts->mainline && p;
1789 if (cnt != opts->mainline || !p)
1790 return error(_("commit %s does not have parent %d"),
1791 oid_to_hex(&commit->object.oid), opts->mainline);
1793 } else if (1 < opts->mainline)
1795 * Non-first parent explicitly specified as mainline for
1798 return error(_("commit %s does not have parent %d"),
1799 oid_to_hex(&commit->object.oid), opts->mainline);
1801 parent = commit->parents->item;
1803 if (get_message(commit, &msg) != 0)
1804 return error(_("cannot get commit message for %s"),
1805 oid_to_hex(&commit->object.oid));
1807 if (opts->allow_ff && !is_fixup(command) &&
1808 ((parent && oideq(&parent->object.oid, &head)) ||
1809 (!parent && unborn))) {
1810 if (is_rebase_i(opts))
1811 write_author_script(msg.message);
1812 res = fast_forward_to(r, &commit->object.oid, &head, unborn,
1814 if (res || command != TODO_REWORD)
1818 goto fast_forward_edit;
1820 if (parent && parse_commit(parent) < 0)
1821 /* TRANSLATORS: The first %s will be a "todo" command like
1822 "revert" or "pick", the second %s a SHA1. */
1823 return error(_("%s: cannot parse parent commit %s"),
1824 command_to_string(command),
1825 oid_to_hex(&parent->object.oid));
1828 * "commit" is an existing commit. We would want to apply
1829 * the difference it introduces since its first parent "prev"
1830 * on top of the current HEAD if we are cherry-pick. Or the
1831 * reverse of it if we are revert.
1834 if (command == TODO_REVERT) {
1836 base_label = msg.label;
1838 next_label = msg.parent_label;
1839 strbuf_addstr(&msgbuf, "Revert \"");
1840 strbuf_addstr(&msgbuf, msg.subject);
1841 strbuf_addstr(&msgbuf, "\"\n\nThis reverts commit ");
1842 strbuf_addstr(&msgbuf, oid_to_hex(&commit->object.oid));
1844 if (commit->parents && commit->parents->next) {
1845 strbuf_addstr(&msgbuf, ", reversing\nchanges made to ");
1846 strbuf_addstr(&msgbuf, oid_to_hex(&parent->object.oid));
1848 strbuf_addstr(&msgbuf, ".\n");
1853 base_label = msg.parent_label;
1855 next_label = msg.label;
1857 /* Append the commit log message to msgbuf. */
1858 if (find_commit_subject(msg.message, &p))
1859 strbuf_addstr(&msgbuf, p);
1861 if (opts->record_origin) {
1862 strbuf_complete_line(&msgbuf);
1863 if (!has_conforming_footer(&msgbuf, NULL, 0))
1864 strbuf_addch(&msgbuf, '\n');
1865 strbuf_addstr(&msgbuf, cherry_picked_prefix);
1866 strbuf_addstr(&msgbuf, oid_to_hex(&commit->object.oid));
1867 strbuf_addstr(&msgbuf, ")\n");
1869 if (!is_fixup(command))
1870 author = get_author(msg.message);
1873 if (command == TODO_REWORD)
1875 else if (is_fixup(command)) {
1876 if (update_squash_messages(r, command, commit, opts))
1880 msg_file = rebase_path_squash_msg();
1881 else if (file_exists(rebase_path_fixup_msg())) {
1882 flags |= CLEANUP_MSG;
1883 msg_file = rebase_path_fixup_msg();
1885 const char *dest = git_path_squash_msg(r);
1887 if (copy_file(dest, rebase_path_squash_msg(), 0666))
1888 return error(_("could not rename '%s' to '%s'"),
1889 rebase_path_squash_msg(), dest);
1890 unlink(git_path_merge_msg(r));
1896 if (opts->signoff && !is_fixup(command))
1897 append_signoff(&msgbuf, 0, 0);
1899 if (is_rebase_i(opts) && write_author_script(msg.message) < 0)
1901 else if (!opts->strategy || !strcmp(opts->strategy, "recursive") || command == TODO_REVERT) {
1902 res = do_recursive_merge(r, base, next, base_label, next_label,
1903 &head, &msgbuf, opts);
1907 res |= write_message(msgbuf.buf, msgbuf.len,
1908 git_path_merge_msg(r), 0);
1910 struct commit_list *common = NULL;
1911 struct commit_list *remotes = NULL;
1913 res = write_message(msgbuf.buf, msgbuf.len,
1914 git_path_merge_msg(r), 0);
1916 commit_list_insert(base, &common);
1917 commit_list_insert(next, &remotes);
1918 res |= try_merge_command(r, opts->strategy,
1919 opts->xopts_nr, (const char **)opts->xopts,
1920 common, oid_to_hex(&head), remotes);
1921 free_commit_list(common);
1922 free_commit_list(remotes);
1924 strbuf_release(&msgbuf);
1927 * If the merge was clean or if it failed due to conflict, we write
1928 * CHERRY_PICK_HEAD for the subsequent invocation of commit to use.
1929 * However, if the merge did not even start, then we don't want to
1932 if (command == TODO_PICK && !opts->no_commit && (res == 0 || res == 1) &&
1933 update_ref(NULL, "CHERRY_PICK_HEAD", &commit->object.oid, NULL,
1934 REF_NO_DEREF, UPDATE_REFS_MSG_ON_ERR))
1936 if (command == TODO_REVERT && ((opts->no_commit && res == 0) || res == 1) &&
1937 update_ref(NULL, "REVERT_HEAD", &commit->object.oid, NULL,
1938 REF_NO_DEREF, UPDATE_REFS_MSG_ON_ERR))
1942 error(command == TODO_REVERT
1943 ? _("could not revert %s... %s")
1944 : _("could not apply %s... %s"),
1945 short_commit_name(commit), msg.subject);
1946 print_advice(r, res == 1, opts);
1947 repo_rerere(r, opts->allow_rerere_auto);
1952 allow = allow_empty(r, opts, commit);
1956 } else if (allow == 1) {
1957 flags |= ALLOW_EMPTY;
1958 } else if (allow == 2) {
1960 unlink(git_path_cherry_pick_head(r));
1961 unlink(git_path_merge_msg(r));
1963 _("dropping %s %s -- patch contents already upstream\n"),
1964 oid_to_hex(&commit->object.oid), msg.subject);
1965 } /* else allow == 0 and there's nothing special to do */
1966 if (!opts->no_commit && !drop_commit) {
1967 if (author || command == TODO_REVERT || (flags & AMEND_MSG))
1968 res = do_commit(r, msg_file, author, opts, flags);
1970 res = error(_("unable to parse commit author"));
1971 *check_todo = !!(flags & EDIT_MSG);
1972 if (!res && reword) {
1974 res = run_git_commit(r, NULL, opts, EDIT_MSG |
1975 VERIFY_MSG | AMEND_MSG |
1976 (flags & ALLOW_EMPTY));
1982 if (!res && final_fixup) {
1983 unlink(rebase_path_fixup_msg());
1984 unlink(rebase_path_squash_msg());
1985 unlink(rebase_path_current_fixups());
1986 strbuf_reset(&opts->current_fixups);
1987 opts->current_fixup_count = 0;
1991 free_message(commit, &msg);
1993 update_abort_safety_file();
1998 static int prepare_revs(struct replay_opts *opts)
2001 * picking (but not reverting) ranges (but not individual revisions)
2002 * should be done in reverse
2004 if (opts->action == REPLAY_PICK && !opts->revs->no_walk)
2005 opts->revs->reverse ^= 1;
2007 if (prepare_revision_walk(opts->revs))
2008 return error(_("revision walk setup failed"));
2013 static int read_and_refresh_cache(struct repository *r,
2014 struct replay_opts *opts)
2016 struct lock_file index_lock = LOCK_INIT;
2017 int index_fd = repo_hold_locked_index(r, &index_lock, 0);
2018 if (repo_read_index(r) < 0) {
2019 rollback_lock_file(&index_lock);
2020 return error(_("git %s: failed to read the index"),
2021 _(action_name(opts)));
2023 refresh_index(r->index, REFRESH_QUIET|REFRESH_UNMERGED, NULL, NULL, NULL);
2024 if (index_fd >= 0) {
2025 if (write_locked_index(r->index, &index_lock,
2026 COMMIT_LOCK | SKIP_IF_UNCHANGED)) {
2027 return error(_("git %s: failed to refresh the index"),
2028 _(action_name(opts)));
2034 enum todo_item_flags {
2035 TODO_EDIT_MERGE_MSG = 1
2038 void todo_list_release(struct todo_list *todo_list)
2040 strbuf_release(&todo_list->buf);
2041 FREE_AND_NULL(todo_list->items);
2042 todo_list->nr = todo_list->alloc = 0;
2045 static struct todo_item *append_new_todo(struct todo_list *todo_list)
2047 ALLOC_GROW(todo_list->items, todo_list->nr + 1, todo_list->alloc);
2048 todo_list->total_nr++;
2049 return todo_list->items + todo_list->nr++;
2052 const char *todo_item_get_arg(struct todo_list *todo_list,
2053 struct todo_item *item)
2055 return todo_list->buf.buf + item->arg_offset;
2058 static int is_command(enum todo_command command, const char **bol)
2060 const char *str = todo_command_info[command].str;
2061 const char nick = todo_command_info[command].c;
2062 const char *p = *bol + 1;
2064 return skip_prefix(*bol, str, bol) ||
2065 ((nick && **bol == nick) &&
2066 (*p == ' ' || *p == '\t' || *p == '\n' || *p == '\r' || !*p) &&
2070 static int parse_insn_line(struct repository *r, struct todo_item *item,
2071 const char *buf, const char *bol, char *eol)
2073 struct object_id commit_oid;
2074 char *end_of_object_name;
2075 int i, saved, status, padding;
2080 bol += strspn(bol, " \t");
2082 if (bol == eol || *bol == '\r' || *bol == comment_line_char) {
2083 item->command = TODO_COMMENT;
2084 item->commit = NULL;
2085 item->arg_offset = bol - buf;
2086 item->arg_len = eol - bol;
2090 for (i = 0; i < TODO_COMMENT; i++)
2091 if (is_command(i, &bol)) {
2095 if (i >= TODO_COMMENT)
2098 /* Eat up extra spaces/ tabs before object name */
2099 padding = strspn(bol, " \t");
2102 if (item->command == TODO_NOOP || item->command == TODO_BREAK) {
2104 return error(_("%s does not accept arguments: '%s'"),
2105 command_to_string(item->command), bol);
2106 item->commit = NULL;
2107 item->arg_offset = bol - buf;
2108 item->arg_len = eol - bol;
2113 return error(_("missing arguments for %s"),
2114 command_to_string(item->command));
2116 if (item->command == TODO_EXEC || item->command == TODO_LABEL ||
2117 item->command == TODO_RESET) {
2118 item->commit = NULL;
2119 item->arg_offset = bol - buf;
2120 item->arg_len = (int)(eol - bol);
2124 if (item->command == TODO_MERGE) {
2125 if (skip_prefix(bol, "-C", &bol))
2126 bol += strspn(bol, " \t");
2127 else if (skip_prefix(bol, "-c", &bol)) {
2128 bol += strspn(bol, " \t");
2129 item->flags |= TODO_EDIT_MERGE_MSG;
2131 item->flags |= TODO_EDIT_MERGE_MSG;
2132 item->commit = NULL;
2133 item->arg_offset = bol - buf;
2134 item->arg_len = (int)(eol - bol);
2139 end_of_object_name = (char *) bol + strcspn(bol, " \t\n");
2140 saved = *end_of_object_name;
2141 *end_of_object_name = '\0';
2142 status = get_oid(bol, &commit_oid);
2144 error(_("could not parse '%s'"), bol); /* return later */
2145 *end_of_object_name = saved;
2147 bol = end_of_object_name + strspn(end_of_object_name, " \t");
2148 item->arg_offset = bol - buf;
2149 item->arg_len = (int)(eol - bol);
2154 item->commit = lookup_commit_reference(r, &commit_oid);
2155 return item->commit ? 0 : -1;
2158 int sequencer_get_last_command(struct repository *r, enum replay_action *action)
2160 const char *todo_file, *bol;
2161 struct strbuf buf = STRBUF_INIT;
2164 todo_file = git_path_todo_file();
2165 if (strbuf_read_file(&buf, todo_file, 0) < 0) {
2166 if (errno == ENOENT || errno == ENOTDIR)
2169 return error_errno("unable to open '%s'", todo_file);
2171 bol = buf.buf + strspn(buf.buf, " \t\r\n");
2172 if (is_command(TODO_PICK, &bol) && (*bol == ' ' || *bol == '\t'))
2173 *action = REPLAY_PICK;
2174 else if (is_command(TODO_REVERT, &bol) &&
2175 (*bol == ' ' || *bol == '\t'))
2176 *action = REPLAY_REVERT;
2180 strbuf_release(&buf);
2185 int todo_list_parse_insn_buffer(struct repository *r, char *buf,
2186 struct todo_list *todo_list)
2188 struct todo_item *item;
2189 char *p = buf, *next_p;
2190 int i, res = 0, fixup_okay = file_exists(rebase_path_done());
2192 todo_list->current = todo_list->nr = 0;
2194 for (i = 1; *p; i++, p = next_p) {
2195 char *eol = strchrnul(p, '\n');
2197 next_p = *eol ? eol + 1 /* skip LF */ : eol;
2199 if (p != eol && eol[-1] == '\r')
2200 eol--; /* strip Carriage Return */
2202 item = append_new_todo(todo_list);
2203 item->offset_in_buf = p - todo_list->buf.buf;
2204 if (parse_insn_line(r, item, buf, p, eol)) {
2205 res = error(_("invalid line %d: %.*s"),
2206 i, (int)(eol - p), p);
2207 item->command = TODO_COMMENT + 1;
2208 item->arg_offset = p - buf;
2209 item->arg_len = (int)(eol - p);
2210 item->commit = NULL;
2215 else if (is_fixup(item->command))
2216 return error(_("cannot '%s' without a previous commit"),
2217 command_to_string(item->command));
2218 else if (!is_noop(item->command))
2225 static int count_commands(struct todo_list *todo_list)
2229 for (i = 0; i < todo_list->nr; i++)
2230 if (todo_list->items[i].command != TODO_COMMENT)
2236 static int get_item_line_offset(struct todo_list *todo_list, int index)
2238 return index < todo_list->nr ?
2239 todo_list->items[index].offset_in_buf : todo_list->buf.len;
2242 static const char *get_item_line(struct todo_list *todo_list, int index)
2244 return todo_list->buf.buf + get_item_line_offset(todo_list, index);
2247 static int get_item_line_length(struct todo_list *todo_list, int index)
2249 return get_item_line_offset(todo_list, index + 1)
2250 - get_item_line_offset(todo_list, index);
2253 static ssize_t strbuf_read_file_or_whine(struct strbuf *sb, const char *path)
2258 fd = open(path, O_RDONLY);
2260 return error_errno(_("could not open '%s'"), path);
2261 len = strbuf_read(sb, fd, 0);
2264 return error(_("could not read '%s'."), path);
2268 static int have_finished_the_last_pick(void)
2270 struct strbuf buf = STRBUF_INIT;
2272 const char *todo_path = git_path_todo_file();
2275 if (strbuf_read_file(&buf, todo_path, 0) < 0) {
2276 if (errno == ENOENT) {
2279 error_errno("unable to open '%s'", todo_path);
2283 /* If there is only one line then we are done */
2284 eol = strchr(buf.buf, '\n');
2285 if (!eol || !eol[1])
2288 strbuf_release(&buf);
2293 void sequencer_post_commit_cleanup(struct repository *r, int verbose)
2295 struct replay_opts opts = REPLAY_OPTS_INIT;
2296 int need_cleanup = 0;
2298 if (file_exists(git_path_cherry_pick_head(r))) {
2299 if (!unlink(git_path_cherry_pick_head(r)) && verbose)
2300 warning(_("cancelling a cherry picking in progress"));
2301 opts.action = REPLAY_PICK;
2305 if (file_exists(git_path_revert_head(r))) {
2306 if (!unlink(git_path_revert_head(r)) && verbose)
2307 warning(_("cancelling a revert in progress"));
2308 opts.action = REPLAY_REVERT;
2315 if (!have_finished_the_last_pick())
2318 sequencer_remove_state(&opts);
2321 static void todo_list_write_total_nr(struct todo_list *todo_list)
2323 FILE *f = fopen_or_warn(rebase_path_msgtotal(), "w");
2326 fprintf(f, "%d\n", todo_list->total_nr);
2331 static int read_populate_todo(struct repository *r,
2332 struct todo_list *todo_list,
2333 struct replay_opts *opts)
2336 const char *todo_file = get_todo_path(opts);
2339 strbuf_reset(&todo_list->buf);
2340 if (strbuf_read_file_or_whine(&todo_list->buf, todo_file) < 0)
2343 res = stat(todo_file, &st);
2345 return error(_("could not stat '%s'"), todo_file);
2346 fill_stat_data(&todo_list->stat, &st);
2348 res = todo_list_parse_insn_buffer(r, todo_list->buf.buf, todo_list);
2350 if (is_rebase_i(opts))
2351 return error(_("please fix this using "
2352 "'git rebase --edit-todo'."));
2353 return error(_("unusable instruction sheet: '%s'"), todo_file);
2356 if (!todo_list->nr &&
2357 (!is_rebase_i(opts) || !file_exists(rebase_path_done())))
2358 return error(_("no commits parsed."));
2360 if (!is_rebase_i(opts)) {
2361 enum todo_command valid =
2362 opts->action == REPLAY_PICK ? TODO_PICK : TODO_REVERT;
2365 for (i = 0; i < todo_list->nr; i++)
2366 if (valid == todo_list->items[i].command)
2368 else if (valid == TODO_PICK)
2369 return error(_("cannot cherry-pick during a revert."));
2371 return error(_("cannot revert during a cherry-pick."));
2374 if (is_rebase_i(opts)) {
2375 struct todo_list done = TODO_LIST_INIT;
2377 if (strbuf_read_file(&done.buf, rebase_path_done(), 0) > 0 &&
2378 !todo_list_parse_insn_buffer(r, done.buf.buf, &done))
2379 todo_list->done_nr = count_commands(&done);
2381 todo_list->done_nr = 0;
2383 todo_list->total_nr = todo_list->done_nr
2384 + count_commands(todo_list);
2385 todo_list_release(&done);
2387 todo_list_write_total_nr(todo_list);
2393 static int git_config_string_dup(char **dest,
2394 const char *var, const char *value)
2397 return config_error_nonbool(var);
2399 *dest = xstrdup(value);
2403 static int populate_opts_cb(const char *key, const char *value, void *data)
2405 struct replay_opts *opts = data;
2410 else if (!strcmp(key, "options.no-commit"))
2411 opts->no_commit = git_config_bool_or_int(key, value, &error_flag);
2412 else if (!strcmp(key, "options.edit"))
2413 opts->edit = git_config_bool_or_int(key, value, &error_flag);
2414 else if (!strcmp(key, "options.allow-empty"))
2416 git_config_bool_or_int(key, value, &error_flag);
2417 else if (!strcmp(key, "options.allow-empty-message"))
2418 opts->allow_empty_message =
2419 git_config_bool_or_int(key, value, &error_flag);
2420 else if (!strcmp(key, "options.keep-redundant-commits"))
2421 opts->keep_redundant_commits =
2422 git_config_bool_or_int(key, value, &error_flag);
2423 else if (!strcmp(key, "options.signoff"))
2424 opts->signoff = git_config_bool_or_int(key, value, &error_flag);
2425 else if (!strcmp(key, "options.record-origin"))
2426 opts->record_origin = git_config_bool_or_int(key, value, &error_flag);
2427 else if (!strcmp(key, "options.allow-ff"))
2428 opts->allow_ff = git_config_bool_or_int(key, value, &error_flag);
2429 else if (!strcmp(key, "options.mainline"))
2430 opts->mainline = git_config_int(key, value);
2431 else if (!strcmp(key, "options.strategy"))
2432 git_config_string_dup(&opts->strategy, key, value);
2433 else if (!strcmp(key, "options.gpg-sign"))
2434 git_config_string_dup(&opts->gpg_sign, key, value);
2435 else if (!strcmp(key, "options.strategy-option")) {
2436 ALLOC_GROW(opts->xopts, opts->xopts_nr + 1, opts->xopts_alloc);
2437 opts->xopts[opts->xopts_nr++] = xstrdup(value);
2438 } else if (!strcmp(key, "options.allow-rerere-auto"))
2439 opts->allow_rerere_auto =
2440 git_config_bool_or_int(key, value, &error_flag) ?
2441 RERERE_AUTOUPDATE : RERERE_NOAUTOUPDATE;
2442 else if (!strcmp(key, "options.default-msg-cleanup")) {
2443 opts->explicit_cleanup = 1;
2444 opts->default_msg_cleanup = get_cleanup_mode(value, 1);
2446 return error(_("invalid key: %s"), key);
2449 return error(_("invalid value for %s: %s"), key, value);
2454 void parse_strategy_opts(struct replay_opts *opts, char *raw_opts)
2457 char *strategy_opts_string = raw_opts;
2459 if (*strategy_opts_string == ' ')
2460 strategy_opts_string++;
2462 opts->xopts_nr = split_cmdline(strategy_opts_string,
2463 (const char ***)&opts->xopts);
2464 for (i = 0; i < opts->xopts_nr; i++) {
2465 const char *arg = opts->xopts[i];
2467 skip_prefix(arg, "--", &arg);
2468 opts->xopts[i] = xstrdup(arg);
2472 static void read_strategy_opts(struct replay_opts *opts, struct strbuf *buf)
2475 if (!read_oneliner(buf, rebase_path_strategy(), 0))
2477 opts->strategy = strbuf_detach(buf, NULL);
2478 if (!read_oneliner(buf, rebase_path_strategy_opts(), 0))
2481 parse_strategy_opts(opts, buf->buf);
2484 static int read_populate_opts(struct replay_opts *opts)
2486 if (is_rebase_i(opts)) {
2487 struct strbuf buf = STRBUF_INIT;
2489 if (read_oneliner(&buf, rebase_path_gpg_sign_opt(), 1)) {
2490 if (!starts_with(buf.buf, "-S"))
2493 free(opts->gpg_sign);
2494 opts->gpg_sign = xstrdup(buf.buf + 2);
2499 if (read_oneliner(&buf, rebase_path_allow_rerere_autoupdate(), 1)) {
2500 if (!strcmp(buf.buf, "--rerere-autoupdate"))
2501 opts->allow_rerere_auto = RERERE_AUTOUPDATE;
2502 else if (!strcmp(buf.buf, "--no-rerere-autoupdate"))
2503 opts->allow_rerere_auto = RERERE_NOAUTOUPDATE;
2507 if (file_exists(rebase_path_verbose()))
2510 if (file_exists(rebase_path_quiet()))
2513 if (file_exists(rebase_path_signoff())) {
2518 if (file_exists(rebase_path_reschedule_failed_exec()))
2519 opts->reschedule_failed_exec = 1;
2521 if (file_exists(rebase_path_drop_redundant_commits()))
2522 opts->drop_redundant_commits = 1;
2524 if (file_exists(rebase_path_keep_redundant_commits()))
2525 opts->keep_redundant_commits = 1;
2527 read_strategy_opts(opts, &buf);
2528 strbuf_release(&buf);
2530 if (read_oneliner(&opts->current_fixups,
2531 rebase_path_current_fixups(), 1)) {
2532 const char *p = opts->current_fixups.buf;
2533 opts->current_fixup_count = 1;
2534 while ((p = strchr(p, '\n'))) {
2535 opts->current_fixup_count++;
2540 if (read_oneliner(&buf, rebase_path_squash_onto(), 0)) {
2541 if (get_oid_hex(buf.buf, &opts->squash_onto) < 0)
2542 return error(_("unusable squash-onto"));
2543 opts->have_squash_onto = 1;
2549 if (!file_exists(git_path_opts_file()))
2552 * The function git_parse_source(), called from git_config_from_file(),
2553 * may die() in case of a syntactically incorrect file. We do not care
2554 * about this case, though, because we wrote that file ourselves, so we
2555 * are pretty certain that it is syntactically correct.
2557 if (git_config_from_file(populate_opts_cb, git_path_opts_file(), opts) < 0)
2558 return error(_("malformed options sheet: '%s'"),
2559 git_path_opts_file());
2563 static void write_strategy_opts(struct replay_opts *opts)
2566 struct strbuf buf = STRBUF_INIT;
2568 for (i = 0; i < opts->xopts_nr; ++i)
2569 strbuf_addf(&buf, " --%s", opts->xopts[i]);
2571 write_file(rebase_path_strategy_opts(), "%s\n", buf.buf);
2572 strbuf_release(&buf);
2575 int write_basic_state(struct replay_opts *opts, const char *head_name,
2576 struct commit *onto, const char *orig_head)
2579 write_file(rebase_path_head_name(), "%s\n", head_name);
2581 write_file(rebase_path_onto(), "%s\n",
2582 oid_to_hex(&onto->object.oid));
2584 write_file(rebase_path_orig_head(), "%s\n", orig_head);
2587 write_file(rebase_path_quiet(), "%s", "");
2589 write_file(rebase_path_verbose(), "%s", "");
2591 write_file(rebase_path_strategy(), "%s\n", opts->strategy);
2592 if (opts->xopts_nr > 0)
2593 write_strategy_opts(opts);
2595 if (opts->allow_rerere_auto == RERERE_AUTOUPDATE)
2596 write_file(rebase_path_allow_rerere_autoupdate(), "--rerere-autoupdate\n");
2597 else if (opts->allow_rerere_auto == RERERE_NOAUTOUPDATE)
2598 write_file(rebase_path_allow_rerere_autoupdate(), "--no-rerere-autoupdate\n");
2601 write_file(rebase_path_gpg_sign_opt(), "-S%s\n", opts->gpg_sign);
2603 write_file(rebase_path_signoff(), "--signoff\n");
2604 if (opts->drop_redundant_commits)
2605 write_file(rebase_path_drop_redundant_commits(), "%s", "");
2606 if (opts->keep_redundant_commits)
2607 write_file(rebase_path_keep_redundant_commits(), "%s", "");
2608 if (opts->reschedule_failed_exec)
2609 write_file(rebase_path_reschedule_failed_exec(), "%s", "");
2614 static int walk_revs_populate_todo(struct todo_list *todo_list,
2615 struct replay_opts *opts)
2617 enum todo_command command = opts->action == REPLAY_PICK ?
2618 TODO_PICK : TODO_REVERT;
2619 const char *command_string = todo_command_info[command].str;
2620 const char *encoding;
2621 struct commit *commit;
2623 if (prepare_revs(opts))
2626 encoding = get_log_output_encoding();
2628 while ((commit = get_revision(opts->revs))) {
2629 struct todo_item *item = append_new_todo(todo_list);
2630 const char *commit_buffer = logmsg_reencode(commit, NULL, encoding);
2631 const char *subject;
2634 item->command = command;
2635 item->commit = commit;
2636 item->arg_offset = 0;
2638 item->offset_in_buf = todo_list->buf.len;
2639 subject_len = find_commit_subject(commit_buffer, &subject);
2640 strbuf_addf(&todo_list->buf, "%s %s %.*s\n", command_string,
2641 short_commit_name(commit), subject_len, subject);
2642 unuse_commit_buffer(commit, commit_buffer);
2646 return error(_("empty commit set passed"));
2651 static int create_seq_dir(struct repository *r)
2653 enum replay_action action;
2654 const char *in_progress_error = NULL;
2655 const char *in_progress_advice = NULL;
2656 unsigned int advise_skip = file_exists(git_path_revert_head(r)) ||
2657 file_exists(git_path_cherry_pick_head(r));
2659 if (!sequencer_get_last_command(r, &action)) {
2662 in_progress_error = _("revert is already in progress");
2663 in_progress_advice =
2664 _("try \"git revert (--continue | %s--abort | --quit)\"");
2667 in_progress_error = _("cherry-pick is already in progress");
2668 in_progress_advice =
2669 _("try \"git cherry-pick (--continue | %s--abort | --quit)\"");
2672 BUG("unexpected action in create_seq_dir");
2675 if (in_progress_error) {
2676 error("%s", in_progress_error);
2677 if (advice_sequencer_in_use)
2678 advise(in_progress_advice,
2679 advise_skip ? "--skip | " : "");
2682 if (mkdir(git_path_seq_dir(), 0777) < 0)
2683 return error_errno(_("could not create sequencer directory '%s'"),
2684 git_path_seq_dir());
2689 static int save_head(const char *head)
2691 struct lock_file head_lock = LOCK_INIT;
2692 struct strbuf buf = STRBUF_INIT;
2696 fd = hold_lock_file_for_update(&head_lock, git_path_head_file(), 0);
2698 return error_errno(_("could not lock HEAD"));
2699 strbuf_addf(&buf, "%s\n", head);
2700 written = write_in_full(fd, buf.buf, buf.len);
2701 strbuf_release(&buf);
2703 error_errno(_("could not write to '%s'"), git_path_head_file());
2704 rollback_lock_file(&head_lock);
2707 if (commit_lock_file(&head_lock) < 0)
2708 return error(_("failed to finalize '%s'"), git_path_head_file());
2712 static int rollback_is_safe(void)
2714 struct strbuf sb = STRBUF_INIT;
2715 struct object_id expected_head, actual_head;
2717 if (strbuf_read_file(&sb, git_path_abort_safety_file(), 0) >= 0) {
2719 if (get_oid_hex(sb.buf, &expected_head)) {
2720 strbuf_release(&sb);
2721 die(_("could not parse %s"), git_path_abort_safety_file());
2723 strbuf_release(&sb);
2725 else if (errno == ENOENT)
2726 oidclr(&expected_head);
2728 die_errno(_("could not read '%s'"), git_path_abort_safety_file());
2730 if (get_oid("HEAD", &actual_head))
2731 oidclr(&actual_head);
2733 return oideq(&actual_head, &expected_head);
2736 static int reset_merge(const struct object_id *oid)
2739 struct argv_array argv = ARGV_ARRAY_INIT;
2741 argv_array_pushl(&argv, "reset", "--merge", NULL);
2743 if (!is_null_oid(oid))
2744 argv_array_push(&argv, oid_to_hex(oid));
2746 ret = run_command_v_opt(argv.argv, RUN_GIT_CMD);
2747 argv_array_clear(&argv);
2752 static int rollback_single_pick(struct repository *r)
2754 struct object_id head_oid;
2756 if (!file_exists(git_path_cherry_pick_head(r)) &&
2757 !file_exists(git_path_revert_head(r)))
2758 return error(_("no cherry-pick or revert in progress"));
2759 if (read_ref_full("HEAD", 0, &head_oid, NULL))
2760 return error(_("cannot resolve HEAD"));
2761 if (is_null_oid(&head_oid))
2762 return error(_("cannot abort from a branch yet to be born"));
2763 return reset_merge(&head_oid);
2766 static int skip_single_pick(void)
2768 struct object_id head;
2770 if (read_ref_full("HEAD", 0, &head, NULL))
2771 return error(_("cannot resolve HEAD"));
2772 return reset_merge(&head);
2775 int sequencer_rollback(struct repository *r, struct replay_opts *opts)
2778 struct object_id oid;
2779 struct strbuf buf = STRBUF_INIT;
2782 f = fopen(git_path_head_file(), "r");
2783 if (!f && errno == ENOENT) {
2785 * There is no multiple-cherry-pick in progress.
2786 * If CHERRY_PICK_HEAD or REVERT_HEAD indicates
2787 * a single-cherry-pick in progress, abort that.
2789 return rollback_single_pick(r);
2792 return error_errno(_("cannot open '%s'"), git_path_head_file());
2793 if (strbuf_getline_lf(&buf, f)) {
2794 error(_("cannot read '%s': %s"), git_path_head_file(),
2795 ferror(f) ? strerror(errno) : _("unexpected end of file"));
2800 if (parse_oid_hex(buf.buf, &oid, &p) || *p != '\0') {
2801 error(_("stored pre-cherry-pick HEAD file '%s' is corrupt"),
2802 git_path_head_file());
2805 if (is_null_oid(&oid)) {
2806 error(_("cannot abort from a branch yet to be born"));
2810 if (!rollback_is_safe()) {
2811 /* Do not error, just do not rollback */
2812 warning(_("You seem to have moved HEAD. "
2813 "Not rewinding, check your HEAD!"));
2815 if (reset_merge(&oid))
2817 strbuf_release(&buf);
2818 return sequencer_remove_state(opts);
2820 strbuf_release(&buf);
2824 int sequencer_skip(struct repository *r, struct replay_opts *opts)
2826 enum replay_action action = -1;
2827 sequencer_get_last_command(r, &action);
2830 * Check whether the subcommand requested to skip the commit is actually
2831 * in progress and that it's safe to skip the commit.
2833 * opts->action tells us which subcommand requested to skip the commit.
2834 * If the corresponding .git/<ACTION>_HEAD exists, we know that the
2835 * action is in progress and we can skip the commit.
2837 * Otherwise we check that the last instruction was related to the
2838 * particular subcommand we're trying to execute and barf if that's not
2841 * Finally we check that the rollback is "safe", i.e., has the HEAD
2842 * moved? In this case, it doesn't make sense to "reset the merge" and
2843 * "skip the commit" as the user already handled this by committing. But
2844 * we'd not want to barf here, instead give advice on how to proceed. We
2845 * only need to check that when .git/<ACTION>_HEAD doesn't exist because
2846 * it gets removed when the user commits, so if it still exists we're
2847 * sure the user can't have committed before.
2849 switch (opts->action) {
2851 if (!file_exists(git_path_revert_head(r))) {
2852 if (action != REPLAY_REVERT)
2853 return error(_("no revert in progress"));
2854 if (!rollback_is_safe())
2859 if (!file_exists(git_path_cherry_pick_head(r))) {
2860 if (action != REPLAY_PICK)
2861 return error(_("no cherry-pick in progress"));
2862 if (!rollback_is_safe())
2867 BUG("unexpected action in sequencer_skip");
2870 if (skip_single_pick())
2871 return error(_("failed to skip the commit"));
2872 if (!is_directory(git_path_seq_dir()))
2875 return sequencer_continue(r, opts);
2878 error(_("there is nothing to skip"));
2880 if (advice_resolve_conflict) {
2881 advise(_("have you committed already?\n"
2882 "try \"git %s --continue\""),
2883 action == REPLAY_REVERT ? "revert" : "cherry-pick");
2888 static int save_todo(struct todo_list *todo_list, struct replay_opts *opts)
2890 struct lock_file todo_lock = LOCK_INIT;
2891 const char *todo_path = get_todo_path(opts);
2892 int next = todo_list->current, offset, fd;
2895 * rebase -i writes "git-rebase-todo" without the currently executing
2896 * command, appending it to "done" instead.
2898 if (is_rebase_i(opts))
2901 fd = hold_lock_file_for_update(&todo_lock, todo_path, 0);
2903 return error_errno(_("could not lock '%s'"), todo_path);
2904 offset = get_item_line_offset(todo_list, next);
2905 if (write_in_full(fd, todo_list->buf.buf + offset,
2906 todo_list->buf.len - offset) < 0)
2907 return error_errno(_("could not write to '%s'"), todo_path);
2908 if (commit_lock_file(&todo_lock) < 0)
2909 return error(_("failed to finalize '%s'"), todo_path);
2911 if (is_rebase_i(opts) && next > 0) {
2912 const char *done = rebase_path_done();
2913 int fd = open(done, O_CREAT | O_WRONLY | O_APPEND, 0666);
2918 if (write_in_full(fd, get_item_line(todo_list, next - 1),
2919 get_item_line_length(todo_list, next - 1))
2921 ret = error_errno(_("could not write to '%s'"), done);
2923 ret = error_errno(_("failed to finalize '%s'"), done);
2929 static int save_opts(struct replay_opts *opts)
2931 const char *opts_file = git_path_opts_file();
2934 if (opts->no_commit)
2935 res |= git_config_set_in_file_gently(opts_file,
2936 "options.no-commit", "true");
2938 res |= git_config_set_in_file_gently(opts_file,
2939 "options.edit", "true");
2940 if (opts->allow_empty)
2941 res |= git_config_set_in_file_gently(opts_file,
2942 "options.allow-empty", "true");
2943 if (opts->allow_empty_message)
2944 res |= git_config_set_in_file_gently(opts_file,
2945 "options.allow-empty-message", "true");
2946 if (opts->keep_redundant_commits)
2947 res |= git_config_set_in_file_gently(opts_file,
2948 "options.keep-redundant-commits", "true");
2950 res |= git_config_set_in_file_gently(opts_file,
2951 "options.signoff", "true");
2952 if (opts->record_origin)
2953 res |= git_config_set_in_file_gently(opts_file,
2954 "options.record-origin", "true");
2956 res |= git_config_set_in_file_gently(opts_file,
2957 "options.allow-ff", "true");
2958 if (opts->mainline) {
2959 struct strbuf buf = STRBUF_INIT;
2960 strbuf_addf(&buf, "%d", opts->mainline);
2961 res |= git_config_set_in_file_gently(opts_file,
2962 "options.mainline", buf.buf);
2963 strbuf_release(&buf);
2966 res |= git_config_set_in_file_gently(opts_file,
2967 "options.strategy", opts->strategy);
2969 res |= git_config_set_in_file_gently(opts_file,
2970 "options.gpg-sign", opts->gpg_sign);
2973 for (i = 0; i < opts->xopts_nr; i++)
2974 res |= git_config_set_multivar_in_file_gently(opts_file,
2975 "options.strategy-option",
2976 opts->xopts[i], "^$", 0);
2978 if (opts->allow_rerere_auto)
2979 res |= git_config_set_in_file_gently(opts_file,
2980 "options.allow-rerere-auto",
2981 opts->allow_rerere_auto == RERERE_AUTOUPDATE ?
2984 if (opts->explicit_cleanup)
2985 res |= git_config_set_in_file_gently(opts_file,
2986 "options.default-msg-cleanup",
2987 describe_cleanup_mode(opts->default_msg_cleanup));
2991 static int make_patch(struct repository *r,
2992 struct commit *commit,
2993 struct replay_opts *opts)
2995 struct strbuf buf = STRBUF_INIT;
2996 struct rev_info log_tree_opt;
2997 const char *subject, *p;
3000 p = short_commit_name(commit);
3001 if (write_message(p, strlen(p), rebase_path_stopped_sha(), 1) < 0)
3003 if (update_ref("rebase", "REBASE_HEAD", &commit->object.oid,
3004 NULL, REF_NO_DEREF, UPDATE_REFS_MSG_ON_ERR))
3005 res |= error(_("could not update %s"), "REBASE_HEAD");
3007 strbuf_addf(&buf, "%s/patch", get_dir(opts));
3008 memset(&log_tree_opt, 0, sizeof(log_tree_opt));
3009 repo_init_revisions(r, &log_tree_opt, NULL);
3010 log_tree_opt.abbrev = 0;
3011 log_tree_opt.diff = 1;
3012 log_tree_opt.diffopt.output_format = DIFF_FORMAT_PATCH;
3013 log_tree_opt.disable_stdin = 1;
3014 log_tree_opt.no_commit_id = 1;
3015 log_tree_opt.diffopt.file = fopen(buf.buf, "w");
3016 log_tree_opt.diffopt.use_color = GIT_COLOR_NEVER;
3017 if (!log_tree_opt.diffopt.file)
3018 res |= error_errno(_("could not open '%s'"), buf.buf);
3020 res |= log_tree_commit(&log_tree_opt, commit);
3021 fclose(log_tree_opt.diffopt.file);
3025 strbuf_addf(&buf, "%s/message", get_dir(opts));
3026 if (!file_exists(buf.buf)) {
3027 const char *encoding = get_commit_output_encoding();
3028 const char *commit_buffer = logmsg_reencode(commit, NULL, encoding);
3029 find_commit_subject(commit_buffer, &subject);
3030 res |= write_message(subject, strlen(subject), buf.buf, 1);
3031 unuse_commit_buffer(commit, commit_buffer);
3033 strbuf_release(&buf);
3038 static int intend_to_amend(void)
3040 struct object_id head;
3043 if (get_oid("HEAD", &head))
3044 return error(_("cannot read HEAD"));
3046 p = oid_to_hex(&head);
3047 return write_message(p, strlen(p), rebase_path_amend(), 1);
3050 static int error_with_patch(struct repository *r,
3051 struct commit *commit,
3052 const char *subject, int subject_len,
3053 struct replay_opts *opts,
3054 int exit_code, int to_amend)
3057 if (make_patch(r, commit, opts))
3059 } else if (copy_file(rebase_path_message(),
3060 git_path_merge_msg(r), 0666))
3061 return error(_("unable to copy '%s' to '%s'"),
3062 git_path_merge_msg(r), rebase_path_message());
3065 if (intend_to_amend())
3069 _("You can amend the commit now, with\n"
3071 " git commit --amend %s\n"
3073 "Once you are satisfied with your changes, run\n"
3075 " git rebase --continue\n"),
3076 gpg_sign_opt_quoted(opts));
3077 } else if (exit_code) {
3079 fprintf_ln(stderr, _("Could not apply %s... %.*s"),
3080 short_commit_name(commit), subject_len, subject);
3083 * We don't have the hash of the parent so
3084 * just print the line from the todo file.
3086 fprintf_ln(stderr, _("Could not merge %.*s"),
3087 subject_len, subject);
3093 static int error_failed_squash(struct repository *r,
3094 struct commit *commit,
3095 struct replay_opts *opts,
3097 const char *subject)
3099 if (copy_file(rebase_path_message(), rebase_path_squash_msg(), 0666))
3100 return error(_("could not copy '%s' to '%s'"),
3101 rebase_path_squash_msg(), rebase_path_message());
3102 unlink(git_path_merge_msg(r));
3103 if (copy_file(git_path_merge_msg(r), rebase_path_message(), 0666))
3104 return error(_("could not copy '%s' to '%s'"),
3105 rebase_path_message(),
3106 git_path_merge_msg(r));
3107 return error_with_patch(r, commit, subject, subject_len, opts, 1, 0);
3110 static int do_exec(struct repository *r, const char *command_line)
3112 struct argv_array child_env = ARGV_ARRAY_INIT;
3113 const char *child_argv[] = { NULL, NULL };
3116 fprintf(stderr, "Executing: %s\n", command_line);
3117 child_argv[0] = command_line;
3118 argv_array_pushf(&child_env, "GIT_DIR=%s", absolute_path(get_git_dir()));
3119 argv_array_pushf(&child_env, "GIT_WORK_TREE=%s",
3120 absolute_path(get_git_work_tree()));
3121 status = run_command_v_opt_cd_env(child_argv, RUN_USING_SHELL, NULL,
3124 /* force re-reading of the cache */
3125 if (discard_index(r->index) < 0 || repo_read_index(r) < 0)
3126 return error(_("could not read index"));
3128 dirty = require_clean_work_tree(r, "rebase", NULL, 1, 1);
3131 warning(_("execution failed: %s\n%s"
3132 "You can fix the problem, and then run\n"
3134 " git rebase --continue\n"
3137 dirty ? N_("and made changes to the index and/or the "
3138 "working tree\n") : "");
3140 /* command not found */
3143 warning(_("execution succeeded: %s\nbut "
3144 "left changes to the index and/or the working tree\n"
3145 "Commit or stash your changes, and then run\n"
3147 " git rebase --continue\n"
3148 "\n"), command_line);
3152 argv_array_clear(&child_env);
3157 static int safe_append(const char *filename, const char *fmt, ...)
3160 struct lock_file lock = LOCK_INIT;
3161 int fd = hold_lock_file_for_update(&lock, filename,
3162 LOCK_REPORT_ON_ERROR);
3163 struct strbuf buf = STRBUF_INIT;
3168 if (strbuf_read_file(&buf, filename, 0) < 0 && errno != ENOENT) {
3169 error_errno(_("could not read '%s'"), filename);
3170 rollback_lock_file(&lock);
3173 strbuf_complete(&buf, '\n');
3175 strbuf_vaddf(&buf, fmt, ap);
3178 if (write_in_full(fd, buf.buf, buf.len) < 0) {
3179 error_errno(_("could not write to '%s'"), filename);
3180 strbuf_release(&buf);
3181 rollback_lock_file(&lock);
3184 if (commit_lock_file(&lock) < 0) {
3185 strbuf_release(&buf);
3186 rollback_lock_file(&lock);
3187 return error(_("failed to finalize '%s'"), filename);
3190 strbuf_release(&buf);
3194 static int do_label(struct repository *r, const char *name, int len)
3196 struct ref_store *refs = get_main_ref_store(r);
3197 struct ref_transaction *transaction;
3198 struct strbuf ref_name = STRBUF_INIT, err = STRBUF_INIT;
3199 struct strbuf msg = STRBUF_INIT;
3201 struct object_id head_oid;
3203 if (len == 1 && *name == '#')
3204 return error(_("illegal label name: '%.*s'"), len, name);
3206 strbuf_addf(&ref_name, "refs/rewritten/%.*s", len, name);
3207 strbuf_addf(&msg, "rebase (label) '%.*s'", len, name);
3209 transaction = ref_store_transaction_begin(refs, &err);
3211 error("%s", err.buf);
3213 } else if (get_oid("HEAD", &head_oid)) {
3214 error(_("could not read HEAD"));
3216 } else if (ref_transaction_update(transaction, ref_name.buf, &head_oid,
3217 NULL, 0, msg.buf, &err) < 0 ||
3218 ref_transaction_commit(transaction, &err)) {
3219 error("%s", err.buf);
3222 ref_transaction_free(transaction);
3223 strbuf_release(&err);
3224 strbuf_release(&msg);
3227 ret = safe_append(rebase_path_refs_to_delete(),
3228 "%s\n", ref_name.buf);
3229 strbuf_release(&ref_name);
3234 static const char *reflog_message(struct replay_opts *opts,
3235 const char *sub_action, const char *fmt, ...);
3237 static int do_reset(struct repository *r,
3238 const char *name, int len,
3239 struct replay_opts *opts)
3241 struct strbuf ref_name = STRBUF_INIT;
3242 struct object_id oid;
3243 struct lock_file lock = LOCK_INIT;
3244 struct tree_desc desc;
3246 struct unpack_trees_options unpack_tree_opts;
3249 if (repo_hold_locked_index(r, &lock, LOCK_REPORT_ON_ERROR) < 0)
3252 if (len == 10 && !strncmp("[new root]", name, len)) {
3253 if (!opts->have_squash_onto) {
3255 if (commit_tree("", 0, the_hash_algo->empty_tree,
3256 NULL, &opts->squash_onto,
3258 return error(_("writing fake root commit"));
3259 opts->have_squash_onto = 1;
3260 hex = oid_to_hex(&opts->squash_onto);
3261 if (write_message(hex, strlen(hex),
3262 rebase_path_squash_onto(), 0))
3263 return error(_("writing squash-onto"));
3265 oidcpy(&oid, &opts->squash_onto);
3269 /* Determine the length of the label */
3270 for (i = 0; i < len; i++)
3271 if (isspace(name[i]))
3275 strbuf_addf(&ref_name, "refs/rewritten/%.*s", len, name);
3276 if (get_oid(ref_name.buf, &oid) &&
3277 get_oid(ref_name.buf + strlen("refs/rewritten/"), &oid)) {
3278 error(_("could not read '%s'"), ref_name.buf);
3279 rollback_lock_file(&lock);
3280 strbuf_release(&ref_name);
3285 memset(&unpack_tree_opts, 0, sizeof(unpack_tree_opts));
3286 setup_unpack_trees_porcelain(&unpack_tree_opts, "reset");
3287 unpack_tree_opts.head_idx = 1;
3288 unpack_tree_opts.src_index = r->index;
3289 unpack_tree_opts.dst_index = r->index;
3290 unpack_tree_opts.fn = oneway_merge;
3291 unpack_tree_opts.merge = 1;
3292 unpack_tree_opts.update = 1;
3294 if (repo_read_index_unmerged(r)) {
3295 rollback_lock_file(&lock);
3296 strbuf_release(&ref_name);
3297 return error_resolve_conflict(_(action_name(opts)));
3300 if (!fill_tree_descriptor(r, &desc, &oid)) {
3301 error(_("failed to find tree of %s"), oid_to_hex(&oid));
3302 rollback_lock_file(&lock);
3303 free((void *)desc.buffer);
3304 strbuf_release(&ref_name);
3308 if (unpack_trees(1, &desc, &unpack_tree_opts)) {
3309 rollback_lock_file(&lock);
3310 free((void *)desc.buffer);
3311 strbuf_release(&ref_name);
3315 tree = parse_tree_indirect(&oid);
3316 prime_cache_tree(r, r->index, tree);
3318 if (write_locked_index(r->index, &lock, COMMIT_LOCK) < 0)
3319 ret = error(_("could not write index"));
3320 free((void *)desc.buffer);
3323 ret = update_ref(reflog_message(opts, "reset", "'%.*s'",
3324 len, name), "HEAD", &oid,
3325 NULL, 0, UPDATE_REFS_MSG_ON_ERR);
3327 strbuf_release(&ref_name);
3331 static struct commit *lookup_label(const char *label, int len,
3334 struct commit *commit;
3337 strbuf_addf(buf, "refs/rewritten/%.*s", len, label);
3338 commit = lookup_commit_reference_by_name(buf->buf);
3340 /* fall back to non-rewritten ref or commit */
3341 strbuf_splice(buf, 0, strlen("refs/rewritten/"), "", 0);
3342 commit = lookup_commit_reference_by_name(buf->buf);
3346 error(_("could not resolve '%s'"), buf->buf);
3351 static int do_merge(struct repository *r,
3352 struct commit *commit,
3353 const char *arg, int arg_len,
3354 int flags, struct replay_opts *opts)
3356 int run_commit_flags = (flags & TODO_EDIT_MERGE_MSG) ?
3357 EDIT_MSG | VERIFY_MSG : 0;
3358 struct strbuf ref_name = STRBUF_INIT;
3359 struct commit *head_commit, *merge_commit, *i;
3360 struct commit_list *bases, *j, *reversed = NULL;
3361 struct commit_list *to_merge = NULL, **tail = &to_merge;
3362 const char *strategy = !opts->xopts_nr &&
3363 (!opts->strategy || !strcmp(opts->strategy, "recursive")) ?
3364 NULL : opts->strategy;
3365 struct merge_options o;
3366 int merge_arg_len, oneline_offset, can_fast_forward, ret, k;
3367 static struct lock_file lock;
3370 if (repo_hold_locked_index(r, &lock, LOCK_REPORT_ON_ERROR) < 0) {
3375 head_commit = lookup_commit_reference_by_name("HEAD");
3377 ret = error(_("cannot merge without a current revision"));
3382 * For octopus merges, the arg starts with the list of revisions to be
3383 * merged. The list is optionally followed by '#' and the oneline.
3385 merge_arg_len = oneline_offset = arg_len;
3386 for (p = arg; p - arg < arg_len; p += strspn(p, " \t\n")) {
3389 if (*p == '#' && (!p[1] || isspace(p[1]))) {
3390 p += 1 + strspn(p + 1, " \t\n");
3391 oneline_offset = p - arg;
3394 k = strcspn(p, " \t\n");
3397 merge_commit = lookup_label(p, k, &ref_name);
3398 if (!merge_commit) {
3399 ret = error(_("unable to parse '%.*s'"), k, p);
3402 tail = &commit_list_insert(merge_commit, tail)->next;
3404 merge_arg_len = p - arg;
3408 ret = error(_("nothing to merge: '%.*s'"), arg_len, arg);
3412 if (opts->have_squash_onto &&
3413 oideq(&head_commit->object.oid, &opts->squash_onto)) {
3415 * When the user tells us to "merge" something into a
3416 * "[new root]", let's simply fast-forward to the merge head.
3418 rollback_lock_file(&lock);
3420 ret = error(_("octopus merge cannot be executed on "
3421 "top of a [new root]"));
3423 ret = fast_forward_to(r, &to_merge->item->object.oid,
3424 &head_commit->object.oid, 0,
3430 const char *encoding = get_commit_output_encoding();
3431 const char *message = logmsg_reencode(commit, NULL, encoding);
3436 ret = error(_("could not get commit message of '%s'"),
3437 oid_to_hex(&commit->object.oid));
3440 write_author_script(message);
3441 find_commit_subject(message, &body);
3443 ret = write_message(body, len, git_path_merge_msg(r), 0);
3444 unuse_commit_buffer(commit, message);
3446 error_errno(_("could not write '%s'"),
3447 git_path_merge_msg(r));
3451 struct strbuf buf = STRBUF_INIT;
3454 strbuf_addf(&buf, "author %s", git_author_info(0));
3455 write_author_script(buf.buf);
3458 if (oneline_offset < arg_len) {
3459 p = arg + oneline_offset;
3460 len = arg_len - oneline_offset;
3462 strbuf_addf(&buf, "Merge %s '%.*s'",
3463 to_merge->next ? "branches" : "branch",
3464 merge_arg_len, arg);
3469 ret = write_message(p, len, git_path_merge_msg(r), 0);
3470 strbuf_release(&buf);
3472 error_errno(_("could not write '%s'"),
3473 git_path_merge_msg(r));
3479 * If HEAD is not identical to the first parent of the original merge
3480 * commit, we cannot fast-forward.
3482 can_fast_forward = opts->allow_ff && commit && commit->parents &&
3483 oideq(&commit->parents->item->object.oid,
3484 &head_commit->object.oid);
3487 * If any merge head is different from the original one, we cannot
3490 if (can_fast_forward) {
3491 struct commit_list *p = commit->parents->next;
3493 for (j = to_merge; j && p; j = j->next, p = p->next)
3494 if (!oideq(&j->item->object.oid,
3495 &p->item->object.oid)) {
3496 can_fast_forward = 0;
3500 * If the number of merge heads differs from the original merge
3501 * commit, we cannot fast-forward.
3504 can_fast_forward = 0;
3507 if (can_fast_forward) {
3508 rollback_lock_file(&lock);
3509 ret = fast_forward_to(r, &commit->object.oid,
3510 &head_commit->object.oid, 0, opts);
3511 if (flags & TODO_EDIT_MERGE_MSG) {
3512 run_commit_flags |= AMEND_MSG;
3513 goto fast_forward_edit;
3518 if (strategy || to_merge->next) {
3520 struct child_process cmd = CHILD_PROCESS_INIT;
3522 if (read_env_script(&cmd.env_array)) {
3523 const char *gpg_opt = gpg_sign_opt_quoted(opts);
3525 ret = error(_(staged_changes_advice), gpg_opt, gpg_opt);
3530 argv_array_push(&cmd.args, "merge");
3531 argv_array_push(&cmd.args, "-s");
3533 argv_array_push(&cmd.args, "octopus");
3535 argv_array_push(&cmd.args, strategy);
3536 for (k = 0; k < opts->xopts_nr; k++)
3537 argv_array_pushf(&cmd.args,
3538 "-X%s", opts->xopts[k]);
3540 argv_array_push(&cmd.args, "--no-edit");
3541 argv_array_push(&cmd.args, "--no-ff");
3542 argv_array_push(&cmd.args, "--no-log");
3543 argv_array_push(&cmd.args, "--no-stat");
3544 argv_array_push(&cmd.args, "-F");
3545 argv_array_push(&cmd.args, git_path_merge_msg(r));
3547 argv_array_push(&cmd.args, opts->gpg_sign);
3549 /* Add the tips to be merged */
3550 for (j = to_merge; j; j = j->next)
3551 argv_array_push(&cmd.args,
3552 oid_to_hex(&j->item->object.oid));
3554 strbuf_release(&ref_name);
3555 unlink(git_path_cherry_pick_head(r));
3556 rollback_lock_file(&lock);
3558 rollback_lock_file(&lock);
3559 ret = run_command(&cmd);
3561 /* force re-reading of the cache */
3562 if (!ret && (discard_index(r->index) < 0 ||
3563 repo_read_index(r) < 0))
3564 ret = error(_("could not read index"));
3568 merge_commit = to_merge->item;
3569 bases = get_merge_bases(head_commit, merge_commit);
3570 if (bases && oideq(&merge_commit->object.oid,
3571 &bases->item->object.oid)) {
3573 /* skip merging an ancestor of HEAD */
3577 write_message(oid_to_hex(&merge_commit->object.oid), the_hash_algo->hexsz,
3578 git_path_merge_head(r), 0);
3579 write_message("no-ff", 5, git_path_merge_mode(r), 0);
3581 for (j = bases; j; j = j->next)
3582 commit_list_insert(j->item, &reversed);
3583 free_commit_list(bases);
3586 init_merge_options(&o, r);
3588 o.branch2 = ref_name.buf;
3589 o.buffer_output = 2;
3591 ret = merge_recursive(&o, head_commit, merge_commit, reversed, &i);
3593 fputs(o.obuf.buf, stdout);
3594 strbuf_release(&o.obuf);
3596 error(_("could not even attempt to merge '%.*s'"),
3597 merge_arg_len, arg);
3601 * The return value of merge_recursive() is 1 on clean, and 0 on
3604 * Let's reverse that, so that do_merge() returns 0 upon success and
3605 * 1 upon failed merge (keeping the return value -1 for the cases where
3606 * we will want to reschedule the `merge` command).
3610 if (r->index->cache_changed &&
3611 write_locked_index(r->index, &lock, COMMIT_LOCK)) {
3612 ret = error(_("merge: Unable to write new index file"));
3616 rollback_lock_file(&lock);
3618 repo_rerere(r, opts->allow_rerere_auto);
3621 * In case of problems, we now want to return a positive
3622 * value (a negative one would indicate that the `merge`
3623 * command needs to be rescheduled).
3626 ret = !!run_git_commit(r, git_path_merge_msg(r), opts,
3630 strbuf_release(&ref_name);
3631 rollback_lock_file(&lock);
3632 free_commit_list(to_merge);
3636 static int is_final_fixup(struct todo_list *todo_list)
3638 int i = todo_list->current;
3640 if (!is_fixup(todo_list->items[i].command))
3643 while (++i < todo_list->nr)
3644 if (is_fixup(todo_list->items[i].command))
3646 else if (!is_noop(todo_list->items[i].command))
3651 static enum todo_command peek_command(struct todo_list *todo_list, int offset)
3655 for (i = todo_list->current + offset; i < todo_list->nr; i++)
3656 if (!is_noop(todo_list->items[i].command))
3657 return todo_list->items[i].command;
3662 static int apply_autostash(struct replay_opts *opts)
3664 struct strbuf stash_sha1 = STRBUF_INIT;
3665 struct child_process child = CHILD_PROCESS_INIT;
3668 if (!read_oneliner(&stash_sha1, rebase_path_autostash(), 1)) {
3669 strbuf_release(&stash_sha1);
3672 strbuf_trim(&stash_sha1);
3675 child.no_stdout = 1;
3676 child.no_stderr = 1;
3677 argv_array_push(&child.args, "stash");
3678 argv_array_push(&child.args, "apply");
3679 argv_array_push(&child.args, stash_sha1.buf);
3680 if (!run_command(&child))
3681 fprintf(stderr, _("Applied autostash.\n"));
3683 struct child_process store = CHILD_PROCESS_INIT;
3686 argv_array_push(&store.args, "stash");
3687 argv_array_push(&store.args, "store");
3688 argv_array_push(&store.args, "-m");
3689 argv_array_push(&store.args, "autostash");
3690 argv_array_push(&store.args, "-q");
3691 argv_array_push(&store.args, stash_sha1.buf);
3692 if (run_command(&store))
3693 ret = error(_("cannot store %s"), stash_sha1.buf);
3696 _("Applying autostash resulted in conflicts.\n"
3697 "Your changes are safe in the stash.\n"
3698 "You can run \"git stash pop\" or"
3699 " \"git stash drop\" at any time.\n"));
3702 strbuf_release(&stash_sha1);
3706 static const char *reflog_message(struct replay_opts *opts,
3707 const char *sub_action, const char *fmt, ...)
3710 static struct strbuf buf = STRBUF_INIT;
3711 char *reflog_action = getenv(GIT_REFLOG_ACTION);
3715 strbuf_addstr(&buf, reflog_action ? reflog_action : action_name(opts));
3717 strbuf_addf(&buf, " (%s)", sub_action);
3719 strbuf_addstr(&buf, ": ");
3720 strbuf_vaddf(&buf, fmt, ap);
3727 static int run_git_checkout(struct repository *r, struct replay_opts *opts,
3728 const char *commit, const char *action)
3730 struct child_process cmd = CHILD_PROCESS_INIT;
3735 argv_array_push(&cmd.args, "checkout");
3736 argv_array_push(&cmd.args, commit);
3737 argv_array_pushf(&cmd.env_array, GIT_REFLOG_ACTION "=%s", action);
3740 ret = run_command(&cmd);
3742 ret = run_command_silent_on_success(&cmd);
3745 discard_index(r->index);
3750 static int checkout_onto(struct repository *r, struct replay_opts *opts,
3751 const char *onto_name, const struct object_id *onto,
3752 const char *orig_head)
3754 struct object_id oid;
3755 const char *action = reflog_message(opts, "start", "checkout %s", onto_name);
3757 if (get_oid(orig_head, &oid))
3758 return error(_("%s: not a valid OID"), orig_head);
3760 if (run_git_checkout(r, opts, oid_to_hex(onto), action)) {
3761 apply_autostash(opts);
3762 sequencer_remove_state(opts);
3763 return error(_("could not detach HEAD"));
3766 return update_ref(NULL, "ORIG_HEAD", &oid, NULL, 0, UPDATE_REFS_MSG_ON_ERR);
3769 static int stopped_at_head(struct repository *r)
3771 struct object_id head;
3772 struct commit *commit;
3773 struct commit_message message;
3775 if (get_oid("HEAD", &head) ||
3776 !(commit = lookup_commit(r, &head)) ||
3777 parse_commit(commit) || get_message(commit, &message))
3778 fprintf(stderr, _("Stopped at HEAD\n"));
3780 fprintf(stderr, _("Stopped at %s\n"), message.label);
3781 free_message(commit, &message);
3787 static const char rescheduled_advice[] =
3788 N_("Could not execute the todo command\n"
3792 "It has been rescheduled; To edit the command before continuing, please\n"
3793 "edit the todo list first:\n"
3795 " git rebase --edit-todo\n"
3796 " git rebase --continue\n");
3798 static int pick_commits(struct repository *r,
3799 struct todo_list *todo_list,
3800 struct replay_opts *opts)
3802 int res = 0, reschedule = 0;
3803 char *prev_reflog_action;
3805 /* Note that 0 for 3rd parameter of setenv means set only if not set */
3806 setenv(GIT_REFLOG_ACTION, action_name(opts), 0);
3807 prev_reflog_action = xstrdup(getenv(GIT_REFLOG_ACTION));
3809 assert(!(opts->signoff || opts->no_commit ||
3810 opts->record_origin || opts->edit));
3811 if (read_and_refresh_cache(r, opts))
3814 while (todo_list->current < todo_list->nr) {
3815 struct todo_item *item = todo_list->items + todo_list->current;
3816 const char *arg = todo_item_get_arg(todo_list, item);
3819 if (save_todo(todo_list, opts))
3821 if (is_rebase_i(opts)) {
3822 if (item->command != TODO_COMMENT) {
3823 FILE *f = fopen(rebase_path_msgnum(), "w");
3825 todo_list->done_nr++;
3828 fprintf(f, "%d\n", todo_list->done_nr);
3832 fprintf(stderr, "Rebasing (%d/%d)%s",
3834 todo_list->total_nr,
3835 opts->verbose ? "\n" : "\r");
3837 unlink(rebase_path_message());
3838 unlink(rebase_path_author_script());
3839 unlink(rebase_path_stopped_sha());
3840 unlink(rebase_path_amend());
3841 unlink(git_path_merge_head(r));
3842 delete_ref(NULL, "REBASE_HEAD", NULL, REF_NO_DEREF);
3844 if (item->command == TODO_BREAK) {
3847 return stopped_at_head(r);
3850 if (item->command <= TODO_SQUASH) {
3851 if (is_rebase_i(opts))
3852 setenv(GIT_REFLOG_ACTION, reflog_message(opts,
3853 command_to_string(item->command), NULL),
3855 res = do_pick_commit(r, item->command, item->commit,
3856 opts, is_final_fixup(todo_list),
3858 if (is_rebase_i(opts))
3859 setenv(GIT_REFLOG_ACTION, prev_reflog_action, 1);
3860 if (is_rebase_i(opts) && res < 0) {
3862 advise(_(rescheduled_advice),
3863 get_item_line_length(todo_list,
3864 todo_list->current),
3865 get_item_line(todo_list,
3866 todo_list->current));
3867 todo_list->current--;
3868 if (save_todo(todo_list, opts))
3871 if (item->command == TODO_EDIT) {
3872 struct commit *commit = item->commit;
3877 _("Stopped at %s... %.*s\n"),
3878 short_commit_name(commit),
3879 item->arg_len, arg);
3881 return error_with_patch(r, commit,
3882 arg, item->arg_len, opts, res, !res);
3884 if (is_rebase_i(opts) && !res)
3885 record_in_rewritten(&item->commit->object.oid,
3886 peek_command(todo_list, 1));
3887 if (res && is_fixup(item->command)) {
3890 return error_failed_squash(r, item->commit, opts,
3891 item->arg_len, arg);
3892 } else if (res && is_rebase_i(opts) && item->commit) {
3894 struct object_id oid;
3897 * If we are rewording and have either
3898 * fast-forwarded already, or are about to
3899 * create a new root commit, we want to amend,
3900 * otherwise we do not.
3902 if (item->command == TODO_REWORD &&
3903 !get_oid("HEAD", &oid) &&
3904 (oideq(&item->commit->object.oid, &oid) ||
3905 (opts->have_squash_onto &&
3906 oideq(&opts->squash_onto, &oid))))
3909 return res | error_with_patch(r, item->commit,
3910 arg, item->arg_len, opts,
3913 } else if (item->command == TODO_EXEC) {
3914 char *end_of_arg = (char *)(arg + item->arg_len);
3915 int saved = *end_of_arg;
3920 res = do_exec(r, arg);
3921 *end_of_arg = saved;
3924 if (opts->reschedule_failed_exec)
3928 } else if (item->command == TODO_LABEL) {
3929 if ((res = do_label(r, arg, item->arg_len)))
3931 } else if (item->command == TODO_RESET) {
3932 if ((res = do_reset(r, arg, item->arg_len, opts)))
3934 } else if (item->command == TODO_MERGE) {
3935 if ((res = do_merge(r, item->commit,
3937 item->flags, opts)) < 0)
3939 else if (item->commit)
3940 record_in_rewritten(&item->commit->object.oid,
3941 peek_command(todo_list, 1));
3943 /* failed with merge conflicts */
3944 return error_with_patch(r, item->commit,
3947 } else if (!is_noop(item->command))
3948 return error(_("unknown command %d"), item->command);
3951 advise(_(rescheduled_advice),
3952 get_item_line_length(todo_list,
3953 todo_list->current),
3954 get_item_line(todo_list, todo_list->current));
3955 todo_list->current--;
3956 if (save_todo(todo_list, opts))
3959 return error_with_patch(r,
3963 } else if (is_rebase_i(opts) && check_todo && !res) {
3966 if (stat(get_todo_path(opts), &st)) {
3967 res = error_errno(_("could not stat '%s'"),
3968 get_todo_path(opts));
3969 } else if (match_stat_data(&todo_list->stat, &st)) {
3970 /* Reread the todo file if it has changed. */
3971 todo_list_release(todo_list);
3972 if (read_populate_todo(r, todo_list, opts))
3973 res = -1; /* message was printed */
3974 /* `current` will be incremented below */
3975 todo_list->current = -1;
3979 todo_list->current++;
3984 if (is_rebase_i(opts)) {
3985 struct strbuf head_ref = STRBUF_INIT, buf = STRBUF_INIT;
3988 /* Stopped in the middle, as planned? */
3989 if (todo_list->current < todo_list->nr)
3992 if (read_oneliner(&head_ref, rebase_path_head_name(), 0) &&
3993 starts_with(head_ref.buf, "refs/")) {
3995 struct object_id head, orig;
3998 if (get_oid("HEAD", &head)) {
3999 res = error(_("cannot read HEAD"));
4001 strbuf_release(&head_ref);
4002 strbuf_release(&buf);
4005 if (!read_oneliner(&buf, rebase_path_orig_head(), 0) ||
4006 get_oid_hex(buf.buf, &orig)) {
4007 res = error(_("could not read orig-head"));
4008 goto cleanup_head_ref;
4011 if (!read_oneliner(&buf, rebase_path_onto(), 0)) {
4012 res = error(_("could not read 'onto'"));
4013 goto cleanup_head_ref;
4015 msg = reflog_message(opts, "finish", "%s onto %s",
4016 head_ref.buf, buf.buf);
4017 if (update_ref(msg, head_ref.buf, &head, &orig,
4018 REF_NO_DEREF, UPDATE_REFS_MSG_ON_ERR)) {
4019 res = error(_("could not update %s"),
4021 goto cleanup_head_ref;
4023 msg = reflog_message(opts, "finish", "returning to %s",
4025 if (create_symref("HEAD", head_ref.buf, msg)) {
4026 res = error(_("could not update HEAD to %s"),
4028 goto cleanup_head_ref;
4033 if (opts->verbose) {
4034 struct rev_info log_tree_opt;
4035 struct object_id orig, head;
4037 memset(&log_tree_opt, 0, sizeof(log_tree_opt));
4038 repo_init_revisions(r, &log_tree_opt, NULL);
4039 log_tree_opt.diff = 1;
4040 log_tree_opt.diffopt.output_format =
4041 DIFF_FORMAT_DIFFSTAT;
4042 log_tree_opt.disable_stdin = 1;
4044 if (read_oneliner(&buf, rebase_path_orig_head(), 0) &&
4045 !get_oid(buf.buf, &orig) &&
4046 !get_oid("HEAD", &head)) {
4047 diff_tree_oid(&orig, &head, "",
4048 &log_tree_opt.diffopt);
4049 log_tree_diff_flush(&log_tree_opt);
4052 flush_rewritten_pending();
4053 if (!stat(rebase_path_rewritten_list(), &st) &&
4055 struct child_process child = CHILD_PROCESS_INIT;
4056 const char *post_rewrite_hook =
4057 find_hook("post-rewrite");
4059 child.in = open(rebase_path_rewritten_list(), O_RDONLY);
4061 argv_array_push(&child.args, "notes");
4062 argv_array_push(&child.args, "copy");
4063 argv_array_push(&child.args, "--for-rewrite=rebase");
4064 /* we don't care if this copying failed */
4065 run_command(&child);
4067 if (post_rewrite_hook) {
4068 struct child_process hook = CHILD_PROCESS_INIT;
4070 hook.in = open(rebase_path_rewritten_list(),
4072 hook.stdout_to_stderr = 1;
4073 hook.trace2_hook_name = "post-rewrite";
4074 argv_array_push(&hook.args, post_rewrite_hook);
4075 argv_array_push(&hook.args, "rebase");
4076 /* we don't care if this hook failed */
4080 apply_autostash(opts);
4086 "Successfully rebased and updated %s.\n",
4090 strbuf_release(&buf);
4091 strbuf_release(&head_ref);
4095 * Sequence of picks finished successfully; cleanup by
4096 * removing the .git/sequencer directory
4098 return sequencer_remove_state(opts);
4101 static int continue_single_pick(struct repository *r)
4103 const char *argv[] = { "commit", NULL };
4105 if (!file_exists(git_path_cherry_pick_head(r)) &&
4106 !file_exists(git_path_revert_head(r)))
4107 return error(_("no cherry-pick or revert in progress"));
4108 return run_command_v_opt(argv, RUN_GIT_CMD);
4111 static int commit_staged_changes(struct repository *r,
4112 struct replay_opts *opts,
4113 struct todo_list *todo_list)
4115 unsigned int flags = ALLOW_EMPTY | EDIT_MSG;
4116 unsigned int final_fixup = 0, is_clean;
4118 if (has_unstaged_changes(r, 1))
4119 return error(_("cannot rebase: You have unstaged changes."));
4121 is_clean = !has_uncommitted_changes(r, 0);
4123 if (file_exists(rebase_path_amend())) {
4124 struct strbuf rev = STRBUF_INIT;
4125 struct object_id head, to_amend;
4127 if (get_oid("HEAD", &head))
4128 return error(_("cannot amend non-existing commit"));
4129 if (!read_oneliner(&rev, rebase_path_amend(), 0))
4130 return error(_("invalid file: '%s'"), rebase_path_amend());
4131 if (get_oid_hex(rev.buf, &to_amend))
4132 return error(_("invalid contents: '%s'"),
4133 rebase_path_amend());
4134 if (!is_clean && !oideq(&head, &to_amend))
4135 return error(_("\nYou have uncommitted changes in your "
4136 "working tree. Please, commit them\n"
4137 "first and then run 'git rebase "
4138 "--continue' again."));
4140 * When skipping a failed fixup/squash, we need to edit the
4141 * commit message, the current fixup list and count, and if it
4142 * was the last fixup/squash in the chain, we need to clean up
4143 * the commit message and if there was a squash, let the user
4146 if (!is_clean || !opts->current_fixup_count)
4147 ; /* this is not the final fixup */
4148 else if (!oideq(&head, &to_amend) ||
4149 !file_exists(rebase_path_stopped_sha())) {
4150 /* was a final fixup or squash done manually? */
4151 if (!is_fixup(peek_command(todo_list, 0))) {
4152 unlink(rebase_path_fixup_msg());
4153 unlink(rebase_path_squash_msg());
4154 unlink(rebase_path_current_fixups());
4155 strbuf_reset(&opts->current_fixups);
4156 opts->current_fixup_count = 0;
4159 /* we are in a fixup/squash chain */
4160 const char *p = opts->current_fixups.buf;
4161 int len = opts->current_fixups.len;
4163 opts->current_fixup_count--;
4165 BUG("Incorrect current_fixups:\n%s", p);
4166 while (len && p[len - 1] != '\n')
4168 strbuf_setlen(&opts->current_fixups, len);
4169 if (write_message(p, len, rebase_path_current_fixups(),
4171 return error(_("could not write file: '%s'"),
4172 rebase_path_current_fixups());
4175 * If a fixup/squash in a fixup/squash chain failed, the
4176 * commit message is already correct, no need to commit
4179 * Only if it is the final command in the fixup/squash
4180 * chain, and only if the chain is longer than a single
4181 * fixup/squash command (which was just skipped), do we
4182 * actually need to re-commit with a cleaned up commit
4185 if (opts->current_fixup_count > 0 &&
4186 !is_fixup(peek_command(todo_list, 0))) {
4189 * If there was not a single "squash" in the
4190 * chain, we only need to clean up the commit
4191 * message, no need to bother the user with
4192 * opening the commit message in the editor.
4194 if (!starts_with(p, "squash ") &&
4195 !strstr(p, "\nsquash "))
4196 flags = (flags & ~EDIT_MSG) | CLEANUP_MSG;
4197 } else if (is_fixup(peek_command(todo_list, 0))) {
4199 * We need to update the squash message to skip
4200 * the latest commit message.
4202 struct commit *commit;
4203 const char *path = rebase_path_squash_msg();
4204 const char *encoding = get_commit_output_encoding();
4206 if (parse_head(r, &commit) ||
4207 !(p = logmsg_reencode(commit, NULL, encoding)) ||
4208 write_message(p, strlen(p), path, 0)) {
4209 unuse_commit_buffer(commit, p);
4210 return error(_("could not write file: "
4213 unuse_commit_buffer(commit, p);
4217 strbuf_release(&rev);
4222 const char *cherry_pick_head = git_path_cherry_pick_head(r);
4224 if (file_exists(cherry_pick_head) && unlink(cherry_pick_head))
4225 return error(_("could not remove CHERRY_PICK_HEAD"));
4230 if (run_git_commit(r, final_fixup ? NULL : rebase_path_message(),
4232 return error(_("could not commit staged changes."));
4233 unlink(rebase_path_amend());
4234 unlink(git_path_merge_head(r));
4236 unlink(rebase_path_fixup_msg());
4237 unlink(rebase_path_squash_msg());
4239 if (opts->current_fixup_count > 0) {
4241 * Whether final fixup or not, we just cleaned up the commit
4244 unlink(rebase_path_current_fixups());
4245 strbuf_reset(&opts->current_fixups);
4246 opts->current_fixup_count = 0;
4251 int sequencer_continue(struct repository *r, struct replay_opts *opts)
4253 struct todo_list todo_list = TODO_LIST_INIT;
4256 if (read_and_refresh_cache(r, opts))
4259 if (read_populate_opts(opts))
4261 if (is_rebase_i(opts)) {
4262 if ((res = read_populate_todo(r, &todo_list, opts)))
4263 goto release_todo_list;
4265 if (file_exists(rebase_path_dropped())) {
4266 if ((res = todo_list_check_against_backup(r, &todo_list)))
4267 goto release_todo_list;
4269 unlink(rebase_path_dropped());
4272 if (commit_staged_changes(r, opts, &todo_list)) {
4274 goto release_todo_list;
4276 } else if (!file_exists(get_todo_path(opts)))
4277 return continue_single_pick(r);
4278 else if ((res = read_populate_todo(r, &todo_list, opts)))
4279 goto release_todo_list;
4281 if (!is_rebase_i(opts)) {
4282 /* Verify that the conflict has been resolved */
4283 if (file_exists(git_path_cherry_pick_head(r)) ||
4284 file_exists(git_path_revert_head(r))) {
4285 res = continue_single_pick(r);
4287 goto release_todo_list;
4289 if (index_differs_from(r, "HEAD", NULL, 0)) {
4290 res = error_dirty_index(r, opts);
4291 goto release_todo_list;
4293 todo_list.current++;
4294 } else if (file_exists(rebase_path_stopped_sha())) {
4295 struct strbuf buf = STRBUF_INIT;
4296 struct object_id oid;
4298 if (read_oneliner(&buf, rebase_path_stopped_sha(), 1) &&
4299 !get_oid_committish(buf.buf, &oid))
4300 record_in_rewritten(&oid, peek_command(&todo_list, 0));
4301 strbuf_release(&buf);
4304 res = pick_commits(r, &todo_list, opts);
4306 todo_list_release(&todo_list);
4310 static int single_pick(struct repository *r,
4311 struct commit *cmit,
4312 struct replay_opts *opts)
4316 setenv(GIT_REFLOG_ACTION, action_name(opts), 0);
4317 return do_pick_commit(r, opts->action == REPLAY_PICK ?
4318 TODO_PICK : TODO_REVERT, cmit, opts, 0,
4322 int sequencer_pick_revisions(struct repository *r,
4323 struct replay_opts *opts)
4325 struct todo_list todo_list = TODO_LIST_INIT;
4326 struct object_id oid;
4330 if (read_and_refresh_cache(r, opts))
4333 for (i = 0; i < opts->revs->pending.nr; i++) {
4334 struct object_id oid;
4335 const char *name = opts->revs->pending.objects[i].name;
4337 /* This happens when using --stdin. */
4341 if (!get_oid(name, &oid)) {
4342 if (!lookup_commit_reference_gently(r, &oid, 1)) {
4343 enum object_type type = oid_object_info(r,
4346 return error(_("%s: can't cherry-pick a %s"),
4347 name, type_name(type));
4350 return error(_("%s: bad revision"), name);
4354 * If we were called as "git cherry-pick <commit>", just
4355 * cherry-pick/revert it, set CHERRY_PICK_HEAD /
4356 * REVERT_HEAD, and don't touch the sequencer state.
4357 * This means it is possible to cherry-pick in the middle
4358 * of a cherry-pick sequence.
4360 if (opts->revs->cmdline.nr == 1 &&
4361 opts->revs->cmdline.rev->whence == REV_CMD_REV &&
4362 opts->revs->no_walk &&
4363 !opts->revs->cmdline.rev->flags) {
4364 struct commit *cmit;
4365 if (prepare_revision_walk(opts->revs))
4366 return error(_("revision walk setup failed"));
4367 cmit = get_revision(opts->revs);
4369 return error(_("empty commit set passed"));
4370 if (get_revision(opts->revs))
4371 BUG("unexpected extra commit from walk");
4372 return single_pick(r, cmit, opts);
4376 * Start a new cherry-pick/ revert sequence; but
4377 * first, make sure that an existing one isn't in
4381 if (walk_revs_populate_todo(&todo_list, opts) ||
4382 create_seq_dir(r) < 0)
4384 if (get_oid("HEAD", &oid) && (opts->action == REPLAY_REVERT))
4385 return error(_("can't revert as initial commit"));
4386 if (save_head(oid_to_hex(&oid)))
4388 if (save_opts(opts))
4390 update_abort_safety_file();
4391 res = pick_commits(r, &todo_list, opts);
4392 todo_list_release(&todo_list);
4396 void append_signoff(struct strbuf *msgbuf, size_t ignore_footer, unsigned flag)
4398 unsigned no_dup_sob = flag & APPEND_SIGNOFF_DEDUP;
4399 struct strbuf sob = STRBUF_INIT;
4402 strbuf_addstr(&sob, sign_off_header);
4403 strbuf_addstr(&sob, fmt_name(WANT_COMMITTER_IDENT));
4404 strbuf_addch(&sob, '\n');
4407 strbuf_complete_line(msgbuf);
4410 * If the whole message buffer is equal to the sob, pretend that we
4411 * found a conforming footer with a matching sob
4413 if (msgbuf->len - ignore_footer == sob.len &&
4414 !strncmp(msgbuf->buf, sob.buf, sob.len))
4417 has_footer = has_conforming_footer(msgbuf, &sob, ignore_footer);
4420 const char *append_newlines = NULL;
4421 size_t len = msgbuf->len - ignore_footer;
4425 * The buffer is completely empty. Leave foom for
4426 * the title and body to be filled in by the user.
4428 append_newlines = "\n\n";
4429 } else if (len == 1) {
4431 * Buffer contains a single newline. Add another
4432 * so that we leave room for the title and body.
4434 append_newlines = "\n";
4435 } else if (msgbuf->buf[len - 2] != '\n') {
4437 * Buffer ends with a single newline. Add another
4438 * so that there is an empty line between the message
4441 append_newlines = "\n";
4442 } /* else, the buffer already ends with two newlines. */
4444 if (append_newlines)
4445 strbuf_splice(msgbuf, msgbuf->len - ignore_footer, 0,
4446 append_newlines, strlen(append_newlines));
4449 if (has_footer != 3 && (!no_dup_sob || has_footer != 2))
4450 strbuf_splice(msgbuf, msgbuf->len - ignore_footer, 0,
4453 strbuf_release(&sob);
4456 struct labels_entry {
4457 struct hashmap_entry entry;
4458 char label[FLEX_ARRAY];
4461 static int labels_cmp(const void *fndata, const struct hashmap_entry *eptr,
4462 const struct hashmap_entry *entry_or_key, const void *key)
4464 const struct labels_entry *a, *b;
4466 a = container_of(eptr, const struct labels_entry, entry);
4467 b = container_of(entry_or_key, const struct labels_entry, entry);
4469 return key ? strcmp(a->label, key) : strcmp(a->label, b->label);
4472 struct string_entry {
4473 struct oidmap_entry entry;
4474 char string[FLEX_ARRAY];
4477 struct label_state {
4478 struct oidmap commit2label;
4479 struct hashmap labels;
4483 static const char *label_oid(struct object_id *oid, const char *label,
4484 struct label_state *state)
4486 struct labels_entry *labels_entry;
4487 struct string_entry *string_entry;
4488 struct object_id dummy;
4491 string_entry = oidmap_get(&state->commit2label, oid);
4493 return string_entry->string;
4496 * For "uninteresting" commits, i.e. commits that are not to be
4497 * rebased, and which can therefore not be labeled, we use a unique
4498 * abbreviation of the commit name. This is slightly more complicated
4499 * than calling find_unique_abbrev() because we also need to make
4500 * sure that the abbreviation does not conflict with any other
4503 * We disallow "interesting" commits to be labeled by a string that
4504 * is a valid full-length hash, to ensure that we always can find an
4505 * abbreviation for any uninteresting commit's names that does not
4506 * clash with any other label.
4508 strbuf_reset(&state->buf);
4512 strbuf_grow(&state->buf, GIT_MAX_HEXSZ);
4513 label = p = state->buf.buf;
4515 find_unique_abbrev_r(p, oid, default_abbrev);
4518 * We may need to extend the abbreviated hash so that there is
4519 * no conflicting label.
4521 if (hashmap_get_from_hash(&state->labels, strihash(p), p)) {
4522 size_t i = strlen(p) + 1;
4524 oid_to_hex_r(p, oid);
4525 for (; i < the_hash_algo->hexsz; i++) {
4528 if (!hashmap_get_from_hash(&state->labels,
4535 struct strbuf *buf = &state->buf;
4538 * Sanitize labels by replacing non-alpha-numeric characters
4539 * (including white-space ones) by dashes, as they might be
4540 * illegal in file names (and hence in ref names).
4542 * Note that we retain non-ASCII UTF-8 characters (identified
4543 * via the most significant bit). They should be all acceptable
4544 * in file names. We do not validate the UTF-8 here, that's not
4545 * the job of this function.
4547 for (; *label; label++)
4548 if ((*label & 0x80) || isalnum(*label))
4549 strbuf_addch(buf, *label);
4550 /* avoid leading dash and double-dashes */
4551 else if (buf->len && buf->buf[buf->len - 1] != '-')
4552 strbuf_addch(buf, '-');
4554 strbuf_addstr(buf, "rev-");
4555 strbuf_add_unique_abbrev(buf, oid, default_abbrev);
4559 if ((buf->len == the_hash_algo->hexsz &&
4560 !get_oid_hex(label, &dummy)) ||
4561 (buf->len == 1 && *label == '#') ||
4562 hashmap_get_from_hash(&state->labels,
4563 strihash(label), label)) {
4565 * If the label already exists, or if the label is a
4566 * valid full OID, or the label is a '#' (which we use
4567 * as a separator between merge heads and oneline), we
4568 * append a dash and a number to make it unique.
4570 size_t len = buf->len;
4572 for (i = 2; ; i++) {
4573 strbuf_setlen(buf, len);
4574 strbuf_addf(buf, "-%d", i);
4575 if (!hashmap_get_from_hash(&state->labels,
4585 FLEX_ALLOC_STR(labels_entry, label, label);
4586 hashmap_entry_init(&labels_entry->entry, strihash(label));
4587 hashmap_add(&state->labels, &labels_entry->entry);
4589 FLEX_ALLOC_STR(string_entry, string, label);
4590 oidcpy(&string_entry->entry.oid, oid);
4591 oidmap_put(&state->commit2label, string_entry);
4593 return string_entry->string;
4596 static int make_script_with_merges(struct pretty_print_context *pp,
4597 struct rev_info *revs, struct strbuf *out,
4600 int rebase_cousins = flags & TODO_LIST_REBASE_COUSINS;
4601 int root_with_onto = flags & TODO_LIST_ROOT_WITH_ONTO;
4602 struct strbuf buf = STRBUF_INIT, oneline = STRBUF_INIT;
4603 struct strbuf label = STRBUF_INIT;
4604 struct commit_list *commits = NULL, **tail = &commits, *iter;
4605 struct commit_list *tips = NULL, **tips_tail = &tips;
4606 struct commit *commit;
4607 struct oidmap commit2todo = OIDMAP_INIT;
4608 struct string_entry *entry;
4609 struct oidset interesting = OIDSET_INIT, child_seen = OIDSET_INIT,
4610 shown = OIDSET_INIT;
4611 struct label_state state = { OIDMAP_INIT, { NULL }, STRBUF_INIT };
4613 int abbr = flags & TODO_LIST_ABBREVIATE_CMDS;
4614 const char *cmd_pick = abbr ? "p" : "pick",
4615 *cmd_label = abbr ? "l" : "label",
4616 *cmd_reset = abbr ? "t" : "reset",
4617 *cmd_merge = abbr ? "m" : "merge";
4619 oidmap_init(&commit2todo, 0);
4620 oidmap_init(&state.commit2label, 0);
4621 hashmap_init(&state.labels, labels_cmp, NULL, 0);
4622 strbuf_init(&state.buf, 32);
4624 if (revs->cmdline.nr && (revs->cmdline.rev[0].flags & BOTTOM)) {
4625 struct labels_entry *onto_label_entry;
4626 struct object_id *oid = &revs->cmdline.rev[0].item->oid;
4627 FLEX_ALLOC_STR(entry, string, "onto");
4628 oidcpy(&entry->entry.oid, oid);
4629 oidmap_put(&state.commit2label, entry);
4631 FLEX_ALLOC_STR(onto_label_entry, label, "onto");
4632 hashmap_entry_init(&onto_label_entry->entry, strihash("onto"));
4633 hashmap_add(&state.labels, &onto_label_entry->entry);
4638 * - get onelines for all commits
4639 * - gather all branch tips (i.e. 2nd or later parents of merges)
4640 * - label all branch tips
4642 while ((commit = get_revision(revs))) {
4643 struct commit_list *to_merge;
4644 const char *p1, *p2;
4645 struct object_id *oid;
4648 tail = &commit_list_insert(commit, tail)->next;
4649 oidset_insert(&interesting, &commit->object.oid);
4651 is_empty = is_original_commit_empty(commit);
4652 if (!is_empty && (commit->object.flags & PATCHSAME))
4655 strbuf_reset(&oneline);
4656 pretty_print_commit(pp, commit, &oneline);
4658 to_merge = commit->parents ? commit->parents->next : NULL;
4660 /* non-merge commit: easy case */
4662 strbuf_addf(&buf, "%s %s %s", cmd_pick,
4663 oid_to_hex(&commit->object.oid),
4666 FLEX_ALLOC_STR(entry, string, buf.buf);
4667 oidcpy(&entry->entry.oid, &commit->object.oid);
4668 oidmap_put(&commit2todo, entry);
4673 /* Create a label */
4674 strbuf_reset(&label);
4675 if (skip_prefix(oneline.buf, "Merge ", &p1) &&
4676 (p1 = strchr(p1, '\'')) &&
4677 (p2 = strchr(++p1, '\'')))
4678 strbuf_add(&label, p1, p2 - p1);
4679 else if (skip_prefix(oneline.buf, "Merge pull request ",
4681 (p1 = strstr(p1, " from ")))
4682 strbuf_addstr(&label, p1 + strlen(" from "));
4684 strbuf_addbuf(&label, &oneline);
4687 strbuf_addf(&buf, "%s -C %s",
4688 cmd_merge, oid_to_hex(&commit->object.oid));
4690 /* label the tips of merged branches */
4691 for (; to_merge; to_merge = to_merge->next) {
4692 oid = &to_merge->item->object.oid;
4693 strbuf_addch(&buf, ' ');
4695 if (!oidset_contains(&interesting, oid)) {
4696 strbuf_addstr(&buf, label_oid(oid, NULL,
4701 tips_tail = &commit_list_insert(to_merge->item,
4704 strbuf_addstr(&buf, label_oid(oid, label.buf, &state));
4706 strbuf_addf(&buf, " # %s", oneline.buf);
4708 FLEX_ALLOC_STR(entry, string, buf.buf);
4709 oidcpy(&entry->entry.oid, &commit->object.oid);
4710 oidmap_put(&commit2todo, entry);
4715 * - label branch points
4716 * - add HEAD to the branch tips
4718 for (iter = commits; iter; iter = iter->next) {
4719 struct commit_list *parent = iter->item->parents;
4720 for (; parent; parent = parent->next) {
4721 struct object_id *oid = &parent->item->object.oid;
4722 if (!oidset_contains(&interesting, oid))
4724 if (oidset_insert(&child_seen, oid))
4725 label_oid(oid, "branch-point", &state);
4728 /* Add HEAD as implicit "tip of branch" */
4730 tips_tail = &commit_list_insert(iter->item,
4735 * Third phase: output the todo list. This is a bit tricky, as we
4736 * want to avoid jumping back and forth between revisions. To
4737 * accomplish that goal, we walk backwards from the branch tips,
4738 * gathering commits not yet shown, reversing the list on the fly,
4739 * then outputting that list (labeling revisions as needed).
4741 strbuf_addf(out, "%s onto\n", cmd_label);
4742 for (iter = tips; iter; iter = iter->next) {
4743 struct commit_list *list = NULL, *iter2;
4745 commit = iter->item;
4746 if (oidset_contains(&shown, &commit->object.oid))
4748 entry = oidmap_get(&state.commit2label, &commit->object.oid);
4751 strbuf_addf(out, "\n%c Branch %s\n", comment_line_char, entry->string);
4753 strbuf_addch(out, '\n');
4755 while (oidset_contains(&interesting, &commit->object.oid) &&
4756 !oidset_contains(&shown, &commit->object.oid)) {
4757 commit_list_insert(commit, &list);
4758 if (!commit->parents) {
4762 commit = commit->parents->item;
4766 strbuf_addf(out, "%s %s\n", cmd_reset,
4767 rebase_cousins || root_with_onto ?
4768 "onto" : "[new root]");
4770 const char *to = NULL;
4772 entry = oidmap_get(&state.commit2label,
4773 &commit->object.oid);
4776 else if (!rebase_cousins)
4777 to = label_oid(&commit->object.oid, NULL,
4780 if (!to || !strcmp(to, "onto"))
4781 strbuf_addf(out, "%s onto\n", cmd_reset);
4783 strbuf_reset(&oneline);
4784 pretty_print_commit(pp, commit, &oneline);
4785 strbuf_addf(out, "%s %s # %s\n",
4786 cmd_reset, to, oneline.buf);
4790 for (iter2 = list; iter2; iter2 = iter2->next) {
4791 struct object_id *oid = &iter2->item->object.oid;
4792 entry = oidmap_get(&commit2todo, oid);
4793 /* only show if not already upstream */
4795 strbuf_addf(out, "%s\n", entry->string);
4796 entry = oidmap_get(&state.commit2label, oid);
4798 strbuf_addf(out, "%s %s\n",
4799 cmd_label, entry->string);
4800 oidset_insert(&shown, oid);
4803 free_commit_list(list);
4806 free_commit_list(commits);
4807 free_commit_list(tips);
4809 strbuf_release(&label);
4810 strbuf_release(&oneline);
4811 strbuf_release(&buf);
4813 oidmap_free(&commit2todo, 1);
4814 oidmap_free(&state.commit2label, 1);
4815 hashmap_free_entries(&state.labels, struct labels_entry, entry);
4816 strbuf_release(&state.buf);
4821 int sequencer_make_script(struct repository *r, struct strbuf *out, int argc,
4822 const char **argv, unsigned flags)
4824 char *format = NULL;
4825 struct pretty_print_context pp = {0};
4826 struct rev_info revs;
4827 struct commit *commit;
4828 const char *insn = flags & TODO_LIST_ABBREVIATE_CMDS ? "p" : "pick";
4829 int rebase_merges = flags & TODO_LIST_REBASE_MERGES;
4831 repo_init_revisions(r, &revs, NULL);
4832 revs.verbose_header = 1;
4834 revs.max_parents = 1;
4835 revs.cherry_mark = 1;
4838 revs.right_only = 1;
4839 revs.sort_order = REV_SORT_IN_GRAPH_ORDER;
4840 revs.topo_order = 1;
4842 revs.pretty_given = 1;
4843 git_config_get_string("rebase.instructionFormat", &format);
4844 if (!format || !*format) {
4846 format = xstrdup("%s");
4848 get_commit_format(format, &revs);
4850 pp.fmt = revs.commit_format;
4851 pp.output_encoding = get_log_output_encoding();
4853 if (setup_revisions(argc, argv, &revs, NULL) > 1)
4854 return error(_("make_script: unhandled options"));
4856 if (prepare_revision_walk(&revs) < 0)
4857 return error(_("make_script: error preparing revisions"));
4860 return make_script_with_merges(&pp, &revs, out, flags);
4862 while ((commit = get_revision(&revs))) {
4863 int is_empty = is_original_commit_empty(commit);
4865 if (!is_empty && (commit->object.flags & PATCHSAME))
4867 strbuf_addf(out, "%s %s ", insn,
4868 oid_to_hex(&commit->object.oid));
4869 pretty_print_commit(&pp, commit, out);
4870 strbuf_addch(out, '\n');
4876 * Add commands after pick and (series of) squash/fixup commands
4879 void todo_list_add_exec_commands(struct todo_list *todo_list,
4880 struct string_list *commands)
4882 struct strbuf *buf = &todo_list->buf;
4883 size_t base_offset = buf->len;
4884 int i, insert, nr = 0, alloc = 0;
4885 struct todo_item *items = NULL, *base_items = NULL;
4887 base_items = xcalloc(commands->nr, sizeof(struct todo_item));
4888 for (i = 0; i < commands->nr; i++) {
4889 size_t command_len = strlen(commands->items[i].string);
4891 strbuf_addstr(buf, commands->items[i].string);
4892 strbuf_addch(buf, '\n');
4894 base_items[i].command = TODO_EXEC;
4895 base_items[i].offset_in_buf = base_offset;
4896 base_items[i].arg_offset = base_offset + strlen("exec ");
4897 base_items[i].arg_len = command_len - strlen("exec ");
4899 base_offset += command_len + 1;
4903 * Insert <commands> after every pick. Here, fixup/squash chains
4904 * are considered part of the pick, so we insert the commands *after*
4905 * those chains if there are any.
4907 * As we insert the exec commands immediately after rearranging
4908 * any fixups and before the user edits the list, a fixup chain
4909 * can never contain comments (any comments are empty picks that
4910 * have been commented out because the user did not specify
4911 * --keep-empty). So, it is safe to insert an exec command
4912 * without looking at the command following a comment.
4915 for (i = 0; i < todo_list->nr; i++) {
4916 enum todo_command command = todo_list->items[i].command;
4917 if (insert && !is_fixup(command)) {
4918 ALLOC_GROW(items, nr + commands->nr, alloc);
4919 COPY_ARRAY(items + nr, base_items, commands->nr);
4925 ALLOC_GROW(items, nr + 1, alloc);
4926 items[nr++] = todo_list->items[i];
4928 if (command == TODO_PICK || command == TODO_MERGE)
4932 /* insert or append final <commands> */
4933 if (insert || nr == todo_list->nr) {
4934 ALLOC_GROW(items, nr + commands->nr, alloc);
4935 COPY_ARRAY(items + nr, base_items, commands->nr);
4940 FREE_AND_NULL(todo_list->items);
4941 todo_list->items = items;
4943 todo_list->alloc = alloc;
4946 static void todo_list_to_strbuf(struct repository *r, struct todo_list *todo_list,
4947 struct strbuf *buf, int num, unsigned flags)
4949 struct todo_item *item;
4950 int i, max = todo_list->nr;
4952 if (num > 0 && num < max)
4955 for (item = todo_list->items, i = 0; i < max; i++, item++) {
4956 /* if the item is not a command write it and continue */
4957 if (item->command >= TODO_COMMENT) {
4958 strbuf_addf(buf, "%.*s\n", item->arg_len,
4959 todo_item_get_arg(todo_list, item));
4963 /* add command to the buffer */
4964 if (flags & TODO_LIST_ABBREVIATE_CMDS)
4965 strbuf_addch(buf, command_to_char(item->command));
4967 strbuf_addstr(buf, command_to_string(item->command));
4971 const char *oid = flags & TODO_LIST_SHORTEN_IDS ?
4972 short_commit_name(item->commit) :
4973 oid_to_hex(&item->commit->object.oid);
4975 if (item->command == TODO_MERGE) {
4976 if (item->flags & TODO_EDIT_MERGE_MSG)
4977 strbuf_addstr(buf, " -c");
4979 strbuf_addstr(buf, " -C");
4982 strbuf_addf(buf, " %s", oid);
4985 /* add all the rest */
4987 strbuf_addch(buf, '\n');
4989 strbuf_addf(buf, " %.*s\n", item->arg_len,
4990 todo_item_get_arg(todo_list, item));
4994 int todo_list_write_to_file(struct repository *r, struct todo_list *todo_list,
4995 const char *file, const char *shortrevisions,
4996 const char *shortonto, int num, unsigned flags)
4999 struct strbuf buf = STRBUF_INIT;
5001 todo_list_to_strbuf(r, todo_list, &buf, num, flags);
5002 if (flags & TODO_LIST_APPEND_TODO_HELP)
5003 append_todo_help(count_commands(todo_list),
5004 shortrevisions, shortonto, &buf);
5006 res = write_message(buf.buf, buf.len, file, 0);
5007 strbuf_release(&buf);
5012 /* skip picking commits whose parents are unchanged */
5013 static int skip_unnecessary_picks(struct repository *r,
5014 struct todo_list *todo_list,
5015 struct object_id *base_oid)
5017 struct object_id *parent_oid;
5020 for (i = 0; i < todo_list->nr; i++) {
5021 struct todo_item *item = todo_list->items + i;
5023 if (item->command >= TODO_NOOP)
5025 if (item->command != TODO_PICK)
5027 if (parse_commit(item->commit)) {
5028 return error(_("could not parse commit '%s'"),
5029 oid_to_hex(&item->commit->object.oid));
5031 if (!item->commit->parents)
5032 break; /* root commit */
5033 if (item->commit->parents->next)
5034 break; /* merge commit */
5035 parent_oid = &item->commit->parents->item->object.oid;
5036 if (!oideq(parent_oid, base_oid))
5038 oidcpy(base_oid, &item->commit->object.oid);
5041 const char *done_path = rebase_path_done();
5043 if (todo_list_write_to_file(r, todo_list, done_path, NULL, NULL, i, 0)) {
5044 error_errno(_("could not write to '%s'"), done_path);
5048 MOVE_ARRAY(todo_list->items, todo_list->items + i, todo_list->nr - i);
5050 todo_list->current = 0;
5051 todo_list->done_nr += i;
5053 if (is_fixup(peek_command(todo_list, 0)))
5054 record_in_rewritten(base_oid, peek_command(todo_list, 0));
5060 int complete_action(struct repository *r, struct replay_opts *opts, unsigned flags,
5061 const char *shortrevisions, const char *onto_name,
5062 struct commit *onto, const char *orig_head,
5063 struct string_list *commands, unsigned autosquash,
5064 struct todo_list *todo_list)
5066 const char *shortonto, *todo_file = rebase_path_todo();
5067 struct todo_list new_todo = TODO_LIST_INIT;
5068 struct strbuf *buf = &todo_list->buf, buf2 = STRBUF_INIT;
5069 struct object_id oid = onto->object.oid;
5072 shortonto = find_unique_abbrev(&oid, DEFAULT_ABBREV);
5074 if (buf->len == 0) {
5075 struct todo_item *item = append_new_todo(todo_list);
5076 item->command = TODO_NOOP;
5077 item->commit = NULL;
5078 item->arg_len = item->arg_offset = item->flags = item->offset_in_buf = 0;
5081 if (autosquash && todo_list_rearrange_squash(todo_list))
5085 todo_list_add_exec_commands(todo_list, commands);
5087 if (count_commands(todo_list) == 0) {
5088 apply_autostash(opts);
5089 sequencer_remove_state(opts);
5091 return error(_("nothing to do"));
5094 res = edit_todo_list(r, todo_list, &new_todo, shortrevisions,
5098 else if (res == -2) {
5099 apply_autostash(opts);
5100 sequencer_remove_state(opts);
5103 } else if (res == -3) {
5104 apply_autostash(opts);
5105 sequencer_remove_state(opts);
5106 todo_list_release(&new_todo);
5108 return error(_("nothing to do"));
5109 } else if (res == -4) {
5110 checkout_onto(r, opts, onto_name, &onto->object.oid, orig_head);
5111 todo_list_release(&new_todo);
5116 /* Expand the commit IDs */
5117 todo_list_to_strbuf(r, &new_todo, &buf2, -1, 0);
5118 strbuf_swap(&new_todo.buf, &buf2);
5119 strbuf_release(&buf2);
5120 new_todo.total_nr -= new_todo.nr;
5121 if (todo_list_parse_insn_buffer(r, new_todo.buf.buf, &new_todo) < 0)
5122 BUG("invalid todo list after expanding IDs:\n%s",
5125 if (opts->allow_ff && skip_unnecessary_picks(r, &new_todo, &oid)) {
5126 todo_list_release(&new_todo);
5127 return error(_("could not skip unnecessary pick commands"));
5130 if (todo_list_write_to_file(r, &new_todo, todo_file, NULL, NULL, -1,
5131 flags & ~(TODO_LIST_SHORTEN_IDS))) {
5132 todo_list_release(&new_todo);
5133 return error_errno(_("could not write '%s'"), todo_file);
5138 if (checkout_onto(r, opts, onto_name, &oid, orig_head))
5141 if (require_clean_work_tree(r, "rebase", "", 1, 1))
5144 todo_list_write_total_nr(&new_todo);
5145 res = pick_commits(r, &new_todo, opts);
5148 todo_list_release(&new_todo);
5153 struct subject2item_entry {
5154 struct hashmap_entry entry;
5156 char subject[FLEX_ARRAY];
5159 static int subject2item_cmp(const void *fndata,
5160 const struct hashmap_entry *eptr,
5161 const struct hashmap_entry *entry_or_key,
5164 const struct subject2item_entry *a, *b;
5166 a = container_of(eptr, const struct subject2item_entry, entry);
5167 b = container_of(entry_or_key, const struct subject2item_entry, entry);
5169 return key ? strcmp(a->subject, key) : strcmp(a->subject, b->subject);
5172 define_commit_slab(commit_todo_item, struct todo_item *);
5175 * Rearrange the todo list that has both "pick commit-id msg" and "pick
5176 * commit-id fixup!/squash! msg" in it so that the latter is put immediately
5177 * after the former, and change "pick" to "fixup"/"squash".
5179 * Note that if the config has specified a custom instruction format, each log
5180 * message will have to be retrieved from the commit (as the oneline in the
5181 * script cannot be trusted) in order to normalize the autosquash arrangement.
5183 int todo_list_rearrange_squash(struct todo_list *todo_list)
5185 struct hashmap subject2item;
5186 int rearranged = 0, *next, *tail, i, nr = 0, alloc = 0;
5188 struct commit_todo_item commit_todo;
5189 struct todo_item *items = NULL;
5191 init_commit_todo_item(&commit_todo);
5193 * The hashmap maps onelines to the respective todo list index.
5195 * If any items need to be rearranged, the next[i] value will indicate
5196 * which item was moved directly after the i'th.
5198 * In that case, last[i] will indicate the index of the latest item to
5199 * be moved to appear after the i'th.
5201 hashmap_init(&subject2item, subject2item_cmp, NULL, todo_list->nr);
5202 ALLOC_ARRAY(next, todo_list->nr);
5203 ALLOC_ARRAY(tail, todo_list->nr);
5204 ALLOC_ARRAY(subjects, todo_list->nr);
5205 for (i = 0; i < todo_list->nr; i++) {
5206 struct strbuf buf = STRBUF_INIT;
5207 struct todo_item *item = todo_list->items + i;
5208 const char *commit_buffer, *subject, *p;
5211 struct subject2item_entry *entry;
5213 next[i] = tail[i] = -1;
5214 if (!item->commit || item->command == TODO_DROP) {
5219 if (is_fixup(item->command)) {
5220 clear_commit_todo_item(&commit_todo);
5221 return error(_("the script was already rearranged."));
5224 *commit_todo_item_at(&commit_todo, item->commit) = item;
5226 parse_commit(item->commit);
5227 commit_buffer = logmsg_reencode(item->commit, NULL, "UTF-8");
5228 find_commit_subject(commit_buffer, &subject);
5229 format_subject(&buf, subject, " ");
5230 subject = subjects[i] = strbuf_detach(&buf, &subject_len);
5231 unuse_commit_buffer(item->commit, commit_buffer);
5232 if ((skip_prefix(subject, "fixup! ", &p) ||
5233 skip_prefix(subject, "squash! ", &p))) {
5234 struct commit *commit2;
5239 if (!skip_prefix(p, "fixup! ", &p) &&
5240 !skip_prefix(p, "squash! ", &p))
5244 entry = hashmap_get_entry_from_hash(&subject2item,
5246 struct subject2item_entry,
5249 /* found by title */
5251 else if (!strchr(p, ' ') &&
5253 lookup_commit_reference_by_name(p)) &&
5254 *commit_todo_item_at(&commit_todo, commit2))
5255 /* found by commit name */
5256 i2 = *commit_todo_item_at(&commit_todo, commit2)
5259 /* copy can be a prefix of the commit subject */
5260 for (i2 = 0; i2 < i; i2++)
5262 starts_with(subjects[i2], p))
5270 todo_list->items[i].command =
5271 starts_with(subject, "fixup!") ?
5272 TODO_FIXUP : TODO_SQUASH;
5278 } else if (!hashmap_get_from_hash(&subject2item,
5279 strhash(subject), subject)) {
5280 FLEX_ALLOC_MEM(entry, subject, subject, subject_len);
5282 hashmap_entry_init(&entry->entry,
5283 strhash(entry->subject));
5284 hashmap_put(&subject2item, &entry->entry);
5289 for (i = 0; i < todo_list->nr; i++) {
5290 enum todo_command command = todo_list->items[i].command;
5294 * Initially, all commands are 'pick's. If it is a
5295 * fixup or a squash now, we have rearranged it.
5297 if (is_fixup(command))
5301 ALLOC_GROW(items, nr + 1, alloc);
5302 items[nr++] = todo_list->items[cur];
5307 FREE_AND_NULL(todo_list->items);
5308 todo_list->items = items;
5310 todo_list->alloc = alloc;
5315 for (i = 0; i < todo_list->nr; i++)
5318 hashmap_free_entries(&subject2item, struct subject2item_entry, entry);
5320 clear_commit_todo_item(&commit_todo);