Merge branch 'cb/test-use-ere-for-alternation'
[git.git] / sequencer.c
blobfd7701c88a8643c424d4f61fd0cc86fde3097d7d
1 #include "cache.h"
2 #include "config.h"
3 #include "lockfile.h"
4 #include "dir.h"
5 #include "object-store.h"
6 #include "object.h"
7 #include "commit.h"
8 #include "sequencer.h"
9 #include "tag.h"
10 #include "run-command.h"
11 #include "exec-cmd.h"
12 #include "utf8.h"
13 #include "cache-tree.h"
14 #include "diff.h"
15 #include "revision.h"
16 #include "rerere.h"
17 #include "merge-recursive.h"
18 #include "refs.h"
19 #include "argv-array.h"
20 #include "quote.h"
21 #include "trailer.h"
22 #include "log-tree.h"
23 #include "wt-status.h"
24 #include "hashmap.h"
25 #include "notes-utils.h"
26 #include "sigchain.h"
27 #include "unpack-trees.h"
28 #include "worktree.h"
29 #include "oidmap.h"
30 #include "oidset.h"
31 #include "commit-slab.h"
32 #include "alias.h"
33 #include "commit-reach.h"
34 #include "rebase-interactive.h"
35 #include "reset.h"
37 #define GIT_REFLOG_ACTION "GIT_REFLOG_ACTION"
39 static const char sign_off_header[] = "Signed-off-by: ";
40 static const char cherry_picked_prefix[] = "(cherry picked from commit ";
42 GIT_PATH_FUNC(git_path_commit_editmsg, "COMMIT_EDITMSG")
44 static GIT_PATH_FUNC(git_path_seq_dir, "sequencer")
46 static GIT_PATH_FUNC(git_path_todo_file, "sequencer/todo")
47 static GIT_PATH_FUNC(git_path_opts_file, "sequencer/opts")
48 static GIT_PATH_FUNC(git_path_head_file, "sequencer/head")
49 static GIT_PATH_FUNC(git_path_abort_safety_file, "sequencer/abort-safety")
51 static GIT_PATH_FUNC(rebase_path, "rebase-merge")
53 * The file containing rebase commands, comments, and empty lines.
54 * This file is created by "git rebase -i" then edited by the user. As
55 * the lines are processed, they are removed from the front of this
56 * file and written to the tail of 'done'.
58 GIT_PATH_FUNC(rebase_path_todo, "rebase-merge/git-rebase-todo")
59 GIT_PATH_FUNC(rebase_path_todo_backup, "rebase-merge/git-rebase-todo.backup")
61 GIT_PATH_FUNC(rebase_path_dropped, "rebase-merge/dropped")
64 * The rebase command lines that have already been processed. A line
65 * is moved here when it is first handled, before any associated user
66 * actions.
68 static GIT_PATH_FUNC(rebase_path_done, "rebase-merge/done")
70 * The file to keep track of how many commands were already processed (e.g.
71 * for the prompt).
73 static GIT_PATH_FUNC(rebase_path_msgnum, "rebase-merge/msgnum")
75 * The file to keep track of how many commands are to be processed in total
76 * (e.g. for the prompt).
78 static GIT_PATH_FUNC(rebase_path_msgtotal, "rebase-merge/end")
80 * The commit message that is planned to be used for any changes that
81 * need to be committed following a user interaction.
83 static GIT_PATH_FUNC(rebase_path_message, "rebase-merge/message")
85 * The file into which is accumulated the suggested commit message for
86 * squash/fixup commands. When the first of a series of squash/fixups
87 * is seen, the file is created and the commit message from the
88 * previous commit and from the first squash/fixup commit are written
89 * to it. The commit message for each subsequent squash/fixup commit
90 * is appended to the file as it is processed.
92 static GIT_PATH_FUNC(rebase_path_squash_msg, "rebase-merge/message-squash")
94 * If the current series of squash/fixups has not yet included a squash
95 * command, then this file exists and holds the commit message of the
96 * original "pick" commit. (If the series ends without a "squash"
97 * command, then this can be used as the commit message of the combined
98 * commit without opening the editor.)
100 static GIT_PATH_FUNC(rebase_path_fixup_msg, "rebase-merge/message-fixup")
102 * This file contains the list fixup/squash commands that have been
103 * accumulated into message-fixup or message-squash so far.
105 static GIT_PATH_FUNC(rebase_path_current_fixups, "rebase-merge/current-fixups")
107 * A script to set the GIT_AUTHOR_NAME, GIT_AUTHOR_EMAIL, and
108 * GIT_AUTHOR_DATE that will be used for the commit that is currently
109 * being rebased.
111 static GIT_PATH_FUNC(rebase_path_author_script, "rebase-merge/author-script")
113 * When an "edit" rebase command is being processed, the SHA1 of the
114 * commit to be edited is recorded in this file. When "git rebase
115 * --continue" is executed, if there are any staged changes then they
116 * will be amended to the HEAD commit, but only provided the HEAD
117 * commit is still the commit to be edited. When any other rebase
118 * command is processed, this file is deleted.
120 static GIT_PATH_FUNC(rebase_path_amend, "rebase-merge/amend")
122 * When we stop at a given patch via the "edit" command, this file contains
123 * the abbreviated commit name of the corresponding patch.
125 static GIT_PATH_FUNC(rebase_path_stopped_sha, "rebase-merge/stopped-sha")
127 * For the post-rewrite hook, we make a list of rewritten commits and
128 * their new sha1s. The rewritten-pending list keeps the sha1s of
129 * commits that have been processed, but not committed yet,
130 * e.g. because they are waiting for a 'squash' command.
132 static GIT_PATH_FUNC(rebase_path_rewritten_list, "rebase-merge/rewritten-list")
133 static GIT_PATH_FUNC(rebase_path_rewritten_pending,
134 "rebase-merge/rewritten-pending")
137 * The path of the file containing the OID of the "squash onto" commit, i.e.
138 * the dummy commit used for `reset [new root]`.
140 static GIT_PATH_FUNC(rebase_path_squash_onto, "rebase-merge/squash-onto")
143 * The path of the file listing refs that need to be deleted after the rebase
144 * finishes. This is used by the `label` command to record the need for cleanup.
146 static GIT_PATH_FUNC(rebase_path_refs_to_delete, "rebase-merge/refs-to-delete")
149 * The following files are written by git-rebase just after parsing the
150 * command-line.
152 static GIT_PATH_FUNC(rebase_path_gpg_sign_opt, "rebase-merge/gpg_sign_opt")
153 static GIT_PATH_FUNC(rebase_path_orig_head, "rebase-merge/orig-head")
154 static GIT_PATH_FUNC(rebase_path_verbose, "rebase-merge/verbose")
155 static GIT_PATH_FUNC(rebase_path_quiet, "rebase-merge/quiet")
156 static GIT_PATH_FUNC(rebase_path_signoff, "rebase-merge/signoff")
157 static GIT_PATH_FUNC(rebase_path_head_name, "rebase-merge/head-name")
158 static GIT_PATH_FUNC(rebase_path_onto, "rebase-merge/onto")
159 static GIT_PATH_FUNC(rebase_path_autostash, "rebase-merge/autostash")
160 static GIT_PATH_FUNC(rebase_path_strategy, "rebase-merge/strategy")
161 static GIT_PATH_FUNC(rebase_path_strategy_opts, "rebase-merge/strategy_opts")
162 static GIT_PATH_FUNC(rebase_path_allow_rerere_autoupdate, "rebase-merge/allow_rerere_autoupdate")
163 static GIT_PATH_FUNC(rebase_path_reschedule_failed_exec, "rebase-merge/reschedule-failed-exec")
164 static GIT_PATH_FUNC(rebase_path_drop_redundant_commits, "rebase-merge/drop_redundant_commits")
165 static GIT_PATH_FUNC(rebase_path_keep_redundant_commits, "rebase-merge/keep_redundant_commits")
167 static int git_sequencer_config(const char *k, const char *v, void *cb)
169 struct replay_opts *opts = cb;
170 int status;
172 if (!strcmp(k, "commit.cleanup")) {
173 const char *s;
175 status = git_config_string(&s, k, v);
176 if (status)
177 return status;
179 if (!strcmp(s, "verbatim")) {
180 opts->default_msg_cleanup = COMMIT_MSG_CLEANUP_NONE;
181 opts->explicit_cleanup = 1;
182 } else if (!strcmp(s, "whitespace")) {
183 opts->default_msg_cleanup = COMMIT_MSG_CLEANUP_SPACE;
184 opts->explicit_cleanup = 1;
185 } else if (!strcmp(s, "strip")) {
186 opts->default_msg_cleanup = COMMIT_MSG_CLEANUP_ALL;
187 opts->explicit_cleanup = 1;
188 } else if (!strcmp(s, "scissors")) {
189 opts->default_msg_cleanup = COMMIT_MSG_CLEANUP_SCISSORS;
190 opts->explicit_cleanup = 1;
191 } else {
192 warning(_("invalid commit message cleanup mode '%s'"),
196 free((char *)s);
197 return status;
200 if (!strcmp(k, "commit.gpgsign")) {
201 opts->gpg_sign = git_config_bool(k, v) ? xstrdup("") : NULL;
202 return 0;
205 status = git_gpg_config(k, v, NULL);
206 if (status)
207 return status;
209 return git_diff_basic_config(k, v, NULL);
212 void sequencer_init_config(struct replay_opts *opts)
214 opts->default_msg_cleanup = COMMIT_MSG_CLEANUP_NONE;
215 git_config(git_sequencer_config, opts);
218 static inline int is_rebase_i(const struct replay_opts *opts)
220 return opts->action == REPLAY_INTERACTIVE_REBASE;
223 static const char *get_dir(const struct replay_opts *opts)
225 if (is_rebase_i(opts))
226 return rebase_path();
227 return git_path_seq_dir();
230 static const char *get_todo_path(const struct replay_opts *opts)
232 if (is_rebase_i(opts))
233 return rebase_path_todo();
234 return git_path_todo_file();
238 * Returns 0 for non-conforming footer
239 * Returns 1 for conforming footer
240 * Returns 2 when sob exists within conforming footer
241 * Returns 3 when sob exists within conforming footer as last entry
243 static int has_conforming_footer(struct strbuf *sb, struct strbuf *sob,
244 size_t ignore_footer)
246 struct process_trailer_options opts = PROCESS_TRAILER_OPTIONS_INIT;
247 struct trailer_info info;
248 size_t i;
249 int found_sob = 0, found_sob_last = 0;
251 opts.no_divider = 1;
253 trailer_info_get(&info, sb->buf, &opts);
255 if (info.trailer_start == info.trailer_end)
256 return 0;
258 for (i = 0; i < info.trailer_nr; i++)
259 if (sob && !strncmp(info.trailers[i], sob->buf, sob->len)) {
260 found_sob = 1;
261 if (i == info.trailer_nr - 1)
262 found_sob_last = 1;
265 trailer_info_release(&info);
267 if (found_sob_last)
268 return 3;
269 if (found_sob)
270 return 2;
271 return 1;
274 static const char *gpg_sign_opt_quoted(struct replay_opts *opts)
276 static struct strbuf buf = STRBUF_INIT;
278 strbuf_reset(&buf);
279 if (opts->gpg_sign)
280 sq_quotef(&buf, "-S%s", opts->gpg_sign);
281 return buf.buf;
284 int sequencer_remove_state(struct replay_opts *opts)
286 struct strbuf buf = STRBUF_INIT;
287 int i, ret = 0;
289 if (is_rebase_i(opts) &&
290 strbuf_read_file(&buf, rebase_path_refs_to_delete(), 0) > 0) {
291 char *p = buf.buf;
292 while (*p) {
293 char *eol = strchr(p, '\n');
294 if (eol)
295 *eol = '\0';
296 if (delete_ref("(rebase) cleanup", p, NULL, 0) < 0) {
297 warning(_("could not delete '%s'"), p);
298 ret = -1;
300 if (!eol)
301 break;
302 p = eol + 1;
306 free(opts->gpg_sign);
307 free(opts->strategy);
308 for (i = 0; i < opts->xopts_nr; i++)
309 free(opts->xopts[i]);
310 free(opts->xopts);
311 strbuf_release(&opts->current_fixups);
313 strbuf_reset(&buf);
314 strbuf_addstr(&buf, get_dir(opts));
315 if (remove_dir_recursively(&buf, 0))
316 ret = error(_("could not remove '%s'"), buf.buf);
317 strbuf_release(&buf);
319 return ret;
322 static const char *action_name(const struct replay_opts *opts)
324 switch (opts->action) {
325 case REPLAY_REVERT:
326 return N_("revert");
327 case REPLAY_PICK:
328 return N_("cherry-pick");
329 case REPLAY_INTERACTIVE_REBASE:
330 return N_("rebase");
332 die(_("unknown action: %d"), opts->action);
335 struct commit_message {
336 char *parent_label;
337 char *label;
338 char *subject;
339 const char *message;
342 static const char *short_commit_name(struct commit *commit)
344 return find_unique_abbrev(&commit->object.oid, DEFAULT_ABBREV);
347 static int get_message(struct commit *commit, struct commit_message *out)
349 const char *abbrev, *subject;
350 int subject_len;
352 out->message = logmsg_reencode(commit, NULL, get_commit_output_encoding());
353 abbrev = short_commit_name(commit);
355 subject_len = find_commit_subject(out->message, &subject);
357 out->subject = xmemdupz(subject, subject_len);
358 out->label = xstrfmt("%s... %s", abbrev, out->subject);
359 out->parent_label = xstrfmt("parent of %s", out->label);
361 return 0;
364 static void free_message(struct commit *commit, struct commit_message *msg)
366 free(msg->parent_label);
367 free(msg->label);
368 free(msg->subject);
369 unuse_commit_buffer(commit, msg->message);
372 static void print_advice(struct repository *r, int show_hint,
373 struct replay_opts *opts)
375 char *msg = getenv("GIT_CHERRY_PICK_HELP");
377 if (msg) {
378 fprintf(stderr, "%s\n", msg);
380 * A conflict has occurred but the porcelain
381 * (typically rebase --interactive) wants to take care
382 * of the commit itself so remove CHERRY_PICK_HEAD
384 unlink(git_path_cherry_pick_head(r));
385 return;
388 if (show_hint) {
389 if (opts->no_commit)
390 advise(_("after resolving the conflicts, mark the corrected paths\n"
391 "with 'git add <paths>' or 'git rm <paths>'"));
392 else
393 advise(_("after resolving the conflicts, mark the corrected paths\n"
394 "with 'git add <paths>' or 'git rm <paths>'\n"
395 "and commit the result with 'git commit'"));
399 static int write_message(const void *buf, size_t len, const char *filename,
400 int append_eol)
402 struct lock_file msg_file = LOCK_INIT;
404 int msg_fd = hold_lock_file_for_update(&msg_file, filename, 0);
405 if (msg_fd < 0)
406 return error_errno(_("could not lock '%s'"), filename);
407 if (write_in_full(msg_fd, buf, len) < 0) {
408 error_errno(_("could not write to '%s'"), filename);
409 rollback_lock_file(&msg_file);
410 return -1;
412 if (append_eol && write(msg_fd, "\n", 1) < 0) {
413 error_errno(_("could not write eol to '%s'"), filename);
414 rollback_lock_file(&msg_file);
415 return -1;
417 if (commit_lock_file(&msg_file) < 0)
418 return error(_("failed to finalize '%s'"), filename);
420 return 0;
423 int read_oneliner(struct strbuf *buf,
424 const char *path, unsigned flags)
426 int orig_len = buf->len;
428 if (strbuf_read_file(buf, path, 0) < 0) {
429 if ((flags & READ_ONELINER_WARN_MISSING) ||
430 (errno != ENOENT && errno != ENOTDIR))
431 warning_errno(_("could not read '%s'"), path);
432 return 0;
435 if (buf->len > orig_len && buf->buf[buf->len - 1] == '\n') {
436 if (--buf->len > orig_len && buf->buf[buf->len - 1] == '\r')
437 --buf->len;
438 buf->buf[buf->len] = '\0';
441 if ((flags & READ_ONELINER_SKIP_IF_EMPTY) && buf->len == orig_len)
442 return 0;
444 return 1;
447 static struct tree *empty_tree(struct repository *r)
449 return lookup_tree(r, the_hash_algo->empty_tree);
452 static int error_dirty_index(struct repository *repo, struct replay_opts *opts)
454 if (repo_read_index_unmerged(repo))
455 return error_resolve_conflict(_(action_name(opts)));
457 error(_("your local changes would be overwritten by %s."),
458 _(action_name(opts)));
460 if (advice_commit_before_merge)
461 advise(_("commit your changes or stash them to proceed."));
462 return -1;
465 static void update_abort_safety_file(void)
467 struct object_id head;
469 /* Do nothing on a single-pick */
470 if (!file_exists(git_path_seq_dir()))
471 return;
473 if (!get_oid("HEAD", &head))
474 write_file(git_path_abort_safety_file(), "%s", oid_to_hex(&head));
475 else
476 write_file(git_path_abort_safety_file(), "%s", "");
479 static int fast_forward_to(struct repository *r,
480 const struct object_id *to,
481 const struct object_id *from,
482 int unborn,
483 struct replay_opts *opts)
485 struct ref_transaction *transaction;
486 struct strbuf sb = STRBUF_INIT;
487 struct strbuf err = STRBUF_INIT;
489 repo_read_index(r);
490 if (checkout_fast_forward(r, from, to, 1))
491 return -1; /* the callee should have complained already */
493 strbuf_addf(&sb, _("%s: fast-forward"), _(action_name(opts)));
495 transaction = ref_transaction_begin(&err);
496 if (!transaction ||
497 ref_transaction_update(transaction, "HEAD",
498 to, unborn && !is_rebase_i(opts) ?
499 &null_oid : from,
500 0, sb.buf, &err) ||
501 ref_transaction_commit(transaction, &err)) {
502 ref_transaction_free(transaction);
503 error("%s", err.buf);
504 strbuf_release(&sb);
505 strbuf_release(&err);
506 return -1;
509 strbuf_release(&sb);
510 strbuf_release(&err);
511 ref_transaction_free(transaction);
512 update_abort_safety_file();
513 return 0;
516 enum commit_msg_cleanup_mode get_cleanup_mode(const char *cleanup_arg,
517 int use_editor)
519 if (!cleanup_arg || !strcmp(cleanup_arg, "default"))
520 return use_editor ? COMMIT_MSG_CLEANUP_ALL :
521 COMMIT_MSG_CLEANUP_SPACE;
522 else if (!strcmp(cleanup_arg, "verbatim"))
523 return COMMIT_MSG_CLEANUP_NONE;
524 else if (!strcmp(cleanup_arg, "whitespace"))
525 return COMMIT_MSG_CLEANUP_SPACE;
526 else if (!strcmp(cleanup_arg, "strip"))
527 return COMMIT_MSG_CLEANUP_ALL;
528 else if (!strcmp(cleanup_arg, "scissors"))
529 return use_editor ? COMMIT_MSG_CLEANUP_SCISSORS :
530 COMMIT_MSG_CLEANUP_SPACE;
531 else
532 die(_("Invalid cleanup mode %s"), cleanup_arg);
536 * NB using int rather than enum cleanup_mode to stop clang's
537 * -Wtautological-constant-out-of-range-compare complaining that the comparison
538 * is always true.
540 static const char *describe_cleanup_mode(int cleanup_mode)
542 static const char *modes[] = { "whitespace",
543 "verbatim",
544 "scissors",
545 "strip" };
547 if (cleanup_mode < ARRAY_SIZE(modes))
548 return modes[cleanup_mode];
550 BUG("invalid cleanup_mode provided (%d)", cleanup_mode);
553 void append_conflicts_hint(struct index_state *istate,
554 struct strbuf *msgbuf, enum commit_msg_cleanup_mode cleanup_mode)
556 int i;
558 if (cleanup_mode == COMMIT_MSG_CLEANUP_SCISSORS) {
559 strbuf_addch(msgbuf, '\n');
560 wt_status_append_cut_line(msgbuf);
561 strbuf_addch(msgbuf, comment_line_char);
564 strbuf_addch(msgbuf, '\n');
565 strbuf_commented_addf(msgbuf, "Conflicts:\n");
566 for (i = 0; i < istate->cache_nr;) {
567 const struct cache_entry *ce = istate->cache[i++];
568 if (ce_stage(ce)) {
569 strbuf_commented_addf(msgbuf, "\t%s\n", ce->name);
570 while (i < istate->cache_nr &&
571 !strcmp(ce->name, istate->cache[i]->name))
572 i++;
577 static int do_recursive_merge(struct repository *r,
578 struct commit *base, struct commit *next,
579 const char *base_label, const char *next_label,
580 struct object_id *head, struct strbuf *msgbuf,
581 struct replay_opts *opts)
583 struct merge_options o;
584 struct tree *next_tree, *base_tree, *head_tree;
585 int clean;
586 int i;
587 struct lock_file index_lock = LOCK_INIT;
589 if (repo_hold_locked_index(r, &index_lock, LOCK_REPORT_ON_ERROR) < 0)
590 return -1;
592 repo_read_index(r);
594 init_merge_options(&o, r);
595 o.ancestor = base ? base_label : "(empty tree)";
596 o.branch1 = "HEAD";
597 o.branch2 = next ? next_label : "(empty tree)";
598 if (is_rebase_i(opts))
599 o.buffer_output = 2;
600 o.show_rename_progress = 1;
602 head_tree = parse_tree_indirect(head);
603 next_tree = next ? get_commit_tree(next) : empty_tree(r);
604 base_tree = base ? get_commit_tree(base) : empty_tree(r);
606 for (i = 0; i < opts->xopts_nr; i++)
607 parse_merge_opt(&o, opts->xopts[i]);
609 clean = merge_trees(&o,
610 head_tree,
611 next_tree, base_tree);
612 if (is_rebase_i(opts) && clean <= 0)
613 fputs(o.obuf.buf, stdout);
614 strbuf_release(&o.obuf);
615 if (clean < 0) {
616 rollback_lock_file(&index_lock);
617 return clean;
620 if (write_locked_index(r->index, &index_lock,
621 COMMIT_LOCK | SKIP_IF_UNCHANGED))
623 * TRANSLATORS: %s will be "revert", "cherry-pick" or
624 * "rebase".
626 return error(_("%s: Unable to write new index file"),
627 _(action_name(opts)));
629 if (!clean)
630 append_conflicts_hint(r->index, msgbuf,
631 opts->default_msg_cleanup);
633 return !clean;
636 static struct object_id *get_cache_tree_oid(struct index_state *istate)
638 if (!istate->cache_tree)
639 istate->cache_tree = cache_tree();
641 if (!cache_tree_fully_valid(istate->cache_tree))
642 if (cache_tree_update(istate, 0)) {
643 error(_("unable to update cache tree"));
644 return NULL;
647 return &istate->cache_tree->oid;
650 static int is_index_unchanged(struct repository *r)
652 struct object_id head_oid, *cache_tree_oid;
653 struct commit *head_commit;
654 struct index_state *istate = r->index;
656 if (!resolve_ref_unsafe("HEAD", RESOLVE_REF_READING, &head_oid, NULL))
657 return error(_("could not resolve HEAD commit"));
659 head_commit = lookup_commit(r, &head_oid);
662 * If head_commit is NULL, check_commit, called from
663 * lookup_commit, would have indicated that head_commit is not
664 * a commit object already. parse_commit() will return failure
665 * without further complaints in such a case. Otherwise, if
666 * the commit is invalid, parse_commit() will complain. So
667 * there is nothing for us to say here. Just return failure.
669 if (parse_commit(head_commit))
670 return -1;
672 if (!(cache_tree_oid = get_cache_tree_oid(istate)))
673 return -1;
675 return oideq(cache_tree_oid, get_commit_tree_oid(head_commit));
678 static int write_author_script(const char *message)
680 struct strbuf buf = STRBUF_INIT;
681 const char *eol;
682 int res;
684 for (;;)
685 if (!*message || starts_with(message, "\n")) {
686 missing_author:
687 /* Missing 'author' line? */
688 unlink(rebase_path_author_script());
689 return 0;
690 } else if (skip_prefix(message, "author ", &message))
691 break;
692 else if ((eol = strchr(message, '\n')))
693 message = eol + 1;
694 else
695 goto missing_author;
697 strbuf_addstr(&buf, "GIT_AUTHOR_NAME='");
698 while (*message && *message != '\n' && *message != '\r')
699 if (skip_prefix(message, " <", &message))
700 break;
701 else if (*message != '\'')
702 strbuf_addch(&buf, *(message++));
703 else
704 strbuf_addf(&buf, "'\\%c'", *(message++));
705 strbuf_addstr(&buf, "'\nGIT_AUTHOR_EMAIL='");
706 while (*message && *message != '\n' && *message != '\r')
707 if (skip_prefix(message, "> ", &message))
708 break;
709 else if (*message != '\'')
710 strbuf_addch(&buf, *(message++));
711 else
712 strbuf_addf(&buf, "'\\%c'", *(message++));
713 strbuf_addstr(&buf, "'\nGIT_AUTHOR_DATE='@");
714 while (*message && *message != '\n' && *message != '\r')
715 if (*message != '\'')
716 strbuf_addch(&buf, *(message++));
717 else
718 strbuf_addf(&buf, "'\\%c'", *(message++));
719 strbuf_addch(&buf, '\'');
720 res = write_message(buf.buf, buf.len, rebase_path_author_script(), 1);
721 strbuf_release(&buf);
722 return res;
726 * Take a series of KEY='VALUE' lines where VALUE part is
727 * sq-quoted, and append <KEY, VALUE> at the end of the string list
729 static int parse_key_value_squoted(char *buf, struct string_list *list)
731 while (*buf) {
732 struct string_list_item *item;
733 char *np;
734 char *cp = strchr(buf, '=');
735 if (!cp) {
736 np = strchrnul(buf, '\n');
737 return error(_("no key present in '%.*s'"),
738 (int) (np - buf), buf);
740 np = strchrnul(cp, '\n');
741 *cp++ = '\0';
742 item = string_list_append(list, buf);
744 buf = np + (*np == '\n');
745 *np = '\0';
746 cp = sq_dequote(cp);
747 if (!cp)
748 return error(_("unable to dequote value of '%s'"),
749 item->string);
750 item->util = xstrdup(cp);
752 return 0;
756 * Reads and parses the state directory's "author-script" file, and sets name,
757 * email and date accordingly.
758 * Returns 0 on success, -1 if the file could not be parsed.
760 * The author script is of the format:
762 * GIT_AUTHOR_NAME='$author_name'
763 * GIT_AUTHOR_EMAIL='$author_email'
764 * GIT_AUTHOR_DATE='$author_date'
766 * where $author_name, $author_email and $author_date are quoted. We are strict
767 * with our parsing, as the file was meant to be eval'd in the now-removed
768 * git-am.sh/git-rebase--interactive.sh scripts, and thus if the file differs
769 * from what this function expects, it is better to bail out than to do
770 * something that the user does not expect.
772 int read_author_script(const char *path, char **name, char **email, char **date,
773 int allow_missing)
775 struct strbuf buf = STRBUF_INIT;
776 struct string_list kv = STRING_LIST_INIT_DUP;
777 int retval = -1; /* assume failure */
778 int i, name_i = -2, email_i = -2, date_i = -2, err = 0;
780 if (strbuf_read_file(&buf, path, 256) <= 0) {
781 strbuf_release(&buf);
782 if (errno == ENOENT && allow_missing)
783 return 0;
784 else
785 return error_errno(_("could not open '%s' for reading"),
786 path);
789 if (parse_key_value_squoted(buf.buf, &kv))
790 goto finish;
792 for (i = 0; i < kv.nr; i++) {
793 if (!strcmp(kv.items[i].string, "GIT_AUTHOR_NAME")) {
794 if (name_i != -2)
795 name_i = error(_("'GIT_AUTHOR_NAME' already given"));
796 else
797 name_i = i;
798 } else if (!strcmp(kv.items[i].string, "GIT_AUTHOR_EMAIL")) {
799 if (email_i != -2)
800 email_i = error(_("'GIT_AUTHOR_EMAIL' already given"));
801 else
802 email_i = i;
803 } else if (!strcmp(kv.items[i].string, "GIT_AUTHOR_DATE")) {
804 if (date_i != -2)
805 date_i = error(_("'GIT_AUTHOR_DATE' already given"));
806 else
807 date_i = i;
808 } else {
809 err = error(_("unknown variable '%s'"),
810 kv.items[i].string);
813 if (name_i == -2)
814 error(_("missing 'GIT_AUTHOR_NAME'"));
815 if (email_i == -2)
816 error(_("missing 'GIT_AUTHOR_EMAIL'"));
817 if (date_i == -2)
818 error(_("missing 'GIT_AUTHOR_DATE'"));
819 if (date_i < 0 || email_i < 0 || date_i < 0 || err)
820 goto finish;
821 *name = kv.items[name_i].util;
822 *email = kv.items[email_i].util;
823 *date = kv.items[date_i].util;
824 retval = 0;
825 finish:
826 string_list_clear(&kv, !!retval);
827 strbuf_release(&buf);
828 return retval;
832 * Read a GIT_AUTHOR_NAME, GIT_AUTHOR_EMAIL AND GIT_AUTHOR_DATE from a
833 * file with shell quoting into struct argv_array. Returns -1 on
834 * error, 0 otherwise.
836 static int read_env_script(struct argv_array *env)
838 char *name, *email, *date;
840 if (read_author_script(rebase_path_author_script(),
841 &name, &email, &date, 0))
842 return -1;
844 argv_array_pushf(env, "GIT_AUTHOR_NAME=%s", name);
845 argv_array_pushf(env, "GIT_AUTHOR_EMAIL=%s", email);
846 argv_array_pushf(env, "GIT_AUTHOR_DATE=%s", date);
847 free(name);
848 free(email);
849 free(date);
851 return 0;
854 static char *get_author(const char *message)
856 size_t len;
857 const char *a;
859 a = find_commit_header(message, "author", &len);
860 if (a)
861 return xmemdupz(a, len);
863 return NULL;
866 static const char staged_changes_advice[] =
867 N_("you have staged changes in your working tree\n"
868 "If these changes are meant to be squashed into the previous commit, run:\n"
869 "\n"
870 " git commit --amend %s\n"
871 "\n"
872 "If they are meant to go into a new commit, run:\n"
873 "\n"
874 " git commit %s\n"
875 "\n"
876 "In both cases, once you're done, continue with:\n"
877 "\n"
878 " git rebase --continue\n");
880 #define ALLOW_EMPTY (1<<0)
881 #define EDIT_MSG (1<<1)
882 #define AMEND_MSG (1<<2)
883 #define CLEANUP_MSG (1<<3)
884 #define VERIFY_MSG (1<<4)
885 #define CREATE_ROOT_COMMIT (1<<5)
887 static int run_command_silent_on_success(struct child_process *cmd)
889 struct strbuf buf = STRBUF_INIT;
890 int rc;
892 cmd->stdout_to_stderr = 1;
893 rc = pipe_command(cmd,
894 NULL, 0,
895 NULL, 0,
896 &buf, 0);
898 if (rc)
899 fputs(buf.buf, stderr);
900 strbuf_release(&buf);
901 return rc;
905 * If we are cherry-pick, and if the merge did not result in
906 * hand-editing, we will hit this commit and inherit the original
907 * author date and name.
909 * If we are revert, or if our cherry-pick results in a hand merge,
910 * we had better say that the current user is responsible for that.
912 * An exception is when run_git_commit() is called during an
913 * interactive rebase: in that case, we will want to retain the
914 * author metadata.
916 static int run_git_commit(struct repository *r,
917 const char *defmsg,
918 struct replay_opts *opts,
919 unsigned int flags)
921 struct child_process cmd = CHILD_PROCESS_INIT;
923 cmd.git_cmd = 1;
925 if (is_rebase_i(opts) && read_env_script(&cmd.env_array)) {
926 const char *gpg_opt = gpg_sign_opt_quoted(opts);
928 return error(_(staged_changes_advice),
929 gpg_opt, gpg_opt);
932 argv_array_push(&cmd.args, "commit");
934 if (!(flags & VERIFY_MSG))
935 argv_array_push(&cmd.args, "-n");
936 if ((flags & AMEND_MSG))
937 argv_array_push(&cmd.args, "--amend");
938 if (opts->gpg_sign)
939 argv_array_pushf(&cmd.args, "-S%s", opts->gpg_sign);
940 else
941 argv_array_push(&cmd.args, "--no-gpg-sign");
942 if (defmsg)
943 argv_array_pushl(&cmd.args, "-F", defmsg, NULL);
944 else if (!(flags & EDIT_MSG))
945 argv_array_pushl(&cmd.args, "-C", "HEAD", NULL);
946 if ((flags & CLEANUP_MSG))
947 argv_array_push(&cmd.args, "--cleanup=strip");
948 if ((flags & EDIT_MSG))
949 argv_array_push(&cmd.args, "-e");
950 else if (!(flags & CLEANUP_MSG) &&
951 !opts->signoff && !opts->record_origin &&
952 !opts->explicit_cleanup)
953 argv_array_push(&cmd.args, "--cleanup=verbatim");
955 if ((flags & ALLOW_EMPTY))
956 argv_array_push(&cmd.args, "--allow-empty");
958 if (!(flags & EDIT_MSG))
959 argv_array_push(&cmd.args, "--allow-empty-message");
961 if (is_rebase_i(opts) && !(flags & EDIT_MSG))
962 return run_command_silent_on_success(&cmd);
963 else
964 return run_command(&cmd);
967 static int rest_is_empty(const struct strbuf *sb, int start)
969 int i, eol;
970 const char *nl;
972 /* Check if the rest is just whitespace and Signed-off-by's. */
973 for (i = start; i < sb->len; i++) {
974 nl = memchr(sb->buf + i, '\n', sb->len - i);
975 if (nl)
976 eol = nl - sb->buf;
977 else
978 eol = sb->len;
980 if (strlen(sign_off_header) <= eol - i &&
981 starts_with(sb->buf + i, sign_off_header)) {
982 i = eol;
983 continue;
985 while (i < eol)
986 if (!isspace(sb->buf[i++]))
987 return 0;
990 return 1;
993 void cleanup_message(struct strbuf *msgbuf,
994 enum commit_msg_cleanup_mode cleanup_mode, int verbose)
996 if (verbose || /* Truncate the message just before the diff, if any. */
997 cleanup_mode == COMMIT_MSG_CLEANUP_SCISSORS)
998 strbuf_setlen(msgbuf, wt_status_locate_end(msgbuf->buf, msgbuf->len));
999 if (cleanup_mode != COMMIT_MSG_CLEANUP_NONE)
1000 strbuf_stripspace(msgbuf, cleanup_mode == COMMIT_MSG_CLEANUP_ALL);
1004 * Find out if the message in the strbuf contains only whitespace and
1005 * Signed-off-by lines.
1007 int message_is_empty(const struct strbuf *sb,
1008 enum commit_msg_cleanup_mode cleanup_mode)
1010 if (cleanup_mode == COMMIT_MSG_CLEANUP_NONE && sb->len)
1011 return 0;
1012 return rest_is_empty(sb, 0);
1016 * See if the user edited the message in the editor or left what
1017 * was in the template intact
1019 int template_untouched(const struct strbuf *sb, const char *template_file,
1020 enum commit_msg_cleanup_mode cleanup_mode)
1022 struct strbuf tmpl = STRBUF_INIT;
1023 const char *start;
1025 if (cleanup_mode == COMMIT_MSG_CLEANUP_NONE && sb->len)
1026 return 0;
1028 if (!template_file || strbuf_read_file(&tmpl, template_file, 0) <= 0)
1029 return 0;
1031 strbuf_stripspace(&tmpl, cleanup_mode == COMMIT_MSG_CLEANUP_ALL);
1032 if (!skip_prefix(sb->buf, tmpl.buf, &start))
1033 start = sb->buf;
1034 strbuf_release(&tmpl);
1035 return rest_is_empty(sb, start - sb->buf);
1038 int update_head_with_reflog(const struct commit *old_head,
1039 const struct object_id *new_head,
1040 const char *action, const struct strbuf *msg,
1041 struct strbuf *err)
1043 struct ref_transaction *transaction;
1044 struct strbuf sb = STRBUF_INIT;
1045 const char *nl;
1046 int ret = 0;
1048 if (action) {
1049 strbuf_addstr(&sb, action);
1050 strbuf_addstr(&sb, ": ");
1053 nl = strchr(msg->buf, '\n');
1054 if (nl) {
1055 strbuf_add(&sb, msg->buf, nl + 1 - msg->buf);
1056 } else {
1057 strbuf_addbuf(&sb, msg);
1058 strbuf_addch(&sb, '\n');
1061 transaction = ref_transaction_begin(err);
1062 if (!transaction ||
1063 ref_transaction_update(transaction, "HEAD", new_head,
1064 old_head ? &old_head->object.oid : &null_oid,
1065 0, sb.buf, err) ||
1066 ref_transaction_commit(transaction, err)) {
1067 ret = -1;
1069 ref_transaction_free(transaction);
1070 strbuf_release(&sb);
1072 return ret;
1075 static int run_rewrite_hook(const struct object_id *oldoid,
1076 const struct object_id *newoid)
1078 struct child_process proc = CHILD_PROCESS_INIT;
1079 const char *argv[3];
1080 int code;
1081 struct strbuf sb = STRBUF_INIT;
1083 argv[0] = find_hook("post-rewrite");
1084 if (!argv[0])
1085 return 0;
1087 argv[1] = "amend";
1088 argv[2] = NULL;
1090 proc.argv = argv;
1091 proc.in = -1;
1092 proc.stdout_to_stderr = 1;
1093 proc.trace2_hook_name = "post-rewrite";
1095 code = start_command(&proc);
1096 if (code)
1097 return code;
1098 strbuf_addf(&sb, "%s %s\n", oid_to_hex(oldoid), oid_to_hex(newoid));
1099 sigchain_push(SIGPIPE, SIG_IGN);
1100 write_in_full(proc.in, sb.buf, sb.len);
1101 close(proc.in);
1102 strbuf_release(&sb);
1103 sigchain_pop(SIGPIPE);
1104 return finish_command(&proc);
1107 void commit_post_rewrite(struct repository *r,
1108 const struct commit *old_head,
1109 const struct object_id *new_head)
1111 struct notes_rewrite_cfg *cfg;
1113 cfg = init_copy_notes_for_rewrite("amend");
1114 if (cfg) {
1115 /* we are amending, so old_head is not NULL */
1116 copy_note_for_rewrite(cfg, &old_head->object.oid, new_head);
1117 finish_copy_notes_for_rewrite(r, cfg, "Notes added by 'git commit --amend'");
1119 run_rewrite_hook(&old_head->object.oid, new_head);
1122 static int run_prepare_commit_msg_hook(struct repository *r,
1123 struct strbuf *msg,
1124 const char *commit)
1126 int ret = 0;
1127 const char *name, *arg1 = NULL, *arg2 = NULL;
1129 name = git_path_commit_editmsg();
1130 if (write_message(msg->buf, msg->len, name, 0))
1131 return -1;
1133 if (commit) {
1134 arg1 = "commit";
1135 arg2 = commit;
1136 } else {
1137 arg1 = "message";
1139 if (run_commit_hook(0, r->index_file, "prepare-commit-msg", name,
1140 arg1, arg2, NULL))
1141 ret = error(_("'prepare-commit-msg' hook failed"));
1143 return ret;
1146 static const char implicit_ident_advice_noconfig[] =
1147 N_("Your name and email address were configured automatically based\n"
1148 "on your username and hostname. Please check that they are accurate.\n"
1149 "You can suppress this message by setting them explicitly. Run the\n"
1150 "following command and follow the instructions in your editor to edit\n"
1151 "your configuration file:\n"
1152 "\n"
1153 " git config --global --edit\n"
1154 "\n"
1155 "After doing this, you may fix the identity used for this commit with:\n"
1156 "\n"
1157 " git commit --amend --reset-author\n");
1159 static const char implicit_ident_advice_config[] =
1160 N_("Your name and email address were configured automatically based\n"
1161 "on your username and hostname. Please check that they are accurate.\n"
1162 "You can suppress this message by setting them explicitly:\n"
1163 "\n"
1164 " git config --global user.name \"Your Name\"\n"
1165 " git config --global user.email you@example.com\n"
1166 "\n"
1167 "After doing this, you may fix the identity used for this commit with:\n"
1168 "\n"
1169 " git commit --amend --reset-author\n");
1171 static const char *implicit_ident_advice(void)
1173 char *user_config = expand_user_path("~/.gitconfig", 0);
1174 char *xdg_config = xdg_config_home("config");
1175 int config_exists = file_exists(user_config) || file_exists(xdg_config);
1177 free(user_config);
1178 free(xdg_config);
1180 if (config_exists)
1181 return _(implicit_ident_advice_config);
1182 else
1183 return _(implicit_ident_advice_noconfig);
1187 void print_commit_summary(struct repository *r,
1188 const char *prefix,
1189 const struct object_id *oid,
1190 unsigned int flags)
1192 struct rev_info rev;
1193 struct commit *commit;
1194 struct strbuf format = STRBUF_INIT;
1195 const char *head;
1196 struct pretty_print_context pctx = {0};
1197 struct strbuf author_ident = STRBUF_INIT;
1198 struct strbuf committer_ident = STRBUF_INIT;
1200 commit = lookup_commit(r, oid);
1201 if (!commit)
1202 die(_("couldn't look up newly created commit"));
1203 if (parse_commit(commit))
1204 die(_("could not parse newly created commit"));
1206 strbuf_addstr(&format, "format:%h] %s");
1208 format_commit_message(commit, "%an <%ae>", &author_ident, &pctx);
1209 format_commit_message(commit, "%cn <%ce>", &committer_ident, &pctx);
1210 if (strbuf_cmp(&author_ident, &committer_ident)) {
1211 strbuf_addstr(&format, "\n Author: ");
1212 strbuf_addbuf_percentquote(&format, &author_ident);
1214 if (flags & SUMMARY_SHOW_AUTHOR_DATE) {
1215 struct strbuf date = STRBUF_INIT;
1217 format_commit_message(commit, "%ad", &date, &pctx);
1218 strbuf_addstr(&format, "\n Date: ");
1219 strbuf_addbuf_percentquote(&format, &date);
1220 strbuf_release(&date);
1222 if (!committer_ident_sufficiently_given()) {
1223 strbuf_addstr(&format, "\n Committer: ");
1224 strbuf_addbuf_percentquote(&format, &committer_ident);
1225 if (advice_implicit_identity) {
1226 strbuf_addch(&format, '\n');
1227 strbuf_addstr(&format, implicit_ident_advice());
1230 strbuf_release(&author_ident);
1231 strbuf_release(&committer_ident);
1233 repo_init_revisions(r, &rev, prefix);
1234 setup_revisions(0, NULL, &rev, NULL);
1236 rev.diff = 1;
1237 rev.diffopt.output_format =
1238 DIFF_FORMAT_SHORTSTAT | DIFF_FORMAT_SUMMARY;
1240 rev.verbose_header = 1;
1241 rev.show_root_diff = 1;
1242 get_commit_format(format.buf, &rev);
1243 rev.always_show_header = 0;
1244 rev.diffopt.detect_rename = DIFF_DETECT_RENAME;
1245 rev.diffopt.break_opt = 0;
1246 diff_setup_done(&rev.diffopt);
1248 head = resolve_ref_unsafe("HEAD", 0, NULL, NULL);
1249 if (!head)
1250 die_errno(_("unable to resolve HEAD after creating commit"));
1251 if (!strcmp(head, "HEAD"))
1252 head = _("detached HEAD");
1253 else
1254 skip_prefix(head, "refs/heads/", &head);
1255 printf("[%s%s ", head, (flags & SUMMARY_INITIAL_COMMIT) ?
1256 _(" (root-commit)") : "");
1258 if (!log_tree_commit(&rev, commit)) {
1259 rev.always_show_header = 1;
1260 rev.use_terminator = 1;
1261 log_tree_commit(&rev, commit);
1264 strbuf_release(&format);
1267 static int parse_head(struct repository *r, struct commit **head)
1269 struct commit *current_head;
1270 struct object_id oid;
1272 if (get_oid("HEAD", &oid)) {
1273 current_head = NULL;
1274 } else {
1275 current_head = lookup_commit_reference(r, &oid);
1276 if (!current_head)
1277 return error(_("could not parse HEAD"));
1278 if (!oideq(&oid, &current_head->object.oid)) {
1279 warning(_("HEAD %s is not a commit!"),
1280 oid_to_hex(&oid));
1282 if (parse_commit(current_head))
1283 return error(_("could not parse HEAD commit"));
1285 *head = current_head;
1287 return 0;
1291 * Try to commit without forking 'git commit'. In some cases we need
1292 * to run 'git commit' to display an error message
1294 * Returns:
1295 * -1 - error unable to commit
1296 * 0 - success
1297 * 1 - run 'git commit'
1299 static int try_to_commit(struct repository *r,
1300 struct strbuf *msg, const char *author,
1301 struct replay_opts *opts, unsigned int flags,
1302 struct object_id *oid)
1304 struct object_id tree;
1305 struct commit *current_head = NULL;
1306 struct commit_list *parents = NULL;
1307 struct commit_extra_header *extra = NULL;
1308 struct strbuf err = STRBUF_INIT;
1309 struct strbuf commit_msg = STRBUF_INIT;
1310 char *amend_author = NULL;
1311 const char *hook_commit = NULL;
1312 enum commit_msg_cleanup_mode cleanup;
1313 int res = 0;
1315 if (parse_head(r, &current_head))
1316 return -1;
1318 if (flags & AMEND_MSG) {
1319 const char *exclude_gpgsig[] = { "gpgsig", "gpgsig-sha256", NULL };
1320 const char *out_enc = get_commit_output_encoding();
1321 const char *message = logmsg_reencode(current_head, NULL,
1322 out_enc);
1324 if (!msg) {
1325 const char *orig_message = NULL;
1327 find_commit_subject(message, &orig_message);
1328 msg = &commit_msg;
1329 strbuf_addstr(msg, orig_message);
1330 hook_commit = "HEAD";
1332 author = amend_author = get_author(message);
1333 unuse_commit_buffer(current_head, message);
1334 if (!author) {
1335 res = error(_("unable to parse commit author"));
1336 goto out;
1338 parents = copy_commit_list(current_head->parents);
1339 extra = read_commit_extra_headers(current_head, exclude_gpgsig);
1340 } else if (current_head &&
1341 (!(flags & CREATE_ROOT_COMMIT) || (flags & AMEND_MSG))) {
1342 commit_list_insert(current_head, &parents);
1345 if (write_index_as_tree(&tree, r->index, r->index_file, 0, NULL)) {
1346 res = error(_("git write-tree failed to write a tree"));
1347 goto out;
1350 if (!(flags & ALLOW_EMPTY)) {
1351 struct commit *first_parent = current_head;
1353 if (flags & AMEND_MSG) {
1354 if (current_head->parents) {
1355 first_parent = current_head->parents->item;
1356 if (repo_parse_commit(r, first_parent)) {
1357 res = error(_("could not parse HEAD commit"));
1358 goto out;
1360 } else {
1361 first_parent = NULL;
1364 if (oideq(first_parent
1365 ? get_commit_tree_oid(first_parent)
1366 : the_hash_algo->empty_tree,
1367 &tree)) {
1368 res = 1; /* run 'git commit' to display error message */
1369 goto out;
1373 if (find_hook("prepare-commit-msg")) {
1374 res = run_prepare_commit_msg_hook(r, msg, hook_commit);
1375 if (res)
1376 goto out;
1377 if (strbuf_read_file(&commit_msg, git_path_commit_editmsg(),
1378 2048) < 0) {
1379 res = error_errno(_("unable to read commit message "
1380 "from '%s'"),
1381 git_path_commit_editmsg());
1382 goto out;
1384 msg = &commit_msg;
1387 if (flags & CLEANUP_MSG)
1388 cleanup = COMMIT_MSG_CLEANUP_ALL;
1389 else if ((opts->signoff || opts->record_origin) &&
1390 !opts->explicit_cleanup)
1391 cleanup = COMMIT_MSG_CLEANUP_SPACE;
1392 else
1393 cleanup = opts->default_msg_cleanup;
1395 if (cleanup != COMMIT_MSG_CLEANUP_NONE)
1396 strbuf_stripspace(msg, cleanup == COMMIT_MSG_CLEANUP_ALL);
1397 if ((flags & EDIT_MSG) && message_is_empty(msg, cleanup)) {
1398 res = 1; /* run 'git commit' to display error message */
1399 goto out;
1402 reset_ident_date();
1404 if (commit_tree_extended(msg->buf, msg->len, &tree, parents,
1405 oid, author, opts->gpg_sign, extra)) {
1406 res = error(_("failed to write commit object"));
1407 goto out;
1410 if (update_head_with_reflog(current_head, oid,
1411 getenv("GIT_REFLOG_ACTION"), msg, &err)) {
1412 res = error("%s", err.buf);
1413 goto out;
1416 run_commit_hook(0, r->index_file, "post-commit", NULL);
1417 if (flags & AMEND_MSG)
1418 commit_post_rewrite(r, current_head, oid);
1420 out:
1421 free_commit_extra_headers(extra);
1422 strbuf_release(&err);
1423 strbuf_release(&commit_msg);
1424 free(amend_author);
1426 return res;
1429 static int write_rebase_head(struct object_id *oid)
1431 if (update_ref("rebase", "REBASE_HEAD", oid,
1432 NULL, REF_NO_DEREF, UPDATE_REFS_MSG_ON_ERR))
1433 return error(_("could not update %s"), "REBASE_HEAD");
1435 return 0;
1438 static int do_commit(struct repository *r,
1439 const char *msg_file, const char *author,
1440 struct replay_opts *opts, unsigned int flags,
1441 struct object_id *oid)
1443 int res = 1;
1445 if (!(flags & EDIT_MSG) && !(flags & VERIFY_MSG)) {
1446 struct object_id oid;
1447 struct strbuf sb = STRBUF_INIT;
1449 if (msg_file && strbuf_read_file(&sb, msg_file, 2048) < 0)
1450 return error_errno(_("unable to read commit message "
1451 "from '%s'"),
1452 msg_file);
1454 res = try_to_commit(r, msg_file ? &sb : NULL,
1455 author, opts, flags, &oid);
1456 strbuf_release(&sb);
1457 if (!res) {
1458 unlink(git_path_cherry_pick_head(r));
1459 unlink(git_path_merge_msg(r));
1460 if (!is_rebase_i(opts))
1461 print_commit_summary(r, NULL, &oid,
1462 SUMMARY_SHOW_AUTHOR_DATE);
1463 return res;
1466 if (res == 1) {
1467 if (is_rebase_i(opts) && oid)
1468 if (write_rebase_head(oid))
1469 return -1;
1470 return run_git_commit(r, msg_file, opts, flags);
1473 return res;
1476 static int is_original_commit_empty(struct commit *commit)
1478 const struct object_id *ptree_oid;
1480 if (parse_commit(commit))
1481 return error(_("could not parse commit %s"),
1482 oid_to_hex(&commit->object.oid));
1483 if (commit->parents) {
1484 struct commit *parent = commit->parents->item;
1485 if (parse_commit(parent))
1486 return error(_("could not parse parent commit %s"),
1487 oid_to_hex(&parent->object.oid));
1488 ptree_oid = get_commit_tree_oid(parent);
1489 } else {
1490 ptree_oid = the_hash_algo->empty_tree; /* commit is root */
1493 return oideq(ptree_oid, get_commit_tree_oid(commit));
1497 * Should empty commits be allowed? Return status:
1498 * <0: Error in is_index_unchanged(r) or is_original_commit_empty(commit)
1499 * 0: Halt on empty commit
1500 * 1: Allow empty commit
1501 * 2: Drop empty commit
1503 static int allow_empty(struct repository *r,
1504 struct replay_opts *opts,
1505 struct commit *commit)
1507 int index_unchanged, originally_empty;
1510 * Four cases:
1512 * (1) we do not allow empty at all and error out.
1514 * (2) we allow ones that were initially empty, and
1515 * just drop the ones that become empty
1517 * (3) we allow ones that were initially empty, but
1518 * halt for the ones that become empty;
1520 * (4) we allow both.
1522 if (!opts->allow_empty)
1523 return 0; /* let "git commit" barf as necessary */
1525 index_unchanged = is_index_unchanged(r);
1526 if (index_unchanged < 0)
1527 return index_unchanged;
1528 if (!index_unchanged)
1529 return 0; /* we do not have to say --allow-empty */
1531 if (opts->keep_redundant_commits)
1532 return 1;
1534 originally_empty = is_original_commit_empty(commit);
1535 if (originally_empty < 0)
1536 return originally_empty;
1537 if (originally_empty)
1538 return 1;
1539 else if (opts->drop_redundant_commits)
1540 return 2;
1541 else
1542 return 0;
1545 static struct {
1546 char c;
1547 const char *str;
1548 } todo_command_info[] = {
1549 { 'p', "pick" },
1550 { 0, "revert" },
1551 { 'e', "edit" },
1552 { 'r', "reword" },
1553 { 'f', "fixup" },
1554 { 's', "squash" },
1555 { 'x', "exec" },
1556 { 'b', "break" },
1557 { 'l', "label" },
1558 { 't', "reset" },
1559 { 'm', "merge" },
1560 { 0, "noop" },
1561 { 'd', "drop" },
1562 { 0, NULL }
1565 static const char *command_to_string(const enum todo_command command)
1567 if (command < TODO_COMMENT)
1568 return todo_command_info[command].str;
1569 die(_("unknown command: %d"), command);
1572 static char command_to_char(const enum todo_command command)
1574 if (command < TODO_COMMENT)
1575 return todo_command_info[command].c;
1576 return comment_line_char;
1579 static int is_noop(const enum todo_command command)
1581 return TODO_NOOP <= command;
1584 static int is_fixup(enum todo_command command)
1586 return command == TODO_FIXUP || command == TODO_SQUASH;
1589 /* Does this command create a (non-merge) commit? */
1590 static int is_pick_or_similar(enum todo_command command)
1592 switch (command) {
1593 case TODO_PICK:
1594 case TODO_REVERT:
1595 case TODO_EDIT:
1596 case TODO_REWORD:
1597 case TODO_FIXUP:
1598 case TODO_SQUASH:
1599 return 1;
1600 default:
1601 return 0;
1605 static int update_squash_messages(struct repository *r,
1606 enum todo_command command,
1607 struct commit *commit,
1608 struct replay_opts *opts)
1610 struct strbuf buf = STRBUF_INIT;
1611 int res;
1612 const char *message, *body;
1613 const char *encoding = get_commit_output_encoding();
1615 if (opts->current_fixup_count > 0) {
1616 struct strbuf header = STRBUF_INIT;
1617 char *eol;
1619 if (strbuf_read_file(&buf, rebase_path_squash_msg(), 9) <= 0)
1620 return error(_("could not read '%s'"),
1621 rebase_path_squash_msg());
1623 eol = buf.buf[0] != comment_line_char ?
1624 buf.buf : strchrnul(buf.buf, '\n');
1626 strbuf_addf(&header, "%c ", comment_line_char);
1627 strbuf_addf(&header, _("This is a combination of %d commits."),
1628 opts->current_fixup_count + 2);
1629 strbuf_splice(&buf, 0, eol - buf.buf, header.buf, header.len);
1630 strbuf_release(&header);
1631 } else {
1632 struct object_id head;
1633 struct commit *head_commit;
1634 const char *head_message, *body;
1636 if (get_oid("HEAD", &head))
1637 return error(_("need a HEAD to fixup"));
1638 if (!(head_commit = lookup_commit_reference(r, &head)))
1639 return error(_("could not read HEAD"));
1640 if (!(head_message = logmsg_reencode(head_commit, NULL, encoding)))
1641 return error(_("could not read HEAD's commit message"));
1643 find_commit_subject(head_message, &body);
1644 if (write_message(body, strlen(body),
1645 rebase_path_fixup_msg(), 0)) {
1646 unuse_commit_buffer(head_commit, head_message);
1647 return error(_("cannot write '%s'"),
1648 rebase_path_fixup_msg());
1651 strbuf_addf(&buf, "%c ", comment_line_char);
1652 strbuf_addf(&buf, _("This is a combination of %d commits."), 2);
1653 strbuf_addf(&buf, "\n%c ", comment_line_char);
1654 strbuf_addstr(&buf, _("This is the 1st commit message:"));
1655 strbuf_addstr(&buf, "\n\n");
1656 strbuf_addstr(&buf, body);
1658 unuse_commit_buffer(head_commit, head_message);
1661 if (!(message = logmsg_reencode(commit, NULL, encoding)))
1662 return error(_("could not read commit message of %s"),
1663 oid_to_hex(&commit->object.oid));
1664 find_commit_subject(message, &body);
1666 if (command == TODO_SQUASH) {
1667 unlink(rebase_path_fixup_msg());
1668 strbuf_addf(&buf, "\n%c ", comment_line_char);
1669 strbuf_addf(&buf, _("This is the commit message #%d:"),
1670 ++opts->current_fixup_count + 1);
1671 strbuf_addstr(&buf, "\n\n");
1672 strbuf_addstr(&buf, body);
1673 } else if (command == TODO_FIXUP) {
1674 strbuf_addf(&buf, "\n%c ", comment_line_char);
1675 strbuf_addf(&buf, _("The commit message #%d will be skipped:"),
1676 ++opts->current_fixup_count + 1);
1677 strbuf_addstr(&buf, "\n\n");
1678 strbuf_add_commented_lines(&buf, body, strlen(body));
1679 } else
1680 return error(_("unknown command: %d"), command);
1681 unuse_commit_buffer(commit, message);
1683 res = write_message(buf.buf, buf.len, rebase_path_squash_msg(), 0);
1684 strbuf_release(&buf);
1686 if (!res) {
1687 strbuf_addf(&opts->current_fixups, "%s%s %s",
1688 opts->current_fixups.len ? "\n" : "",
1689 command_to_string(command),
1690 oid_to_hex(&commit->object.oid));
1691 res = write_message(opts->current_fixups.buf,
1692 opts->current_fixups.len,
1693 rebase_path_current_fixups(), 0);
1696 return res;
1699 static void flush_rewritten_pending(void)
1701 struct strbuf buf = STRBUF_INIT;
1702 struct object_id newoid;
1703 FILE *out;
1705 if (strbuf_read_file(&buf, rebase_path_rewritten_pending(), (GIT_MAX_HEXSZ + 1) * 2) > 0 &&
1706 !get_oid("HEAD", &newoid) &&
1707 (out = fopen_or_warn(rebase_path_rewritten_list(), "a"))) {
1708 char *bol = buf.buf, *eol;
1710 while (*bol) {
1711 eol = strchrnul(bol, '\n');
1712 fprintf(out, "%.*s %s\n", (int)(eol - bol),
1713 bol, oid_to_hex(&newoid));
1714 if (!*eol)
1715 break;
1716 bol = eol + 1;
1718 fclose(out);
1719 unlink(rebase_path_rewritten_pending());
1721 strbuf_release(&buf);
1724 static void record_in_rewritten(struct object_id *oid,
1725 enum todo_command next_command)
1727 FILE *out = fopen_or_warn(rebase_path_rewritten_pending(), "a");
1729 if (!out)
1730 return;
1732 fprintf(out, "%s\n", oid_to_hex(oid));
1733 fclose(out);
1735 if (!is_fixup(next_command))
1736 flush_rewritten_pending();
1739 static int do_pick_commit(struct repository *r,
1740 enum todo_command command,
1741 struct commit *commit,
1742 struct replay_opts *opts,
1743 int final_fixup, int *check_todo)
1745 unsigned int flags = opts->edit ? EDIT_MSG : 0;
1746 const char *msg_file = opts->edit ? NULL : git_path_merge_msg(r);
1747 struct object_id head;
1748 struct commit *base, *next, *parent;
1749 const char *base_label, *next_label;
1750 char *author = NULL;
1751 struct commit_message msg = { NULL, NULL, NULL, NULL };
1752 struct strbuf msgbuf = STRBUF_INIT;
1753 int res, unborn = 0, reword = 0, allow, drop_commit;
1755 if (opts->no_commit) {
1757 * We do not intend to commit immediately. We just want to
1758 * merge the differences in, so let's compute the tree
1759 * that represents the "current" state for merge-recursive
1760 * to work on.
1762 if (write_index_as_tree(&head, r->index, r->index_file, 0, NULL))
1763 return error(_("your index file is unmerged."));
1764 } else {
1765 unborn = get_oid("HEAD", &head);
1766 /* Do we want to generate a root commit? */
1767 if (is_pick_or_similar(command) && opts->have_squash_onto &&
1768 oideq(&head, &opts->squash_onto)) {
1769 if (is_fixup(command))
1770 return error(_("cannot fixup root commit"));
1771 flags |= CREATE_ROOT_COMMIT;
1772 unborn = 1;
1773 } else if (unborn)
1774 oidcpy(&head, the_hash_algo->empty_tree);
1775 if (index_differs_from(r, unborn ? empty_tree_oid_hex() : "HEAD",
1776 NULL, 0))
1777 return error_dirty_index(r, opts);
1779 discard_index(r->index);
1781 if (!commit->parents)
1782 parent = NULL;
1783 else if (commit->parents->next) {
1784 /* Reverting or cherry-picking a merge commit */
1785 int cnt;
1786 struct commit_list *p;
1788 if (!opts->mainline)
1789 return error(_("commit %s is a merge but no -m option was given."),
1790 oid_to_hex(&commit->object.oid));
1792 for (cnt = 1, p = commit->parents;
1793 cnt != opts->mainline && p;
1794 cnt++)
1795 p = p->next;
1796 if (cnt != opts->mainline || !p)
1797 return error(_("commit %s does not have parent %d"),
1798 oid_to_hex(&commit->object.oid), opts->mainline);
1799 parent = p->item;
1800 } else if (1 < opts->mainline)
1802 * Non-first parent explicitly specified as mainline for
1803 * non-merge commit
1805 return error(_("commit %s does not have parent %d"),
1806 oid_to_hex(&commit->object.oid), opts->mainline);
1807 else
1808 parent = commit->parents->item;
1810 if (get_message(commit, &msg) != 0)
1811 return error(_("cannot get commit message for %s"),
1812 oid_to_hex(&commit->object.oid));
1814 if (opts->allow_ff && !is_fixup(command) &&
1815 ((parent && oideq(&parent->object.oid, &head)) ||
1816 (!parent && unborn))) {
1817 if (is_rebase_i(opts))
1818 write_author_script(msg.message);
1819 res = fast_forward_to(r, &commit->object.oid, &head, unborn,
1820 opts);
1821 if (res || command != TODO_REWORD)
1822 goto leave;
1823 reword = 1;
1824 msg_file = NULL;
1825 goto fast_forward_edit;
1827 if (parent && parse_commit(parent) < 0)
1828 /* TRANSLATORS: The first %s will be a "todo" command like
1829 "revert" or "pick", the second %s a SHA1. */
1830 return error(_("%s: cannot parse parent commit %s"),
1831 command_to_string(command),
1832 oid_to_hex(&parent->object.oid));
1835 * "commit" is an existing commit. We would want to apply
1836 * the difference it introduces since its first parent "prev"
1837 * on top of the current HEAD if we are cherry-pick. Or the
1838 * reverse of it if we are revert.
1841 if (command == TODO_REVERT) {
1842 base = commit;
1843 base_label = msg.label;
1844 next = parent;
1845 next_label = msg.parent_label;
1846 strbuf_addstr(&msgbuf, "Revert \"");
1847 strbuf_addstr(&msgbuf, msg.subject);
1848 strbuf_addstr(&msgbuf, "\"\n\nThis reverts commit ");
1849 strbuf_addstr(&msgbuf, oid_to_hex(&commit->object.oid));
1851 if (commit->parents && commit->parents->next) {
1852 strbuf_addstr(&msgbuf, ", reversing\nchanges made to ");
1853 strbuf_addstr(&msgbuf, oid_to_hex(&parent->object.oid));
1855 strbuf_addstr(&msgbuf, ".\n");
1856 } else {
1857 const char *p;
1859 base = parent;
1860 base_label = msg.parent_label;
1861 next = commit;
1862 next_label = msg.label;
1864 /* Append the commit log message to msgbuf. */
1865 if (find_commit_subject(msg.message, &p))
1866 strbuf_addstr(&msgbuf, p);
1868 if (opts->record_origin) {
1869 strbuf_complete_line(&msgbuf);
1870 if (!has_conforming_footer(&msgbuf, NULL, 0))
1871 strbuf_addch(&msgbuf, '\n');
1872 strbuf_addstr(&msgbuf, cherry_picked_prefix);
1873 strbuf_addstr(&msgbuf, oid_to_hex(&commit->object.oid));
1874 strbuf_addstr(&msgbuf, ")\n");
1876 if (!is_fixup(command))
1877 author = get_author(msg.message);
1880 if (command == TODO_REWORD)
1881 reword = 1;
1882 else if (is_fixup(command)) {
1883 if (update_squash_messages(r, command, commit, opts))
1884 return -1;
1885 flags |= AMEND_MSG;
1886 if (!final_fixup)
1887 msg_file = rebase_path_squash_msg();
1888 else if (file_exists(rebase_path_fixup_msg())) {
1889 flags |= CLEANUP_MSG;
1890 msg_file = rebase_path_fixup_msg();
1891 } else {
1892 const char *dest = git_path_squash_msg(r);
1893 unlink(dest);
1894 if (copy_file(dest, rebase_path_squash_msg(), 0666))
1895 return error(_("could not rename '%s' to '%s'"),
1896 rebase_path_squash_msg(), dest);
1897 unlink(git_path_merge_msg(r));
1898 msg_file = dest;
1899 flags |= EDIT_MSG;
1903 if (opts->signoff && !is_fixup(command))
1904 append_signoff(&msgbuf, 0, 0);
1906 if (is_rebase_i(opts) && write_author_script(msg.message) < 0)
1907 res = -1;
1908 else if (!opts->strategy || !strcmp(opts->strategy, "recursive") || command == TODO_REVERT) {
1909 res = do_recursive_merge(r, base, next, base_label, next_label,
1910 &head, &msgbuf, opts);
1911 if (res < 0)
1912 goto leave;
1914 res |= write_message(msgbuf.buf, msgbuf.len,
1915 git_path_merge_msg(r), 0);
1916 } else {
1917 struct commit_list *common = NULL;
1918 struct commit_list *remotes = NULL;
1920 res = write_message(msgbuf.buf, msgbuf.len,
1921 git_path_merge_msg(r), 0);
1923 commit_list_insert(base, &common);
1924 commit_list_insert(next, &remotes);
1925 res |= try_merge_command(r, opts->strategy,
1926 opts->xopts_nr, (const char **)opts->xopts,
1927 common, oid_to_hex(&head), remotes);
1928 free_commit_list(common);
1929 free_commit_list(remotes);
1931 strbuf_release(&msgbuf);
1934 * If the merge was clean or if it failed due to conflict, we write
1935 * CHERRY_PICK_HEAD for the subsequent invocation of commit to use.
1936 * However, if the merge did not even start, then we don't want to
1937 * write it at all.
1939 if ((command == TODO_PICK || command == TODO_REWORD ||
1940 command == TODO_EDIT) && !opts->no_commit &&
1941 (res == 0 || res == 1) &&
1942 update_ref(NULL, "CHERRY_PICK_HEAD", &commit->object.oid, NULL,
1943 REF_NO_DEREF, UPDATE_REFS_MSG_ON_ERR))
1944 res = -1;
1945 if (command == TODO_REVERT && ((opts->no_commit && res == 0) || res == 1) &&
1946 update_ref(NULL, "REVERT_HEAD", &commit->object.oid, NULL,
1947 REF_NO_DEREF, UPDATE_REFS_MSG_ON_ERR))
1948 res = -1;
1950 if (res) {
1951 error(command == TODO_REVERT
1952 ? _("could not revert %s... %s")
1953 : _("could not apply %s... %s"),
1954 short_commit_name(commit), msg.subject);
1955 print_advice(r, res == 1, opts);
1956 repo_rerere(r, opts->allow_rerere_auto);
1957 goto leave;
1960 drop_commit = 0;
1961 allow = allow_empty(r, opts, commit);
1962 if (allow < 0) {
1963 res = allow;
1964 goto leave;
1965 } else if (allow == 1) {
1966 flags |= ALLOW_EMPTY;
1967 } else if (allow == 2) {
1968 drop_commit = 1;
1969 unlink(git_path_cherry_pick_head(r));
1970 unlink(git_path_merge_msg(r));
1971 fprintf(stderr,
1972 _("dropping %s %s -- patch contents already upstream\n"),
1973 oid_to_hex(&commit->object.oid), msg.subject);
1974 } /* else allow == 0 and there's nothing special to do */
1975 if (!opts->no_commit && !drop_commit) {
1976 if (author || command == TODO_REVERT || (flags & AMEND_MSG))
1977 res = do_commit(r, msg_file, author, opts, flags,
1978 commit? &commit->object.oid : NULL);
1979 else
1980 res = error(_("unable to parse commit author"));
1981 *check_todo = !!(flags & EDIT_MSG);
1982 if (!res && reword) {
1983 fast_forward_edit:
1984 res = run_git_commit(r, NULL, opts, EDIT_MSG |
1985 VERIFY_MSG | AMEND_MSG |
1986 (flags & ALLOW_EMPTY));
1987 *check_todo = 1;
1992 if (!res && final_fixup) {
1993 unlink(rebase_path_fixup_msg());
1994 unlink(rebase_path_squash_msg());
1995 unlink(rebase_path_current_fixups());
1996 strbuf_reset(&opts->current_fixups);
1997 opts->current_fixup_count = 0;
2000 leave:
2001 free_message(commit, &msg);
2002 free(author);
2003 update_abort_safety_file();
2005 return res;
2008 static int prepare_revs(struct replay_opts *opts)
2011 * picking (but not reverting) ranges (but not individual revisions)
2012 * should be done in reverse
2014 if (opts->action == REPLAY_PICK && !opts->revs->no_walk)
2015 opts->revs->reverse ^= 1;
2017 if (prepare_revision_walk(opts->revs))
2018 return error(_("revision walk setup failed"));
2020 return 0;
2023 static int read_and_refresh_cache(struct repository *r,
2024 struct replay_opts *opts)
2026 struct lock_file index_lock = LOCK_INIT;
2027 int index_fd = repo_hold_locked_index(r, &index_lock, 0);
2028 if (repo_read_index(r) < 0) {
2029 rollback_lock_file(&index_lock);
2030 return error(_("git %s: failed to read the index"),
2031 _(action_name(opts)));
2033 refresh_index(r->index, REFRESH_QUIET|REFRESH_UNMERGED, NULL, NULL, NULL);
2034 if (index_fd >= 0) {
2035 if (write_locked_index(r->index, &index_lock,
2036 COMMIT_LOCK | SKIP_IF_UNCHANGED)) {
2037 return error(_("git %s: failed to refresh the index"),
2038 _(action_name(opts)));
2041 return 0;
2044 enum todo_item_flags {
2045 TODO_EDIT_MERGE_MSG = 1
2048 void todo_list_release(struct todo_list *todo_list)
2050 strbuf_release(&todo_list->buf);
2051 FREE_AND_NULL(todo_list->items);
2052 todo_list->nr = todo_list->alloc = 0;
2055 static struct todo_item *append_new_todo(struct todo_list *todo_list)
2057 ALLOC_GROW(todo_list->items, todo_list->nr + 1, todo_list->alloc);
2058 todo_list->total_nr++;
2059 return todo_list->items + todo_list->nr++;
2062 const char *todo_item_get_arg(struct todo_list *todo_list,
2063 struct todo_item *item)
2065 return todo_list->buf.buf + item->arg_offset;
2068 static int is_command(enum todo_command command, const char **bol)
2070 const char *str = todo_command_info[command].str;
2071 const char nick = todo_command_info[command].c;
2072 const char *p = *bol + 1;
2074 return skip_prefix(*bol, str, bol) ||
2075 ((nick && **bol == nick) &&
2076 (*p == ' ' || *p == '\t' || *p == '\n' || *p == '\r' || !*p) &&
2077 (*bol = p));
2080 static int parse_insn_line(struct repository *r, struct todo_item *item,
2081 const char *buf, const char *bol, char *eol)
2083 struct object_id commit_oid;
2084 char *end_of_object_name;
2085 int i, saved, status, padding;
2087 item->flags = 0;
2089 /* left-trim */
2090 bol += strspn(bol, " \t");
2092 if (bol == eol || *bol == '\r' || *bol == comment_line_char) {
2093 item->command = TODO_COMMENT;
2094 item->commit = NULL;
2095 item->arg_offset = bol - buf;
2096 item->arg_len = eol - bol;
2097 return 0;
2100 for (i = 0; i < TODO_COMMENT; i++)
2101 if (is_command(i, &bol)) {
2102 item->command = i;
2103 break;
2105 if (i >= TODO_COMMENT)
2106 return -1;
2108 /* Eat up extra spaces/ tabs before object name */
2109 padding = strspn(bol, " \t");
2110 bol += padding;
2112 if (item->command == TODO_NOOP || item->command == TODO_BREAK) {
2113 if (bol != eol)
2114 return error(_("%s does not accept arguments: '%s'"),
2115 command_to_string(item->command), bol);
2116 item->commit = NULL;
2117 item->arg_offset = bol - buf;
2118 item->arg_len = eol - bol;
2119 return 0;
2122 if (!padding)
2123 return error(_("missing arguments for %s"),
2124 command_to_string(item->command));
2126 if (item->command == TODO_EXEC || item->command == TODO_LABEL ||
2127 item->command == TODO_RESET) {
2128 item->commit = NULL;
2129 item->arg_offset = bol - buf;
2130 item->arg_len = (int)(eol - bol);
2131 return 0;
2134 if (item->command == TODO_MERGE) {
2135 if (skip_prefix(bol, "-C", &bol))
2136 bol += strspn(bol, " \t");
2137 else if (skip_prefix(bol, "-c", &bol)) {
2138 bol += strspn(bol, " \t");
2139 item->flags |= TODO_EDIT_MERGE_MSG;
2140 } else {
2141 item->flags |= TODO_EDIT_MERGE_MSG;
2142 item->commit = NULL;
2143 item->arg_offset = bol - buf;
2144 item->arg_len = (int)(eol - bol);
2145 return 0;
2149 end_of_object_name = (char *) bol + strcspn(bol, " \t\n");
2150 saved = *end_of_object_name;
2151 *end_of_object_name = '\0';
2152 status = get_oid(bol, &commit_oid);
2153 if (status < 0)
2154 error(_("could not parse '%s'"), bol); /* return later */
2155 *end_of_object_name = saved;
2157 bol = end_of_object_name + strspn(end_of_object_name, " \t");
2158 item->arg_offset = bol - buf;
2159 item->arg_len = (int)(eol - bol);
2161 if (status < 0)
2162 return status;
2164 item->commit = lookup_commit_reference(r, &commit_oid);
2165 return item->commit ? 0 : -1;
2168 int sequencer_get_last_command(struct repository *r, enum replay_action *action)
2170 const char *todo_file, *bol;
2171 struct strbuf buf = STRBUF_INIT;
2172 int ret = 0;
2174 todo_file = git_path_todo_file();
2175 if (strbuf_read_file(&buf, todo_file, 0) < 0) {
2176 if (errno == ENOENT || errno == ENOTDIR)
2177 return -1;
2178 else
2179 return error_errno("unable to open '%s'", todo_file);
2181 bol = buf.buf + strspn(buf.buf, " \t\r\n");
2182 if (is_command(TODO_PICK, &bol) && (*bol == ' ' || *bol == '\t'))
2183 *action = REPLAY_PICK;
2184 else if (is_command(TODO_REVERT, &bol) &&
2185 (*bol == ' ' || *bol == '\t'))
2186 *action = REPLAY_REVERT;
2187 else
2188 ret = -1;
2190 strbuf_release(&buf);
2192 return ret;
2195 int todo_list_parse_insn_buffer(struct repository *r, char *buf,
2196 struct todo_list *todo_list)
2198 struct todo_item *item;
2199 char *p = buf, *next_p;
2200 int i, res = 0, fixup_okay = file_exists(rebase_path_done());
2202 todo_list->current = todo_list->nr = 0;
2204 for (i = 1; *p; i++, p = next_p) {
2205 char *eol = strchrnul(p, '\n');
2207 next_p = *eol ? eol + 1 /* skip LF */ : eol;
2209 if (p != eol && eol[-1] == '\r')
2210 eol--; /* strip Carriage Return */
2212 item = append_new_todo(todo_list);
2213 item->offset_in_buf = p - todo_list->buf.buf;
2214 if (parse_insn_line(r, item, buf, p, eol)) {
2215 res = error(_("invalid line %d: %.*s"),
2216 i, (int)(eol - p), p);
2217 item->command = TODO_COMMENT + 1;
2218 item->arg_offset = p - buf;
2219 item->arg_len = (int)(eol - p);
2220 item->commit = NULL;
2223 if (fixup_okay)
2224 ; /* do nothing */
2225 else if (is_fixup(item->command))
2226 return error(_("cannot '%s' without a previous commit"),
2227 command_to_string(item->command));
2228 else if (!is_noop(item->command))
2229 fixup_okay = 1;
2232 return res;
2235 static int count_commands(struct todo_list *todo_list)
2237 int count = 0, i;
2239 for (i = 0; i < todo_list->nr; i++)
2240 if (todo_list->items[i].command != TODO_COMMENT)
2241 count++;
2243 return count;
2246 static int get_item_line_offset(struct todo_list *todo_list, int index)
2248 return index < todo_list->nr ?
2249 todo_list->items[index].offset_in_buf : todo_list->buf.len;
2252 static const char *get_item_line(struct todo_list *todo_list, int index)
2254 return todo_list->buf.buf + get_item_line_offset(todo_list, index);
2257 static int get_item_line_length(struct todo_list *todo_list, int index)
2259 return get_item_line_offset(todo_list, index + 1)
2260 - get_item_line_offset(todo_list, index);
2263 static ssize_t strbuf_read_file_or_whine(struct strbuf *sb, const char *path)
2265 int fd;
2266 ssize_t len;
2268 fd = open(path, O_RDONLY);
2269 if (fd < 0)
2270 return error_errno(_("could not open '%s'"), path);
2271 len = strbuf_read(sb, fd, 0);
2272 close(fd);
2273 if (len < 0)
2274 return error(_("could not read '%s'."), path);
2275 return len;
2278 static int have_finished_the_last_pick(void)
2280 struct strbuf buf = STRBUF_INIT;
2281 const char *eol;
2282 const char *todo_path = git_path_todo_file();
2283 int ret = 0;
2285 if (strbuf_read_file(&buf, todo_path, 0) < 0) {
2286 if (errno == ENOENT) {
2287 return 0;
2288 } else {
2289 error_errno("unable to open '%s'", todo_path);
2290 return 0;
2293 /* If there is only one line then we are done */
2294 eol = strchr(buf.buf, '\n');
2295 if (!eol || !eol[1])
2296 ret = 1;
2298 strbuf_release(&buf);
2300 return ret;
2303 void sequencer_post_commit_cleanup(struct repository *r, int verbose)
2305 struct replay_opts opts = REPLAY_OPTS_INIT;
2306 int need_cleanup = 0;
2308 if (file_exists(git_path_cherry_pick_head(r))) {
2309 if (!unlink(git_path_cherry_pick_head(r)) && verbose)
2310 warning(_("cancelling a cherry picking in progress"));
2311 opts.action = REPLAY_PICK;
2312 need_cleanup = 1;
2315 if (file_exists(git_path_revert_head(r))) {
2316 if (!unlink(git_path_revert_head(r)) && verbose)
2317 warning(_("cancelling a revert in progress"));
2318 opts.action = REPLAY_REVERT;
2319 need_cleanup = 1;
2322 if (!need_cleanup)
2323 return;
2325 if (!have_finished_the_last_pick())
2326 return;
2328 sequencer_remove_state(&opts);
2331 static void todo_list_write_total_nr(struct todo_list *todo_list)
2333 FILE *f = fopen_or_warn(rebase_path_msgtotal(), "w");
2335 if (f) {
2336 fprintf(f, "%d\n", todo_list->total_nr);
2337 fclose(f);
2341 static int read_populate_todo(struct repository *r,
2342 struct todo_list *todo_list,
2343 struct replay_opts *opts)
2345 struct stat st;
2346 const char *todo_file = get_todo_path(opts);
2347 int res;
2349 strbuf_reset(&todo_list->buf);
2350 if (strbuf_read_file_or_whine(&todo_list->buf, todo_file) < 0)
2351 return -1;
2353 res = stat(todo_file, &st);
2354 if (res)
2355 return error(_("could not stat '%s'"), todo_file);
2356 fill_stat_data(&todo_list->stat, &st);
2358 res = todo_list_parse_insn_buffer(r, todo_list->buf.buf, todo_list);
2359 if (res) {
2360 if (is_rebase_i(opts))
2361 return error(_("please fix this using "
2362 "'git rebase --edit-todo'."));
2363 return error(_("unusable instruction sheet: '%s'"), todo_file);
2366 if (!todo_list->nr &&
2367 (!is_rebase_i(opts) || !file_exists(rebase_path_done())))
2368 return error(_("no commits parsed."));
2370 if (!is_rebase_i(opts)) {
2371 enum todo_command valid =
2372 opts->action == REPLAY_PICK ? TODO_PICK : TODO_REVERT;
2373 int i;
2375 for (i = 0; i < todo_list->nr; i++)
2376 if (valid == todo_list->items[i].command)
2377 continue;
2378 else if (valid == TODO_PICK)
2379 return error(_("cannot cherry-pick during a revert."));
2380 else
2381 return error(_("cannot revert during a cherry-pick."));
2384 if (is_rebase_i(opts)) {
2385 struct todo_list done = TODO_LIST_INIT;
2387 if (strbuf_read_file(&done.buf, rebase_path_done(), 0) > 0 &&
2388 !todo_list_parse_insn_buffer(r, done.buf.buf, &done))
2389 todo_list->done_nr = count_commands(&done);
2390 else
2391 todo_list->done_nr = 0;
2393 todo_list->total_nr = todo_list->done_nr
2394 + count_commands(todo_list);
2395 todo_list_release(&done);
2397 todo_list_write_total_nr(todo_list);
2400 return 0;
2403 static int git_config_string_dup(char **dest,
2404 const char *var, const char *value)
2406 if (!value)
2407 return config_error_nonbool(var);
2408 free(*dest);
2409 *dest = xstrdup(value);
2410 return 0;
2413 static int populate_opts_cb(const char *key, const char *value, void *data)
2415 struct replay_opts *opts = data;
2416 int error_flag = 1;
2418 if (!value)
2419 error_flag = 0;
2420 else if (!strcmp(key, "options.no-commit"))
2421 opts->no_commit = git_config_bool_or_int(key, value, &error_flag);
2422 else if (!strcmp(key, "options.edit"))
2423 opts->edit = git_config_bool_or_int(key, value, &error_flag);
2424 else if (!strcmp(key, "options.allow-empty"))
2425 opts->allow_empty =
2426 git_config_bool_or_int(key, value, &error_flag);
2427 else if (!strcmp(key, "options.allow-empty-message"))
2428 opts->allow_empty_message =
2429 git_config_bool_or_int(key, value, &error_flag);
2430 else if (!strcmp(key, "options.keep-redundant-commits"))
2431 opts->keep_redundant_commits =
2432 git_config_bool_or_int(key, value, &error_flag);
2433 else if (!strcmp(key, "options.signoff"))
2434 opts->signoff = git_config_bool_or_int(key, value, &error_flag);
2435 else if (!strcmp(key, "options.record-origin"))
2436 opts->record_origin = git_config_bool_or_int(key, value, &error_flag);
2437 else if (!strcmp(key, "options.allow-ff"))
2438 opts->allow_ff = git_config_bool_or_int(key, value, &error_flag);
2439 else if (!strcmp(key, "options.mainline"))
2440 opts->mainline = git_config_int(key, value);
2441 else if (!strcmp(key, "options.strategy"))
2442 git_config_string_dup(&opts->strategy, key, value);
2443 else if (!strcmp(key, "options.gpg-sign"))
2444 git_config_string_dup(&opts->gpg_sign, key, value);
2445 else if (!strcmp(key, "options.strategy-option")) {
2446 ALLOC_GROW(opts->xopts, opts->xopts_nr + 1, opts->xopts_alloc);
2447 opts->xopts[opts->xopts_nr++] = xstrdup(value);
2448 } else if (!strcmp(key, "options.allow-rerere-auto"))
2449 opts->allow_rerere_auto =
2450 git_config_bool_or_int(key, value, &error_flag) ?
2451 RERERE_AUTOUPDATE : RERERE_NOAUTOUPDATE;
2452 else if (!strcmp(key, "options.default-msg-cleanup")) {
2453 opts->explicit_cleanup = 1;
2454 opts->default_msg_cleanup = get_cleanup_mode(value, 1);
2455 } else
2456 return error(_("invalid key: %s"), key);
2458 if (!error_flag)
2459 return error(_("invalid value for %s: %s"), key, value);
2461 return 0;
2464 void parse_strategy_opts(struct replay_opts *opts, char *raw_opts)
2466 int i;
2467 char *strategy_opts_string = raw_opts;
2469 if (*strategy_opts_string == ' ')
2470 strategy_opts_string++;
2472 opts->xopts_nr = split_cmdline(strategy_opts_string,
2473 (const char ***)&opts->xopts);
2474 for (i = 0; i < opts->xopts_nr; i++) {
2475 const char *arg = opts->xopts[i];
2477 skip_prefix(arg, "--", &arg);
2478 opts->xopts[i] = xstrdup(arg);
2482 static void read_strategy_opts(struct replay_opts *opts, struct strbuf *buf)
2484 strbuf_reset(buf);
2485 if (!read_oneliner(buf, rebase_path_strategy(), 0))
2486 return;
2487 opts->strategy = strbuf_detach(buf, NULL);
2488 if (!read_oneliner(buf, rebase_path_strategy_opts(), 0))
2489 return;
2491 parse_strategy_opts(opts, buf->buf);
2494 static int read_populate_opts(struct replay_opts *opts)
2496 if (is_rebase_i(opts)) {
2497 struct strbuf buf = STRBUF_INIT;
2498 int ret = 0;
2500 if (read_oneliner(&buf, rebase_path_gpg_sign_opt(),
2501 READ_ONELINER_SKIP_IF_EMPTY)) {
2502 if (!starts_with(buf.buf, "-S"))
2503 strbuf_reset(&buf);
2504 else {
2505 free(opts->gpg_sign);
2506 opts->gpg_sign = xstrdup(buf.buf + 2);
2508 strbuf_reset(&buf);
2511 if (read_oneliner(&buf, rebase_path_allow_rerere_autoupdate(),
2512 READ_ONELINER_SKIP_IF_EMPTY)) {
2513 if (!strcmp(buf.buf, "--rerere-autoupdate"))
2514 opts->allow_rerere_auto = RERERE_AUTOUPDATE;
2515 else if (!strcmp(buf.buf, "--no-rerere-autoupdate"))
2516 opts->allow_rerere_auto = RERERE_NOAUTOUPDATE;
2517 strbuf_reset(&buf);
2520 if (file_exists(rebase_path_verbose()))
2521 opts->verbose = 1;
2523 if (file_exists(rebase_path_quiet()))
2524 opts->quiet = 1;
2526 if (file_exists(rebase_path_signoff())) {
2527 opts->allow_ff = 0;
2528 opts->signoff = 1;
2531 if (file_exists(rebase_path_reschedule_failed_exec()))
2532 opts->reschedule_failed_exec = 1;
2534 if (file_exists(rebase_path_drop_redundant_commits()))
2535 opts->drop_redundant_commits = 1;
2537 if (file_exists(rebase_path_keep_redundant_commits()))
2538 opts->keep_redundant_commits = 1;
2540 read_strategy_opts(opts, &buf);
2541 strbuf_reset(&buf);
2543 if (read_oneliner(&opts->current_fixups,
2544 rebase_path_current_fixups(),
2545 READ_ONELINER_SKIP_IF_EMPTY)) {
2546 const char *p = opts->current_fixups.buf;
2547 opts->current_fixup_count = 1;
2548 while ((p = strchr(p, '\n'))) {
2549 opts->current_fixup_count++;
2550 p++;
2554 if (read_oneliner(&buf, rebase_path_squash_onto(), 0)) {
2555 if (get_oid_hex(buf.buf, &opts->squash_onto) < 0) {
2556 ret = error(_("unusable squash-onto"));
2557 goto done_rebase_i;
2559 opts->have_squash_onto = 1;
2562 done_rebase_i:
2563 strbuf_release(&buf);
2564 return ret;
2567 if (!file_exists(git_path_opts_file()))
2568 return 0;
2570 * The function git_parse_source(), called from git_config_from_file(),
2571 * may die() in case of a syntactically incorrect file. We do not care
2572 * about this case, though, because we wrote that file ourselves, so we
2573 * are pretty certain that it is syntactically correct.
2575 if (git_config_from_file(populate_opts_cb, git_path_opts_file(), opts) < 0)
2576 return error(_("malformed options sheet: '%s'"),
2577 git_path_opts_file());
2578 return 0;
2581 static void write_strategy_opts(struct replay_opts *opts)
2583 int i;
2584 struct strbuf buf = STRBUF_INIT;
2586 for (i = 0; i < opts->xopts_nr; ++i)
2587 strbuf_addf(&buf, " --%s", opts->xopts[i]);
2589 write_file(rebase_path_strategy_opts(), "%s\n", buf.buf);
2590 strbuf_release(&buf);
2593 int write_basic_state(struct replay_opts *opts, const char *head_name,
2594 struct commit *onto, const char *orig_head)
2596 if (head_name)
2597 write_file(rebase_path_head_name(), "%s\n", head_name);
2598 if (onto)
2599 write_file(rebase_path_onto(), "%s\n",
2600 oid_to_hex(&onto->object.oid));
2601 if (orig_head)
2602 write_file(rebase_path_orig_head(), "%s\n", orig_head);
2604 if (opts->quiet)
2605 write_file(rebase_path_quiet(), "%s", "");
2606 if (opts->verbose)
2607 write_file(rebase_path_verbose(), "%s", "");
2608 if (opts->strategy)
2609 write_file(rebase_path_strategy(), "%s\n", opts->strategy);
2610 if (opts->xopts_nr > 0)
2611 write_strategy_opts(opts);
2613 if (opts->allow_rerere_auto == RERERE_AUTOUPDATE)
2614 write_file(rebase_path_allow_rerere_autoupdate(), "--rerere-autoupdate\n");
2615 else if (opts->allow_rerere_auto == RERERE_NOAUTOUPDATE)
2616 write_file(rebase_path_allow_rerere_autoupdate(), "--no-rerere-autoupdate\n");
2618 if (opts->gpg_sign)
2619 write_file(rebase_path_gpg_sign_opt(), "-S%s\n", opts->gpg_sign);
2620 if (opts->signoff)
2621 write_file(rebase_path_signoff(), "--signoff\n");
2622 if (opts->drop_redundant_commits)
2623 write_file(rebase_path_drop_redundant_commits(), "%s", "");
2624 if (opts->keep_redundant_commits)
2625 write_file(rebase_path_keep_redundant_commits(), "%s", "");
2626 if (opts->reschedule_failed_exec)
2627 write_file(rebase_path_reschedule_failed_exec(), "%s", "");
2629 return 0;
2632 static int walk_revs_populate_todo(struct todo_list *todo_list,
2633 struct replay_opts *opts)
2635 enum todo_command command = opts->action == REPLAY_PICK ?
2636 TODO_PICK : TODO_REVERT;
2637 const char *command_string = todo_command_info[command].str;
2638 const char *encoding;
2639 struct commit *commit;
2641 if (prepare_revs(opts))
2642 return -1;
2644 encoding = get_log_output_encoding();
2646 while ((commit = get_revision(opts->revs))) {
2647 struct todo_item *item = append_new_todo(todo_list);
2648 const char *commit_buffer = logmsg_reencode(commit, NULL, encoding);
2649 const char *subject;
2650 int subject_len;
2652 item->command = command;
2653 item->commit = commit;
2654 item->arg_offset = 0;
2655 item->arg_len = 0;
2656 item->offset_in_buf = todo_list->buf.len;
2657 subject_len = find_commit_subject(commit_buffer, &subject);
2658 strbuf_addf(&todo_list->buf, "%s %s %.*s\n", command_string,
2659 short_commit_name(commit), subject_len, subject);
2660 unuse_commit_buffer(commit, commit_buffer);
2663 if (!todo_list->nr)
2664 return error(_("empty commit set passed"));
2666 return 0;
2669 static int create_seq_dir(struct repository *r)
2671 enum replay_action action;
2672 const char *in_progress_error = NULL;
2673 const char *in_progress_advice = NULL;
2674 unsigned int advise_skip = file_exists(git_path_revert_head(r)) ||
2675 file_exists(git_path_cherry_pick_head(r));
2677 if (!sequencer_get_last_command(r, &action)) {
2678 switch (action) {
2679 case REPLAY_REVERT:
2680 in_progress_error = _("revert is already in progress");
2681 in_progress_advice =
2682 _("try \"git revert (--continue | %s--abort | --quit)\"");
2683 break;
2684 case REPLAY_PICK:
2685 in_progress_error = _("cherry-pick is already in progress");
2686 in_progress_advice =
2687 _("try \"git cherry-pick (--continue | %s--abort | --quit)\"");
2688 break;
2689 default:
2690 BUG("unexpected action in create_seq_dir");
2693 if (in_progress_error) {
2694 error("%s", in_progress_error);
2695 if (advice_sequencer_in_use)
2696 advise(in_progress_advice,
2697 advise_skip ? "--skip | " : "");
2698 return -1;
2700 if (mkdir(git_path_seq_dir(), 0777) < 0)
2701 return error_errno(_("could not create sequencer directory '%s'"),
2702 git_path_seq_dir());
2704 return 0;
2707 static int save_head(const char *head)
2709 struct lock_file head_lock = LOCK_INIT;
2710 struct strbuf buf = STRBUF_INIT;
2711 int fd;
2712 ssize_t written;
2714 fd = hold_lock_file_for_update(&head_lock, git_path_head_file(), 0);
2715 if (fd < 0)
2716 return error_errno(_("could not lock HEAD"));
2717 strbuf_addf(&buf, "%s\n", head);
2718 written = write_in_full(fd, buf.buf, buf.len);
2719 strbuf_release(&buf);
2720 if (written < 0) {
2721 error_errno(_("could not write to '%s'"), git_path_head_file());
2722 rollback_lock_file(&head_lock);
2723 return -1;
2725 if (commit_lock_file(&head_lock) < 0)
2726 return error(_("failed to finalize '%s'"), git_path_head_file());
2727 return 0;
2730 static int rollback_is_safe(void)
2732 struct strbuf sb = STRBUF_INIT;
2733 struct object_id expected_head, actual_head;
2735 if (strbuf_read_file(&sb, git_path_abort_safety_file(), 0) >= 0) {
2736 strbuf_trim(&sb);
2737 if (get_oid_hex(sb.buf, &expected_head)) {
2738 strbuf_release(&sb);
2739 die(_("could not parse %s"), git_path_abort_safety_file());
2741 strbuf_release(&sb);
2743 else if (errno == ENOENT)
2744 oidclr(&expected_head);
2745 else
2746 die_errno(_("could not read '%s'"), git_path_abort_safety_file());
2748 if (get_oid("HEAD", &actual_head))
2749 oidclr(&actual_head);
2751 return oideq(&actual_head, &expected_head);
2754 static int reset_merge(const struct object_id *oid)
2756 int ret;
2757 struct argv_array argv = ARGV_ARRAY_INIT;
2759 argv_array_pushl(&argv, "reset", "--merge", NULL);
2761 if (!is_null_oid(oid))
2762 argv_array_push(&argv, oid_to_hex(oid));
2764 ret = run_command_v_opt(argv.argv, RUN_GIT_CMD);
2765 argv_array_clear(&argv);
2767 return ret;
2770 static int rollback_single_pick(struct repository *r)
2772 struct object_id head_oid;
2774 if (!file_exists(git_path_cherry_pick_head(r)) &&
2775 !file_exists(git_path_revert_head(r)))
2776 return error(_("no cherry-pick or revert in progress"));
2777 if (read_ref_full("HEAD", 0, &head_oid, NULL))
2778 return error(_("cannot resolve HEAD"));
2779 if (is_null_oid(&head_oid))
2780 return error(_("cannot abort from a branch yet to be born"));
2781 return reset_merge(&head_oid);
2784 static int skip_single_pick(void)
2786 struct object_id head;
2788 if (read_ref_full("HEAD", 0, &head, NULL))
2789 return error(_("cannot resolve HEAD"));
2790 return reset_merge(&head);
2793 int sequencer_rollback(struct repository *r, struct replay_opts *opts)
2795 FILE *f;
2796 struct object_id oid;
2797 struct strbuf buf = STRBUF_INIT;
2798 const char *p;
2800 f = fopen(git_path_head_file(), "r");
2801 if (!f && errno == ENOENT) {
2803 * There is no multiple-cherry-pick in progress.
2804 * If CHERRY_PICK_HEAD or REVERT_HEAD indicates
2805 * a single-cherry-pick in progress, abort that.
2807 return rollback_single_pick(r);
2809 if (!f)
2810 return error_errno(_("cannot open '%s'"), git_path_head_file());
2811 if (strbuf_getline_lf(&buf, f)) {
2812 error(_("cannot read '%s': %s"), git_path_head_file(),
2813 ferror(f) ? strerror(errno) : _("unexpected end of file"));
2814 fclose(f);
2815 goto fail;
2817 fclose(f);
2818 if (parse_oid_hex(buf.buf, &oid, &p) || *p != '\0') {
2819 error(_("stored pre-cherry-pick HEAD file '%s' is corrupt"),
2820 git_path_head_file());
2821 goto fail;
2823 if (is_null_oid(&oid)) {
2824 error(_("cannot abort from a branch yet to be born"));
2825 goto fail;
2828 if (!rollback_is_safe()) {
2829 /* Do not error, just do not rollback */
2830 warning(_("You seem to have moved HEAD. "
2831 "Not rewinding, check your HEAD!"));
2832 } else
2833 if (reset_merge(&oid))
2834 goto fail;
2835 strbuf_release(&buf);
2836 return sequencer_remove_state(opts);
2837 fail:
2838 strbuf_release(&buf);
2839 return -1;
2842 int sequencer_skip(struct repository *r, struct replay_opts *opts)
2844 enum replay_action action = -1;
2845 sequencer_get_last_command(r, &action);
2848 * Check whether the subcommand requested to skip the commit is actually
2849 * in progress and that it's safe to skip the commit.
2851 * opts->action tells us which subcommand requested to skip the commit.
2852 * If the corresponding .git/<ACTION>_HEAD exists, we know that the
2853 * action is in progress and we can skip the commit.
2855 * Otherwise we check that the last instruction was related to the
2856 * particular subcommand we're trying to execute and barf if that's not
2857 * the case.
2859 * Finally we check that the rollback is "safe", i.e., has the HEAD
2860 * moved? In this case, it doesn't make sense to "reset the merge" and
2861 * "skip the commit" as the user already handled this by committing. But
2862 * we'd not want to barf here, instead give advice on how to proceed. We
2863 * only need to check that when .git/<ACTION>_HEAD doesn't exist because
2864 * it gets removed when the user commits, so if it still exists we're
2865 * sure the user can't have committed before.
2867 switch (opts->action) {
2868 case REPLAY_REVERT:
2869 if (!file_exists(git_path_revert_head(r))) {
2870 if (action != REPLAY_REVERT)
2871 return error(_("no revert in progress"));
2872 if (!rollback_is_safe())
2873 goto give_advice;
2875 break;
2876 case REPLAY_PICK:
2877 if (!file_exists(git_path_cherry_pick_head(r))) {
2878 if (action != REPLAY_PICK)
2879 return error(_("no cherry-pick in progress"));
2880 if (!rollback_is_safe())
2881 goto give_advice;
2883 break;
2884 default:
2885 BUG("unexpected action in sequencer_skip");
2888 if (skip_single_pick())
2889 return error(_("failed to skip the commit"));
2890 if (!is_directory(git_path_seq_dir()))
2891 return 0;
2893 return sequencer_continue(r, opts);
2895 give_advice:
2896 error(_("there is nothing to skip"));
2898 if (advice_resolve_conflict) {
2899 advise(_("have you committed already?\n"
2900 "try \"git %s --continue\""),
2901 action == REPLAY_REVERT ? "revert" : "cherry-pick");
2903 return -1;
2906 static int save_todo(struct todo_list *todo_list, struct replay_opts *opts)
2908 struct lock_file todo_lock = LOCK_INIT;
2909 const char *todo_path = get_todo_path(opts);
2910 int next = todo_list->current, offset, fd;
2913 * rebase -i writes "git-rebase-todo" without the currently executing
2914 * command, appending it to "done" instead.
2916 if (is_rebase_i(opts))
2917 next++;
2919 fd = hold_lock_file_for_update(&todo_lock, todo_path, 0);
2920 if (fd < 0)
2921 return error_errno(_("could not lock '%s'"), todo_path);
2922 offset = get_item_line_offset(todo_list, next);
2923 if (write_in_full(fd, todo_list->buf.buf + offset,
2924 todo_list->buf.len - offset) < 0)
2925 return error_errno(_("could not write to '%s'"), todo_path);
2926 if (commit_lock_file(&todo_lock) < 0)
2927 return error(_("failed to finalize '%s'"), todo_path);
2929 if (is_rebase_i(opts) && next > 0) {
2930 const char *done = rebase_path_done();
2931 int fd = open(done, O_CREAT | O_WRONLY | O_APPEND, 0666);
2932 int ret = 0;
2934 if (fd < 0)
2935 return 0;
2936 if (write_in_full(fd, get_item_line(todo_list, next - 1),
2937 get_item_line_length(todo_list, next - 1))
2938 < 0)
2939 ret = error_errno(_("could not write to '%s'"), done);
2940 if (close(fd) < 0)
2941 ret = error_errno(_("failed to finalize '%s'"), done);
2942 return ret;
2944 return 0;
2947 static int save_opts(struct replay_opts *opts)
2949 const char *opts_file = git_path_opts_file();
2950 int res = 0;
2952 if (opts->no_commit)
2953 res |= git_config_set_in_file_gently(opts_file,
2954 "options.no-commit", "true");
2955 if (opts->edit)
2956 res |= git_config_set_in_file_gently(opts_file,
2957 "options.edit", "true");
2958 if (opts->allow_empty)
2959 res |= git_config_set_in_file_gently(opts_file,
2960 "options.allow-empty", "true");
2961 if (opts->allow_empty_message)
2962 res |= git_config_set_in_file_gently(opts_file,
2963 "options.allow-empty-message", "true");
2964 if (opts->keep_redundant_commits)
2965 res |= git_config_set_in_file_gently(opts_file,
2966 "options.keep-redundant-commits", "true");
2967 if (opts->signoff)
2968 res |= git_config_set_in_file_gently(opts_file,
2969 "options.signoff", "true");
2970 if (opts->record_origin)
2971 res |= git_config_set_in_file_gently(opts_file,
2972 "options.record-origin", "true");
2973 if (opts->allow_ff)
2974 res |= git_config_set_in_file_gently(opts_file,
2975 "options.allow-ff", "true");
2976 if (opts->mainline) {
2977 struct strbuf buf = STRBUF_INIT;
2978 strbuf_addf(&buf, "%d", opts->mainline);
2979 res |= git_config_set_in_file_gently(opts_file,
2980 "options.mainline", buf.buf);
2981 strbuf_release(&buf);
2983 if (opts->strategy)
2984 res |= git_config_set_in_file_gently(opts_file,
2985 "options.strategy", opts->strategy);
2986 if (opts->gpg_sign)
2987 res |= git_config_set_in_file_gently(opts_file,
2988 "options.gpg-sign", opts->gpg_sign);
2989 if (opts->xopts) {
2990 int i;
2991 for (i = 0; i < opts->xopts_nr; i++)
2992 res |= git_config_set_multivar_in_file_gently(opts_file,
2993 "options.strategy-option",
2994 opts->xopts[i], "^$", 0);
2996 if (opts->allow_rerere_auto)
2997 res |= git_config_set_in_file_gently(opts_file,
2998 "options.allow-rerere-auto",
2999 opts->allow_rerere_auto == RERERE_AUTOUPDATE ?
3000 "true" : "false");
3002 if (opts->explicit_cleanup)
3003 res |= git_config_set_in_file_gently(opts_file,
3004 "options.default-msg-cleanup",
3005 describe_cleanup_mode(opts->default_msg_cleanup));
3006 return res;
3009 static int make_patch(struct repository *r,
3010 struct commit *commit,
3011 struct replay_opts *opts)
3013 struct strbuf buf = STRBUF_INIT;
3014 struct rev_info log_tree_opt;
3015 const char *subject, *p;
3016 int res = 0;
3018 p = short_commit_name(commit);
3019 if (write_message(p, strlen(p), rebase_path_stopped_sha(), 1) < 0)
3020 return -1;
3021 res |= write_rebase_head(&commit->object.oid);
3023 strbuf_addf(&buf, "%s/patch", get_dir(opts));
3024 memset(&log_tree_opt, 0, sizeof(log_tree_opt));
3025 repo_init_revisions(r, &log_tree_opt, NULL);
3026 log_tree_opt.abbrev = 0;
3027 log_tree_opt.diff = 1;
3028 log_tree_opt.diffopt.output_format = DIFF_FORMAT_PATCH;
3029 log_tree_opt.disable_stdin = 1;
3030 log_tree_opt.no_commit_id = 1;
3031 log_tree_opt.diffopt.file = fopen(buf.buf, "w");
3032 log_tree_opt.diffopt.use_color = GIT_COLOR_NEVER;
3033 if (!log_tree_opt.diffopt.file)
3034 res |= error_errno(_("could not open '%s'"), buf.buf);
3035 else {
3036 res |= log_tree_commit(&log_tree_opt, commit);
3037 fclose(log_tree_opt.diffopt.file);
3039 strbuf_reset(&buf);
3041 strbuf_addf(&buf, "%s/message", get_dir(opts));
3042 if (!file_exists(buf.buf)) {
3043 const char *encoding = get_commit_output_encoding();
3044 const char *commit_buffer = logmsg_reencode(commit, NULL, encoding);
3045 find_commit_subject(commit_buffer, &subject);
3046 res |= write_message(subject, strlen(subject), buf.buf, 1);
3047 unuse_commit_buffer(commit, commit_buffer);
3049 strbuf_release(&buf);
3051 return res;
3054 static int intend_to_amend(void)
3056 struct object_id head;
3057 char *p;
3059 if (get_oid("HEAD", &head))
3060 return error(_("cannot read HEAD"));
3062 p = oid_to_hex(&head);
3063 return write_message(p, strlen(p), rebase_path_amend(), 1);
3066 static int error_with_patch(struct repository *r,
3067 struct commit *commit,
3068 const char *subject, int subject_len,
3069 struct replay_opts *opts,
3070 int exit_code, int to_amend)
3072 if (commit) {
3073 if (make_patch(r, commit, opts))
3074 return -1;
3075 } else if (copy_file(rebase_path_message(),
3076 git_path_merge_msg(r), 0666))
3077 return error(_("unable to copy '%s' to '%s'"),
3078 git_path_merge_msg(r), rebase_path_message());
3080 if (to_amend) {
3081 if (intend_to_amend())
3082 return -1;
3084 fprintf(stderr,
3085 _("You can amend the commit now, with\n"
3086 "\n"
3087 " git commit --amend %s\n"
3088 "\n"
3089 "Once you are satisfied with your changes, run\n"
3090 "\n"
3091 " git rebase --continue\n"),
3092 gpg_sign_opt_quoted(opts));
3093 } else if (exit_code) {
3094 if (commit)
3095 fprintf_ln(stderr, _("Could not apply %s... %.*s"),
3096 short_commit_name(commit), subject_len, subject);
3097 else
3099 * We don't have the hash of the parent so
3100 * just print the line from the todo file.
3102 fprintf_ln(stderr, _("Could not merge %.*s"),
3103 subject_len, subject);
3106 return exit_code;
3109 static int error_failed_squash(struct repository *r,
3110 struct commit *commit,
3111 struct replay_opts *opts,
3112 int subject_len,
3113 const char *subject)
3115 if (copy_file(rebase_path_message(), rebase_path_squash_msg(), 0666))
3116 return error(_("could not copy '%s' to '%s'"),
3117 rebase_path_squash_msg(), rebase_path_message());
3118 unlink(git_path_merge_msg(r));
3119 if (copy_file(git_path_merge_msg(r), rebase_path_message(), 0666))
3120 return error(_("could not copy '%s' to '%s'"),
3121 rebase_path_message(),
3122 git_path_merge_msg(r));
3123 return error_with_patch(r, commit, subject, subject_len, opts, 1, 0);
3126 static int do_exec(struct repository *r, const char *command_line)
3128 struct argv_array child_env = ARGV_ARRAY_INIT;
3129 const char *child_argv[] = { NULL, NULL };
3130 int dirty, status;
3132 fprintf(stderr, _("Executing: %s\n"), command_line);
3133 child_argv[0] = command_line;
3134 argv_array_pushf(&child_env, "GIT_DIR=%s", absolute_path(get_git_dir()));
3135 argv_array_pushf(&child_env, "GIT_WORK_TREE=%s",
3136 absolute_path(get_git_work_tree()));
3137 status = run_command_v_opt_cd_env(child_argv, RUN_USING_SHELL, NULL,
3138 child_env.argv);
3140 /* force re-reading of the cache */
3141 if (discard_index(r->index) < 0 || repo_read_index(r) < 0)
3142 return error(_("could not read index"));
3144 dirty = require_clean_work_tree(r, "rebase", NULL, 1, 1);
3146 if (status) {
3147 warning(_("execution failed: %s\n%s"
3148 "You can fix the problem, and then run\n"
3149 "\n"
3150 " git rebase --continue\n"
3151 "\n"),
3152 command_line,
3153 dirty ? N_("and made changes to the index and/or the "
3154 "working tree\n") : "");
3155 if (status == 127)
3156 /* command not found */
3157 status = 1;
3158 } else if (dirty) {
3159 warning(_("execution succeeded: %s\nbut "
3160 "left changes to the index and/or the working tree\n"
3161 "Commit or stash your changes, and then run\n"
3162 "\n"
3163 " git rebase --continue\n"
3164 "\n"), command_line);
3165 status = 1;
3168 argv_array_clear(&child_env);
3170 return status;
3173 static int safe_append(const char *filename, const char *fmt, ...)
3175 va_list ap;
3176 struct lock_file lock = LOCK_INIT;
3177 int fd = hold_lock_file_for_update(&lock, filename,
3178 LOCK_REPORT_ON_ERROR);
3179 struct strbuf buf = STRBUF_INIT;
3181 if (fd < 0)
3182 return -1;
3184 if (strbuf_read_file(&buf, filename, 0) < 0 && errno != ENOENT) {
3185 error_errno(_("could not read '%s'"), filename);
3186 rollback_lock_file(&lock);
3187 return -1;
3189 strbuf_complete(&buf, '\n');
3190 va_start(ap, fmt);
3191 strbuf_vaddf(&buf, fmt, ap);
3192 va_end(ap);
3194 if (write_in_full(fd, buf.buf, buf.len) < 0) {
3195 error_errno(_("could not write to '%s'"), filename);
3196 strbuf_release(&buf);
3197 rollback_lock_file(&lock);
3198 return -1;
3200 if (commit_lock_file(&lock) < 0) {
3201 strbuf_release(&buf);
3202 rollback_lock_file(&lock);
3203 return error(_("failed to finalize '%s'"), filename);
3206 strbuf_release(&buf);
3207 return 0;
3210 static int do_label(struct repository *r, const char *name, int len)
3212 struct ref_store *refs = get_main_ref_store(r);
3213 struct ref_transaction *transaction;
3214 struct strbuf ref_name = STRBUF_INIT, err = STRBUF_INIT;
3215 struct strbuf msg = STRBUF_INIT;
3216 int ret = 0;
3217 struct object_id head_oid;
3219 if (len == 1 && *name == '#')
3220 return error(_("illegal label name: '%.*s'"), len, name);
3222 strbuf_addf(&ref_name, "refs/rewritten/%.*s", len, name);
3223 strbuf_addf(&msg, "rebase (label) '%.*s'", len, name);
3225 transaction = ref_store_transaction_begin(refs, &err);
3226 if (!transaction) {
3227 error("%s", err.buf);
3228 ret = -1;
3229 } else if (get_oid("HEAD", &head_oid)) {
3230 error(_("could not read HEAD"));
3231 ret = -1;
3232 } else if (ref_transaction_update(transaction, ref_name.buf, &head_oid,
3233 NULL, 0, msg.buf, &err) < 0 ||
3234 ref_transaction_commit(transaction, &err)) {
3235 error("%s", err.buf);
3236 ret = -1;
3238 ref_transaction_free(transaction);
3239 strbuf_release(&err);
3240 strbuf_release(&msg);
3242 if (!ret)
3243 ret = safe_append(rebase_path_refs_to_delete(),
3244 "%s\n", ref_name.buf);
3245 strbuf_release(&ref_name);
3247 return ret;
3250 static const char *reflog_message(struct replay_opts *opts,
3251 const char *sub_action, const char *fmt, ...);
3253 static int do_reset(struct repository *r,
3254 const char *name, int len,
3255 struct replay_opts *opts)
3257 struct strbuf ref_name = STRBUF_INIT;
3258 struct object_id oid;
3259 struct lock_file lock = LOCK_INIT;
3260 struct tree_desc desc;
3261 struct tree *tree;
3262 struct unpack_trees_options unpack_tree_opts;
3263 int ret = 0;
3265 if (repo_hold_locked_index(r, &lock, LOCK_REPORT_ON_ERROR) < 0)
3266 return -1;
3268 if (len == 10 && !strncmp("[new root]", name, len)) {
3269 if (!opts->have_squash_onto) {
3270 const char *hex;
3271 if (commit_tree("", 0, the_hash_algo->empty_tree,
3272 NULL, &opts->squash_onto,
3273 NULL, NULL))
3274 return error(_("writing fake root commit"));
3275 opts->have_squash_onto = 1;
3276 hex = oid_to_hex(&opts->squash_onto);
3277 if (write_message(hex, strlen(hex),
3278 rebase_path_squash_onto(), 0))
3279 return error(_("writing squash-onto"));
3281 oidcpy(&oid, &opts->squash_onto);
3282 } else {
3283 int i;
3285 /* Determine the length of the label */
3286 for (i = 0; i < len; i++)
3287 if (isspace(name[i]))
3288 break;
3289 len = i;
3291 strbuf_addf(&ref_name, "refs/rewritten/%.*s", len, name);
3292 if (get_oid(ref_name.buf, &oid) &&
3293 get_oid(ref_name.buf + strlen("refs/rewritten/"), &oid)) {
3294 error(_("could not read '%s'"), ref_name.buf);
3295 rollback_lock_file(&lock);
3296 strbuf_release(&ref_name);
3297 return -1;
3301 memset(&unpack_tree_opts, 0, sizeof(unpack_tree_opts));
3302 setup_unpack_trees_porcelain(&unpack_tree_opts, "reset");
3303 unpack_tree_opts.head_idx = 1;
3304 unpack_tree_opts.src_index = r->index;
3305 unpack_tree_opts.dst_index = r->index;
3306 unpack_tree_opts.fn = oneway_merge;
3307 unpack_tree_opts.merge = 1;
3308 unpack_tree_opts.update = 1;
3309 init_checkout_metadata(&unpack_tree_opts.meta, name, &oid, NULL);
3311 if (repo_read_index_unmerged(r)) {
3312 rollback_lock_file(&lock);
3313 strbuf_release(&ref_name);
3314 return error_resolve_conflict(_(action_name(opts)));
3317 if (!fill_tree_descriptor(r, &desc, &oid)) {
3318 error(_("failed to find tree of %s"), oid_to_hex(&oid));
3319 rollback_lock_file(&lock);
3320 free((void *)desc.buffer);
3321 strbuf_release(&ref_name);
3322 return -1;
3325 if (unpack_trees(1, &desc, &unpack_tree_opts)) {
3326 rollback_lock_file(&lock);
3327 free((void *)desc.buffer);
3328 strbuf_release(&ref_name);
3329 return -1;
3332 tree = parse_tree_indirect(&oid);
3333 prime_cache_tree(r, r->index, tree);
3335 if (write_locked_index(r->index, &lock, COMMIT_LOCK) < 0)
3336 ret = error(_("could not write index"));
3337 free((void *)desc.buffer);
3339 if (!ret)
3340 ret = update_ref(reflog_message(opts, "reset", "'%.*s'",
3341 len, name), "HEAD", &oid,
3342 NULL, 0, UPDATE_REFS_MSG_ON_ERR);
3344 strbuf_release(&ref_name);
3345 return ret;
3348 static struct commit *lookup_label(const char *label, int len,
3349 struct strbuf *buf)
3351 struct commit *commit;
3353 strbuf_reset(buf);
3354 strbuf_addf(buf, "refs/rewritten/%.*s", len, label);
3355 commit = lookup_commit_reference_by_name(buf->buf);
3356 if (!commit) {
3357 /* fall back to non-rewritten ref or commit */
3358 strbuf_splice(buf, 0, strlen("refs/rewritten/"), "", 0);
3359 commit = lookup_commit_reference_by_name(buf->buf);
3362 if (!commit)
3363 error(_("could not resolve '%s'"), buf->buf);
3365 return commit;
3368 static int do_merge(struct repository *r,
3369 struct commit *commit,
3370 const char *arg, int arg_len,
3371 int flags, struct replay_opts *opts)
3373 int run_commit_flags = (flags & TODO_EDIT_MERGE_MSG) ?
3374 EDIT_MSG | VERIFY_MSG : 0;
3375 struct strbuf ref_name = STRBUF_INIT;
3376 struct commit *head_commit, *merge_commit, *i;
3377 struct commit_list *bases, *j, *reversed = NULL;
3378 struct commit_list *to_merge = NULL, **tail = &to_merge;
3379 const char *strategy = !opts->xopts_nr &&
3380 (!opts->strategy || !strcmp(opts->strategy, "recursive")) ?
3381 NULL : opts->strategy;
3382 struct merge_options o;
3383 int merge_arg_len, oneline_offset, can_fast_forward, ret, k;
3384 static struct lock_file lock;
3385 const char *p;
3387 if (repo_hold_locked_index(r, &lock, LOCK_REPORT_ON_ERROR) < 0) {
3388 ret = -1;
3389 goto leave_merge;
3392 head_commit = lookup_commit_reference_by_name("HEAD");
3393 if (!head_commit) {
3394 ret = error(_("cannot merge without a current revision"));
3395 goto leave_merge;
3399 * For octopus merges, the arg starts with the list of revisions to be
3400 * merged. The list is optionally followed by '#' and the oneline.
3402 merge_arg_len = oneline_offset = arg_len;
3403 for (p = arg; p - arg < arg_len; p += strspn(p, " \t\n")) {
3404 if (!*p)
3405 break;
3406 if (*p == '#' && (!p[1] || isspace(p[1]))) {
3407 p += 1 + strspn(p + 1, " \t\n");
3408 oneline_offset = p - arg;
3409 break;
3411 k = strcspn(p, " \t\n");
3412 if (!k)
3413 continue;
3414 merge_commit = lookup_label(p, k, &ref_name);
3415 if (!merge_commit) {
3416 ret = error(_("unable to parse '%.*s'"), k, p);
3417 goto leave_merge;
3419 tail = &commit_list_insert(merge_commit, tail)->next;
3420 p += k;
3421 merge_arg_len = p - arg;
3424 if (!to_merge) {
3425 ret = error(_("nothing to merge: '%.*s'"), arg_len, arg);
3426 goto leave_merge;
3429 if (opts->have_squash_onto &&
3430 oideq(&head_commit->object.oid, &opts->squash_onto)) {
3432 * When the user tells us to "merge" something into a
3433 * "[new root]", let's simply fast-forward to the merge head.
3435 rollback_lock_file(&lock);
3436 if (to_merge->next)
3437 ret = error(_("octopus merge cannot be executed on "
3438 "top of a [new root]"));
3439 else
3440 ret = fast_forward_to(r, &to_merge->item->object.oid,
3441 &head_commit->object.oid, 0,
3442 opts);
3443 goto leave_merge;
3446 if (commit) {
3447 const char *encoding = get_commit_output_encoding();
3448 const char *message = logmsg_reencode(commit, NULL, encoding);
3449 const char *body;
3450 int len;
3452 if (!message) {
3453 ret = error(_("could not get commit message of '%s'"),
3454 oid_to_hex(&commit->object.oid));
3455 goto leave_merge;
3457 write_author_script(message);
3458 find_commit_subject(message, &body);
3459 len = strlen(body);
3460 ret = write_message(body, len, git_path_merge_msg(r), 0);
3461 unuse_commit_buffer(commit, message);
3462 if (ret) {
3463 error_errno(_("could not write '%s'"),
3464 git_path_merge_msg(r));
3465 goto leave_merge;
3467 } else {
3468 struct strbuf buf = STRBUF_INIT;
3469 int len;
3471 strbuf_addf(&buf, "author %s", git_author_info(0));
3472 write_author_script(buf.buf);
3473 strbuf_reset(&buf);
3475 if (oneline_offset < arg_len) {
3476 p = arg + oneline_offset;
3477 len = arg_len - oneline_offset;
3478 } else {
3479 strbuf_addf(&buf, "Merge %s '%.*s'",
3480 to_merge->next ? "branches" : "branch",
3481 merge_arg_len, arg);
3482 p = buf.buf;
3483 len = buf.len;
3486 ret = write_message(p, len, git_path_merge_msg(r), 0);
3487 strbuf_release(&buf);
3488 if (ret) {
3489 error_errno(_("could not write '%s'"),
3490 git_path_merge_msg(r));
3491 goto leave_merge;
3496 * If HEAD is not identical to the first parent of the original merge
3497 * commit, we cannot fast-forward.
3499 can_fast_forward = opts->allow_ff && commit && commit->parents &&
3500 oideq(&commit->parents->item->object.oid,
3501 &head_commit->object.oid);
3504 * If any merge head is different from the original one, we cannot
3505 * fast-forward.
3507 if (can_fast_forward) {
3508 struct commit_list *p = commit->parents->next;
3510 for (j = to_merge; j && p; j = j->next, p = p->next)
3511 if (!oideq(&j->item->object.oid,
3512 &p->item->object.oid)) {
3513 can_fast_forward = 0;
3514 break;
3517 * If the number of merge heads differs from the original merge
3518 * commit, we cannot fast-forward.
3520 if (j || p)
3521 can_fast_forward = 0;
3524 if (can_fast_forward) {
3525 rollback_lock_file(&lock);
3526 ret = fast_forward_to(r, &commit->object.oid,
3527 &head_commit->object.oid, 0, opts);
3528 if (flags & TODO_EDIT_MERGE_MSG) {
3529 run_commit_flags |= AMEND_MSG;
3530 goto fast_forward_edit;
3532 goto leave_merge;
3535 if (strategy || to_merge->next) {
3536 /* Octopus merge */
3537 struct child_process cmd = CHILD_PROCESS_INIT;
3539 if (read_env_script(&cmd.env_array)) {
3540 const char *gpg_opt = gpg_sign_opt_quoted(opts);
3542 ret = error(_(staged_changes_advice), gpg_opt, gpg_opt);
3543 goto leave_merge;
3546 cmd.git_cmd = 1;
3547 argv_array_push(&cmd.args, "merge");
3548 argv_array_push(&cmd.args, "-s");
3549 if (!strategy)
3550 argv_array_push(&cmd.args, "octopus");
3551 else {
3552 argv_array_push(&cmd.args, strategy);
3553 for (k = 0; k < opts->xopts_nr; k++)
3554 argv_array_pushf(&cmd.args,
3555 "-X%s", opts->xopts[k]);
3557 argv_array_push(&cmd.args, "--no-edit");
3558 argv_array_push(&cmd.args, "--no-ff");
3559 argv_array_push(&cmd.args, "--no-log");
3560 argv_array_push(&cmd.args, "--no-stat");
3561 argv_array_push(&cmd.args, "-F");
3562 argv_array_push(&cmd.args, git_path_merge_msg(r));
3563 if (opts->gpg_sign)
3564 argv_array_push(&cmd.args, opts->gpg_sign);
3566 /* Add the tips to be merged */
3567 for (j = to_merge; j; j = j->next)
3568 argv_array_push(&cmd.args,
3569 oid_to_hex(&j->item->object.oid));
3571 strbuf_release(&ref_name);
3572 unlink(git_path_cherry_pick_head(r));
3573 rollback_lock_file(&lock);
3575 rollback_lock_file(&lock);
3576 ret = run_command(&cmd);
3578 /* force re-reading of the cache */
3579 if (!ret && (discard_index(r->index) < 0 ||
3580 repo_read_index(r) < 0))
3581 ret = error(_("could not read index"));
3582 goto leave_merge;
3585 merge_commit = to_merge->item;
3586 bases = get_merge_bases(head_commit, merge_commit);
3587 if (bases && oideq(&merge_commit->object.oid,
3588 &bases->item->object.oid)) {
3589 ret = 0;
3590 /* skip merging an ancestor of HEAD */
3591 goto leave_merge;
3594 write_message(oid_to_hex(&merge_commit->object.oid), the_hash_algo->hexsz,
3595 git_path_merge_head(r), 0);
3596 write_message("no-ff", 5, git_path_merge_mode(r), 0);
3598 for (j = bases; j; j = j->next)
3599 commit_list_insert(j->item, &reversed);
3600 free_commit_list(bases);
3602 repo_read_index(r);
3603 init_merge_options(&o, r);
3604 o.branch1 = "HEAD";
3605 o.branch2 = ref_name.buf;
3606 o.buffer_output = 2;
3608 ret = merge_recursive(&o, head_commit, merge_commit, reversed, &i);
3609 if (ret <= 0)
3610 fputs(o.obuf.buf, stdout);
3611 strbuf_release(&o.obuf);
3612 if (ret < 0) {
3613 error(_("could not even attempt to merge '%.*s'"),
3614 merge_arg_len, arg);
3615 goto leave_merge;
3618 * The return value of merge_recursive() is 1 on clean, and 0 on
3619 * unclean merge.
3621 * Let's reverse that, so that do_merge() returns 0 upon success and
3622 * 1 upon failed merge (keeping the return value -1 for the cases where
3623 * we will want to reschedule the `merge` command).
3625 ret = !ret;
3627 if (r->index->cache_changed &&
3628 write_locked_index(r->index, &lock, COMMIT_LOCK)) {
3629 ret = error(_("merge: Unable to write new index file"));
3630 goto leave_merge;
3633 rollback_lock_file(&lock);
3634 if (ret)
3635 repo_rerere(r, opts->allow_rerere_auto);
3636 else
3638 * In case of problems, we now want to return a positive
3639 * value (a negative one would indicate that the `merge`
3640 * command needs to be rescheduled).
3642 fast_forward_edit:
3643 ret = !!run_git_commit(r, git_path_merge_msg(r), opts,
3644 run_commit_flags);
3646 leave_merge:
3647 strbuf_release(&ref_name);
3648 rollback_lock_file(&lock);
3649 free_commit_list(to_merge);
3650 return ret;
3653 static int is_final_fixup(struct todo_list *todo_list)
3655 int i = todo_list->current;
3657 if (!is_fixup(todo_list->items[i].command))
3658 return 0;
3660 while (++i < todo_list->nr)
3661 if (is_fixup(todo_list->items[i].command))
3662 return 0;
3663 else if (!is_noop(todo_list->items[i].command))
3664 break;
3665 return 1;
3668 static enum todo_command peek_command(struct todo_list *todo_list, int offset)
3670 int i;
3672 for (i = todo_list->current + offset; i < todo_list->nr; i++)
3673 if (!is_noop(todo_list->items[i].command))
3674 return todo_list->items[i].command;
3676 return -1;
3679 void create_autostash(struct repository *r, const char *path,
3680 const char *default_reflog_action)
3682 struct strbuf buf = STRBUF_INIT;
3683 struct lock_file lock_file = LOCK_INIT;
3684 int fd;
3686 fd = repo_hold_locked_index(r, &lock_file, 0);
3687 refresh_index(r->index, REFRESH_QUIET, NULL, NULL, NULL);
3688 if (0 <= fd)
3689 repo_update_index_if_able(r, &lock_file);
3690 rollback_lock_file(&lock_file);
3692 if (has_unstaged_changes(r, 1) ||
3693 has_uncommitted_changes(r, 1)) {
3694 struct child_process stash = CHILD_PROCESS_INIT;
3695 struct object_id oid;
3697 argv_array_pushl(&stash.args,
3698 "stash", "create", "autostash", NULL);
3699 stash.git_cmd = 1;
3700 stash.no_stdin = 1;
3701 strbuf_reset(&buf);
3702 if (capture_command(&stash, &buf, GIT_MAX_HEXSZ))
3703 die(_("Cannot autostash"));
3704 strbuf_trim_trailing_newline(&buf);
3705 if (get_oid(buf.buf, &oid))
3706 die(_("Unexpected stash response: '%s'"),
3707 buf.buf);
3708 strbuf_reset(&buf);
3709 strbuf_add_unique_abbrev(&buf, &oid, DEFAULT_ABBREV);
3711 if (safe_create_leading_directories_const(path))
3712 die(_("Could not create directory for '%s'"),
3713 path);
3714 write_file(path, "%s", oid_to_hex(&oid));
3715 printf(_("Created autostash: %s\n"), buf.buf);
3716 if (reset_head(r, NULL, "reset --hard",
3717 NULL, RESET_HEAD_HARD, NULL, NULL,
3718 default_reflog_action) < 0)
3719 die(_("could not reset --hard"));
3721 if (discard_index(r->index) < 0 ||
3722 repo_read_index(r) < 0)
3723 die(_("could not read index"));
3725 strbuf_release(&buf);
3728 static int apply_save_autostash_oid(const char *stash_oid, int attempt_apply)
3730 struct child_process child = CHILD_PROCESS_INIT;
3731 int ret = 0;
3733 if (attempt_apply) {
3734 child.git_cmd = 1;
3735 child.no_stdout = 1;
3736 child.no_stderr = 1;
3737 argv_array_push(&child.args, "stash");
3738 argv_array_push(&child.args, "apply");
3739 argv_array_push(&child.args, stash_oid);
3740 ret = run_command(&child);
3743 if (attempt_apply && !ret)
3744 fprintf(stderr, _("Applied autostash.\n"));
3745 else {
3746 struct child_process store = CHILD_PROCESS_INIT;
3748 store.git_cmd = 1;
3749 argv_array_push(&store.args, "stash");
3750 argv_array_push(&store.args, "store");
3751 argv_array_push(&store.args, "-m");
3752 argv_array_push(&store.args, "autostash");
3753 argv_array_push(&store.args, "-q");
3754 argv_array_push(&store.args, stash_oid);
3755 if (run_command(&store))
3756 ret = error(_("cannot store %s"), stash_oid);
3757 else
3758 fprintf(stderr,
3759 _("%s\n"
3760 "Your changes are safe in the stash.\n"
3761 "You can run \"git stash pop\" or"
3762 " \"git stash drop\" at any time.\n"),
3763 attempt_apply ?
3764 _("Applying autostash resulted in conflicts.") :
3765 _("Autostash exists; creating a new stash entry."));
3768 return ret;
3771 static int apply_save_autostash(const char *path, int attempt_apply)
3773 struct strbuf stash_oid = STRBUF_INIT;
3774 int ret = 0;
3776 if (!read_oneliner(&stash_oid, path,
3777 READ_ONELINER_SKIP_IF_EMPTY)) {
3778 strbuf_release(&stash_oid);
3779 return 0;
3781 strbuf_trim(&stash_oid);
3783 ret = apply_save_autostash_oid(stash_oid.buf, attempt_apply);
3785 unlink(path);
3786 strbuf_release(&stash_oid);
3787 return ret;
3790 int save_autostash(const char *path)
3792 return apply_save_autostash(path, 0);
3795 int apply_autostash(const char *path)
3797 return apply_save_autostash(path, 1);
3800 int apply_autostash_oid(const char *stash_oid)
3802 return apply_save_autostash_oid(stash_oid, 1);
3805 static const char *reflog_message(struct replay_opts *opts,
3806 const char *sub_action, const char *fmt, ...)
3808 va_list ap;
3809 static struct strbuf buf = STRBUF_INIT;
3810 char *reflog_action = getenv(GIT_REFLOG_ACTION);
3812 va_start(ap, fmt);
3813 strbuf_reset(&buf);
3814 strbuf_addstr(&buf, reflog_action ? reflog_action : action_name(opts));
3815 if (sub_action)
3816 strbuf_addf(&buf, " (%s)", sub_action);
3817 if (fmt) {
3818 strbuf_addstr(&buf, ": ");
3819 strbuf_vaddf(&buf, fmt, ap);
3821 va_end(ap);
3823 return buf.buf;
3826 static int run_git_checkout(struct repository *r, struct replay_opts *opts,
3827 const char *commit, const char *action)
3829 struct child_process cmd = CHILD_PROCESS_INIT;
3830 int ret;
3832 cmd.git_cmd = 1;
3834 argv_array_push(&cmd.args, "checkout");
3835 argv_array_push(&cmd.args, commit);
3836 argv_array_pushf(&cmd.env_array, GIT_REFLOG_ACTION "=%s", action);
3838 if (opts->verbose)
3839 ret = run_command(&cmd);
3840 else
3841 ret = run_command_silent_on_success(&cmd);
3843 if (!ret)
3844 discard_index(r->index);
3846 return ret;
3849 static int checkout_onto(struct repository *r, struct replay_opts *opts,
3850 const char *onto_name, const struct object_id *onto,
3851 const char *orig_head)
3853 struct object_id oid;
3854 const char *action = reflog_message(opts, "start", "checkout %s", onto_name);
3856 if (get_oid(orig_head, &oid))
3857 return error(_("%s: not a valid OID"), orig_head);
3859 if (run_git_checkout(r, opts, oid_to_hex(onto), action)) {
3860 apply_autostash(rebase_path_autostash());
3861 sequencer_remove_state(opts);
3862 return error(_("could not detach HEAD"));
3865 return update_ref(NULL, "ORIG_HEAD", &oid, NULL, 0, UPDATE_REFS_MSG_ON_ERR);
3868 static int stopped_at_head(struct repository *r)
3870 struct object_id head;
3871 struct commit *commit;
3872 struct commit_message message;
3874 if (get_oid("HEAD", &head) ||
3875 !(commit = lookup_commit(r, &head)) ||
3876 parse_commit(commit) || get_message(commit, &message))
3877 fprintf(stderr, _("Stopped at HEAD\n"));
3878 else {
3879 fprintf(stderr, _("Stopped at %s\n"), message.label);
3880 free_message(commit, &message);
3882 return 0;
3886 static const char rescheduled_advice[] =
3887 N_("Could not execute the todo command\n"
3888 "\n"
3889 " %.*s"
3890 "\n"
3891 "It has been rescheduled; To edit the command before continuing, please\n"
3892 "edit the todo list first:\n"
3893 "\n"
3894 " git rebase --edit-todo\n"
3895 " git rebase --continue\n");
3897 static int pick_commits(struct repository *r,
3898 struct todo_list *todo_list,
3899 struct replay_opts *opts)
3901 int res = 0, reschedule = 0;
3902 char *prev_reflog_action;
3904 /* Note that 0 for 3rd parameter of setenv means set only if not set */
3905 setenv(GIT_REFLOG_ACTION, action_name(opts), 0);
3906 prev_reflog_action = xstrdup(getenv(GIT_REFLOG_ACTION));
3907 if (opts->allow_ff)
3908 assert(!(opts->signoff || opts->no_commit ||
3909 opts->record_origin || opts->edit));
3910 if (read_and_refresh_cache(r, opts))
3911 return -1;
3913 while (todo_list->current < todo_list->nr) {
3914 struct todo_item *item = todo_list->items + todo_list->current;
3915 const char *arg = todo_item_get_arg(todo_list, item);
3916 int check_todo = 0;
3918 if (save_todo(todo_list, opts))
3919 return -1;
3920 if (is_rebase_i(opts)) {
3921 if (item->command != TODO_COMMENT) {
3922 FILE *f = fopen(rebase_path_msgnum(), "w");
3924 todo_list->done_nr++;
3926 if (f) {
3927 fprintf(f, "%d\n", todo_list->done_nr);
3928 fclose(f);
3930 if (!opts->quiet)
3931 fprintf(stderr, _("Rebasing (%d/%d)%s"),
3932 todo_list->done_nr,
3933 todo_list->total_nr,
3934 opts->verbose ? "\n" : "\r");
3936 unlink(rebase_path_message());
3937 unlink(rebase_path_author_script());
3938 unlink(rebase_path_stopped_sha());
3939 unlink(rebase_path_amend());
3940 unlink(git_path_merge_head(r));
3941 delete_ref(NULL, "REBASE_HEAD", NULL, REF_NO_DEREF);
3943 if (item->command == TODO_BREAK) {
3944 if (!opts->verbose)
3945 term_clear_line();
3946 return stopped_at_head(r);
3949 if (item->command <= TODO_SQUASH) {
3950 if (is_rebase_i(opts))
3951 setenv(GIT_REFLOG_ACTION, reflog_message(opts,
3952 command_to_string(item->command), NULL),
3954 res = do_pick_commit(r, item->command, item->commit,
3955 opts, is_final_fixup(todo_list),
3956 &check_todo);
3957 if (is_rebase_i(opts))
3958 setenv(GIT_REFLOG_ACTION, prev_reflog_action, 1);
3959 if (is_rebase_i(opts) && res < 0) {
3960 /* Reschedule */
3961 advise(_(rescheduled_advice),
3962 get_item_line_length(todo_list,
3963 todo_list->current),
3964 get_item_line(todo_list,
3965 todo_list->current));
3966 todo_list->current--;
3967 if (save_todo(todo_list, opts))
3968 return -1;
3970 if (item->command == TODO_EDIT) {
3971 struct commit *commit = item->commit;
3972 if (!res) {
3973 if (!opts->verbose)
3974 term_clear_line();
3975 fprintf(stderr,
3976 _("Stopped at %s... %.*s\n"),
3977 short_commit_name(commit),
3978 item->arg_len, arg);
3980 return error_with_patch(r, commit,
3981 arg, item->arg_len, opts, res, !res);
3983 if (is_rebase_i(opts) && !res)
3984 record_in_rewritten(&item->commit->object.oid,
3985 peek_command(todo_list, 1));
3986 if (res && is_fixup(item->command)) {
3987 if (res == 1)
3988 intend_to_amend();
3989 return error_failed_squash(r, item->commit, opts,
3990 item->arg_len, arg);
3991 } else if (res && is_rebase_i(opts) && item->commit) {
3992 int to_amend = 0;
3993 struct object_id oid;
3996 * If we are rewording and have either
3997 * fast-forwarded already, or are about to
3998 * create a new root commit, we want to amend,
3999 * otherwise we do not.
4001 if (item->command == TODO_REWORD &&
4002 !get_oid("HEAD", &oid) &&
4003 (oideq(&item->commit->object.oid, &oid) ||
4004 (opts->have_squash_onto &&
4005 oideq(&opts->squash_onto, &oid))))
4006 to_amend = 1;
4008 return res | error_with_patch(r, item->commit,
4009 arg, item->arg_len, opts,
4010 res, to_amend);
4012 } else if (item->command == TODO_EXEC) {
4013 char *end_of_arg = (char *)(arg + item->arg_len);
4014 int saved = *end_of_arg;
4016 if (!opts->verbose)
4017 term_clear_line();
4018 *end_of_arg = '\0';
4019 res = do_exec(r, arg);
4020 *end_of_arg = saved;
4022 if (res) {
4023 if (opts->reschedule_failed_exec)
4024 reschedule = 1;
4026 check_todo = 1;
4027 } else if (item->command == TODO_LABEL) {
4028 if ((res = do_label(r, arg, item->arg_len)))
4029 reschedule = 1;
4030 } else if (item->command == TODO_RESET) {
4031 if ((res = do_reset(r, arg, item->arg_len, opts)))
4032 reschedule = 1;
4033 } else if (item->command == TODO_MERGE) {
4034 if ((res = do_merge(r, item->commit,
4035 arg, item->arg_len,
4036 item->flags, opts)) < 0)
4037 reschedule = 1;
4038 else if (item->commit)
4039 record_in_rewritten(&item->commit->object.oid,
4040 peek_command(todo_list, 1));
4041 if (res > 0)
4042 /* failed with merge conflicts */
4043 return error_with_patch(r, item->commit,
4044 arg, item->arg_len,
4045 opts, res, 0);
4046 } else if (!is_noop(item->command))
4047 return error(_("unknown command %d"), item->command);
4049 if (reschedule) {
4050 advise(_(rescheduled_advice),
4051 get_item_line_length(todo_list,
4052 todo_list->current),
4053 get_item_line(todo_list, todo_list->current));
4054 todo_list->current--;
4055 if (save_todo(todo_list, opts))
4056 return -1;
4057 if (item->commit)
4058 return error_with_patch(r,
4059 item->commit,
4060 arg, item->arg_len,
4061 opts, res, 0);
4062 } else if (is_rebase_i(opts) && check_todo && !res) {
4063 struct stat st;
4065 if (stat(get_todo_path(opts), &st)) {
4066 res = error_errno(_("could not stat '%s'"),
4067 get_todo_path(opts));
4068 } else if (match_stat_data(&todo_list->stat, &st)) {
4069 /* Reread the todo file if it has changed. */
4070 todo_list_release(todo_list);
4071 if (read_populate_todo(r, todo_list, opts))
4072 res = -1; /* message was printed */
4073 /* `current` will be incremented below */
4074 todo_list->current = -1;
4078 todo_list->current++;
4079 if (res)
4080 return res;
4083 if (is_rebase_i(opts)) {
4084 struct strbuf head_ref = STRBUF_INIT, buf = STRBUF_INIT;
4085 struct stat st;
4087 /* Stopped in the middle, as planned? */
4088 if (todo_list->current < todo_list->nr)
4089 return 0;
4091 if (read_oneliner(&head_ref, rebase_path_head_name(), 0) &&
4092 starts_with(head_ref.buf, "refs/")) {
4093 const char *msg;
4094 struct object_id head, orig;
4095 int res;
4097 if (get_oid("HEAD", &head)) {
4098 res = error(_("cannot read HEAD"));
4099 cleanup_head_ref:
4100 strbuf_release(&head_ref);
4101 strbuf_release(&buf);
4102 return res;
4104 if (!read_oneliner(&buf, rebase_path_orig_head(), 0) ||
4105 get_oid_hex(buf.buf, &orig)) {
4106 res = error(_("could not read orig-head"));
4107 goto cleanup_head_ref;
4109 strbuf_reset(&buf);
4110 if (!read_oneliner(&buf, rebase_path_onto(), 0)) {
4111 res = error(_("could not read 'onto'"));
4112 goto cleanup_head_ref;
4114 msg = reflog_message(opts, "finish", "%s onto %s",
4115 head_ref.buf, buf.buf);
4116 if (update_ref(msg, head_ref.buf, &head, &orig,
4117 REF_NO_DEREF, UPDATE_REFS_MSG_ON_ERR)) {
4118 res = error(_("could not update %s"),
4119 head_ref.buf);
4120 goto cleanup_head_ref;
4122 msg = reflog_message(opts, "finish", "returning to %s",
4123 head_ref.buf);
4124 if (create_symref("HEAD", head_ref.buf, msg)) {
4125 res = error(_("could not update HEAD to %s"),
4126 head_ref.buf);
4127 goto cleanup_head_ref;
4129 strbuf_reset(&buf);
4132 if (opts->verbose) {
4133 struct rev_info log_tree_opt;
4134 struct object_id orig, head;
4136 memset(&log_tree_opt, 0, sizeof(log_tree_opt));
4137 repo_init_revisions(r, &log_tree_opt, NULL);
4138 log_tree_opt.diff = 1;
4139 log_tree_opt.diffopt.output_format =
4140 DIFF_FORMAT_DIFFSTAT;
4141 log_tree_opt.disable_stdin = 1;
4143 if (read_oneliner(&buf, rebase_path_orig_head(), 0) &&
4144 !get_oid(buf.buf, &orig) &&
4145 !get_oid("HEAD", &head)) {
4146 diff_tree_oid(&orig, &head, "",
4147 &log_tree_opt.diffopt);
4148 log_tree_diff_flush(&log_tree_opt);
4151 flush_rewritten_pending();
4152 if (!stat(rebase_path_rewritten_list(), &st) &&
4153 st.st_size > 0) {
4154 struct child_process child = CHILD_PROCESS_INIT;
4155 const char *post_rewrite_hook =
4156 find_hook("post-rewrite");
4158 child.in = open(rebase_path_rewritten_list(), O_RDONLY);
4159 child.git_cmd = 1;
4160 argv_array_push(&child.args, "notes");
4161 argv_array_push(&child.args, "copy");
4162 argv_array_push(&child.args, "--for-rewrite=rebase");
4163 /* we don't care if this copying failed */
4164 run_command(&child);
4166 if (post_rewrite_hook) {
4167 struct child_process hook = CHILD_PROCESS_INIT;
4169 hook.in = open(rebase_path_rewritten_list(),
4170 O_RDONLY);
4171 hook.stdout_to_stderr = 1;
4172 hook.trace2_hook_name = "post-rewrite";
4173 argv_array_push(&hook.args, post_rewrite_hook);
4174 argv_array_push(&hook.args, "rebase");
4175 /* we don't care if this hook failed */
4176 run_command(&hook);
4179 apply_autostash(rebase_path_autostash());
4181 if (!opts->quiet) {
4182 if (!opts->verbose)
4183 term_clear_line();
4184 fprintf(stderr,
4185 _("Successfully rebased and updated %s.\n"),
4186 head_ref.buf);
4189 strbuf_release(&buf);
4190 strbuf_release(&head_ref);
4194 * Sequence of picks finished successfully; cleanup by
4195 * removing the .git/sequencer directory
4197 return sequencer_remove_state(opts);
4200 static int continue_single_pick(struct repository *r)
4202 const char *argv[] = { "commit", NULL };
4204 if (!file_exists(git_path_cherry_pick_head(r)) &&
4205 !file_exists(git_path_revert_head(r)))
4206 return error(_("no cherry-pick or revert in progress"));
4207 return run_command_v_opt(argv, RUN_GIT_CMD);
4210 static int commit_staged_changes(struct repository *r,
4211 struct replay_opts *opts,
4212 struct todo_list *todo_list)
4214 unsigned int flags = ALLOW_EMPTY | EDIT_MSG;
4215 unsigned int final_fixup = 0, is_clean;
4217 if (has_unstaged_changes(r, 1))
4218 return error(_("cannot rebase: You have unstaged changes."));
4220 is_clean = !has_uncommitted_changes(r, 0);
4222 if (file_exists(rebase_path_amend())) {
4223 struct strbuf rev = STRBUF_INIT;
4224 struct object_id head, to_amend;
4226 if (get_oid("HEAD", &head))
4227 return error(_("cannot amend non-existing commit"));
4228 if (!read_oneliner(&rev, rebase_path_amend(), 0))
4229 return error(_("invalid file: '%s'"), rebase_path_amend());
4230 if (get_oid_hex(rev.buf, &to_amend))
4231 return error(_("invalid contents: '%s'"),
4232 rebase_path_amend());
4233 if (!is_clean && !oideq(&head, &to_amend))
4234 return error(_("\nYou have uncommitted changes in your "
4235 "working tree. Please, commit them\n"
4236 "first and then run 'git rebase "
4237 "--continue' again."));
4239 * When skipping a failed fixup/squash, we need to edit the
4240 * commit message, the current fixup list and count, and if it
4241 * was the last fixup/squash in the chain, we need to clean up
4242 * the commit message and if there was a squash, let the user
4243 * edit it.
4245 if (!is_clean || !opts->current_fixup_count)
4246 ; /* this is not the final fixup */
4247 else if (!oideq(&head, &to_amend) ||
4248 !file_exists(rebase_path_stopped_sha())) {
4249 /* was a final fixup or squash done manually? */
4250 if (!is_fixup(peek_command(todo_list, 0))) {
4251 unlink(rebase_path_fixup_msg());
4252 unlink(rebase_path_squash_msg());
4253 unlink(rebase_path_current_fixups());
4254 strbuf_reset(&opts->current_fixups);
4255 opts->current_fixup_count = 0;
4257 } else {
4258 /* we are in a fixup/squash chain */
4259 const char *p = opts->current_fixups.buf;
4260 int len = opts->current_fixups.len;
4262 opts->current_fixup_count--;
4263 if (!len)
4264 BUG("Incorrect current_fixups:\n%s", p);
4265 while (len && p[len - 1] != '\n')
4266 len--;
4267 strbuf_setlen(&opts->current_fixups, len);
4268 if (write_message(p, len, rebase_path_current_fixups(),
4269 0) < 0)
4270 return error(_("could not write file: '%s'"),
4271 rebase_path_current_fixups());
4274 * If a fixup/squash in a fixup/squash chain failed, the
4275 * commit message is already correct, no need to commit
4276 * it again.
4278 * Only if it is the final command in the fixup/squash
4279 * chain, and only if the chain is longer than a single
4280 * fixup/squash command (which was just skipped), do we
4281 * actually need to re-commit with a cleaned up commit
4282 * message.