Merge branch 'cb/test-lint-cp-a'
[git.git] / sequencer.c
blobb68bca0bef927f0ebb2d8762f658946be7107fcb
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"
36 #define GIT_REFLOG_ACTION "GIT_REFLOG_ACTION"
38 const char sign_off_header[] = "Signed-off-by: ";
39 static const char cherry_picked_prefix[] = "(cherry picked from commit ";
41 GIT_PATH_FUNC(git_path_commit_editmsg, "COMMIT_EDITMSG")
43 GIT_PATH_FUNC(git_path_seq_dir, "sequencer")
45 static GIT_PATH_FUNC(git_path_todo_file, "sequencer/todo")
46 static GIT_PATH_FUNC(git_path_opts_file, "sequencer/opts")
47 static GIT_PATH_FUNC(git_path_head_file, "sequencer/head")
48 static GIT_PATH_FUNC(git_path_abort_safety_file, "sequencer/abort-safety")
50 static GIT_PATH_FUNC(rebase_path, "rebase-merge")
52 * The file containing rebase commands, comments, and empty lines.
53 * This file is created by "git rebase -i" then edited by the user. As
54 * the lines are processed, they are removed from the front of this
55 * file and written to the tail of 'done'.
57 GIT_PATH_FUNC(rebase_path_todo, "rebase-merge/git-rebase-todo")
58 static GIT_PATH_FUNC(rebase_path_todo_backup,
59 "rebase-merge/git-rebase-todo.backup")
62 * The rebase command lines that have already been processed. A line
63 * is moved here when it is first handled, before any associated user
64 * actions.
66 static GIT_PATH_FUNC(rebase_path_done, "rebase-merge/done")
68 * The file to keep track of how many commands were already processed (e.g.
69 * for the prompt).
71 static GIT_PATH_FUNC(rebase_path_msgnum, "rebase-merge/msgnum")
73 * The file to keep track of how many commands are to be processed in total
74 * (e.g. for the prompt).
76 static GIT_PATH_FUNC(rebase_path_msgtotal, "rebase-merge/end")
78 * The commit message that is planned to be used for any changes that
79 * need to be committed following a user interaction.
81 static GIT_PATH_FUNC(rebase_path_message, "rebase-merge/message")
83 * The file into which is accumulated the suggested commit message for
84 * squash/fixup commands. When the first of a series of squash/fixups
85 * is seen, the file is created and the commit message from the
86 * previous commit and from the first squash/fixup commit are written
87 * to it. The commit message for each subsequent squash/fixup commit
88 * is appended to the file as it is processed.
90 static GIT_PATH_FUNC(rebase_path_squash_msg, "rebase-merge/message-squash")
92 * If the current series of squash/fixups has not yet included a squash
93 * command, then this file exists and holds the commit message of the
94 * original "pick" commit. (If the series ends without a "squash"
95 * command, then this can be used as the commit message of the combined
96 * commit without opening the editor.)
98 static GIT_PATH_FUNC(rebase_path_fixup_msg, "rebase-merge/message-fixup")
100 * This file contains the list fixup/squash commands that have been
101 * accumulated into message-fixup or message-squash so far.
103 static GIT_PATH_FUNC(rebase_path_current_fixups, "rebase-merge/current-fixups")
105 * A script to set the GIT_AUTHOR_NAME, GIT_AUTHOR_EMAIL, and
106 * GIT_AUTHOR_DATE that will be used for the commit that is currently
107 * being rebased.
109 static GIT_PATH_FUNC(rebase_path_author_script, "rebase-merge/author-script")
111 * When an "edit" rebase command is being processed, the SHA1 of the
112 * commit to be edited is recorded in this file. When "git rebase
113 * --continue" is executed, if there are any staged changes then they
114 * will be amended to the HEAD commit, but only provided the HEAD
115 * commit is still the commit to be edited. When any other rebase
116 * command is processed, this file is deleted.
118 static GIT_PATH_FUNC(rebase_path_amend, "rebase-merge/amend")
120 * When we stop at a given patch via the "edit" command, this file contains
121 * the abbreviated commit name of the corresponding patch.
123 static GIT_PATH_FUNC(rebase_path_stopped_sha, "rebase-merge/stopped-sha")
125 * For the post-rewrite hook, we make a list of rewritten commits and
126 * their new sha1s. The rewritten-pending list keeps the sha1s of
127 * commits that have been processed, but not committed yet,
128 * e.g. because they are waiting for a 'squash' command.
130 static GIT_PATH_FUNC(rebase_path_rewritten_list, "rebase-merge/rewritten-list")
131 static GIT_PATH_FUNC(rebase_path_rewritten_pending,
132 "rebase-merge/rewritten-pending")
135 * The path of the file containig the OID of the "squash onto" commit, i.e.
136 * the dummy commit used for `reset [new root]`.
138 static GIT_PATH_FUNC(rebase_path_squash_onto, "rebase-merge/squash-onto")
141 * The path of the file listing refs that need to be deleted after the rebase
142 * finishes. This is used by the `label` command to record the need for cleanup.
144 static GIT_PATH_FUNC(rebase_path_refs_to_delete, "rebase-merge/refs-to-delete")
147 * The following files are written by git-rebase just after parsing the
148 * command-line.
150 static GIT_PATH_FUNC(rebase_path_gpg_sign_opt, "rebase-merge/gpg_sign_opt")
151 static GIT_PATH_FUNC(rebase_path_orig_head, "rebase-merge/orig-head")
152 static GIT_PATH_FUNC(rebase_path_verbose, "rebase-merge/verbose")
153 static GIT_PATH_FUNC(rebase_path_signoff, "rebase-merge/signoff")
154 static GIT_PATH_FUNC(rebase_path_head_name, "rebase-merge/head-name")
155 static GIT_PATH_FUNC(rebase_path_onto, "rebase-merge/onto")
156 static GIT_PATH_FUNC(rebase_path_autostash, "rebase-merge/autostash")
157 static GIT_PATH_FUNC(rebase_path_strategy, "rebase-merge/strategy")
158 static GIT_PATH_FUNC(rebase_path_strategy_opts, "rebase-merge/strategy_opts")
159 static GIT_PATH_FUNC(rebase_path_allow_rerere_autoupdate, "rebase-merge/allow_rerere_autoupdate")
160 static GIT_PATH_FUNC(rebase_path_quiet, "rebase-merge/quiet")
162 static int git_sequencer_config(const char *k, const char *v, void *cb)
164 struct replay_opts *opts = cb;
165 int status;
167 if (!strcmp(k, "commit.cleanup")) {
168 const char *s;
170 status = git_config_string(&s, k, v);
171 if (status)
172 return status;
174 if (!strcmp(s, "verbatim"))
175 opts->default_msg_cleanup = COMMIT_MSG_CLEANUP_NONE;
176 else if (!strcmp(s, "whitespace"))
177 opts->default_msg_cleanup = COMMIT_MSG_CLEANUP_SPACE;
178 else if (!strcmp(s, "strip"))
179 opts->default_msg_cleanup = COMMIT_MSG_CLEANUP_ALL;
180 else if (!strcmp(s, "scissors"))
181 opts->default_msg_cleanup = COMMIT_MSG_CLEANUP_SPACE;
182 else
183 warning(_("invalid commit message cleanup mode '%s'"),
186 free((char *)s);
187 return status;
190 if (!strcmp(k, "commit.gpgsign")) {
191 opts->gpg_sign = git_config_bool(k, v) ? xstrdup("") : NULL;
192 return 0;
195 status = git_gpg_config(k, v, NULL);
196 if (status)
197 return status;
199 return git_diff_basic_config(k, v, NULL);
202 void sequencer_init_config(struct replay_opts *opts)
204 opts->default_msg_cleanup = COMMIT_MSG_CLEANUP_NONE;
205 git_config(git_sequencer_config, opts);
208 static inline int is_rebase_i(const struct replay_opts *opts)
210 return opts->action == REPLAY_INTERACTIVE_REBASE;
213 static const char *get_dir(const struct replay_opts *opts)
215 if (is_rebase_i(opts))
216 return rebase_path();
217 return git_path_seq_dir();
220 static const char *get_todo_path(const struct replay_opts *opts)
222 if (is_rebase_i(opts))
223 return rebase_path_todo();
224 return git_path_todo_file();
228 * Returns 0 for non-conforming footer
229 * Returns 1 for conforming footer
230 * Returns 2 when sob exists within conforming footer
231 * Returns 3 when sob exists within conforming footer as last entry
233 static int has_conforming_footer(struct strbuf *sb, struct strbuf *sob,
234 size_t ignore_footer)
236 struct process_trailer_options opts = PROCESS_TRAILER_OPTIONS_INIT;
237 struct trailer_info info;
238 size_t i;
239 int found_sob = 0, found_sob_last = 0;
241 opts.no_divider = 1;
243 trailer_info_get(&info, sb->buf, &opts);
245 if (info.trailer_start == info.trailer_end)
246 return 0;
248 for (i = 0; i < info.trailer_nr; i++)
249 if (sob && !strncmp(info.trailers[i], sob->buf, sob->len)) {
250 found_sob = 1;
251 if (i == info.trailer_nr - 1)
252 found_sob_last = 1;
255 trailer_info_release(&info);
257 if (found_sob_last)
258 return 3;
259 if (found_sob)
260 return 2;
261 return 1;
264 static const char *gpg_sign_opt_quoted(struct replay_opts *opts)
266 static struct strbuf buf = STRBUF_INIT;
268 strbuf_reset(&buf);
269 if (opts->gpg_sign)
270 sq_quotef(&buf, "-S%s", opts->gpg_sign);
271 return buf.buf;
274 int sequencer_remove_state(struct replay_opts *opts)
276 struct strbuf buf = STRBUF_INIT;
277 int i;
279 if (is_rebase_i(opts) &&
280 strbuf_read_file(&buf, rebase_path_refs_to_delete(), 0) > 0) {
281 char *p = buf.buf;
282 while (*p) {
283 char *eol = strchr(p, '\n');
284 if (eol)
285 *eol = '\0';
286 if (delete_ref("(rebase -i) cleanup", p, NULL, 0) < 0)
287 warning(_("could not delete '%s'"), p);
288 if (!eol)
289 break;
290 p = eol + 1;
294 free(opts->gpg_sign);
295 free(opts->strategy);
296 for (i = 0; i < opts->xopts_nr; i++)
297 free(opts->xopts[i]);
298 free(opts->xopts);
299 strbuf_release(&opts->current_fixups);
301 strbuf_reset(&buf);
302 strbuf_addstr(&buf, get_dir(opts));
303 remove_dir_recursively(&buf, 0);
304 strbuf_release(&buf);
306 return 0;
309 static const char *action_name(const struct replay_opts *opts)
311 switch (opts->action) {
312 case REPLAY_REVERT:
313 return N_("revert");
314 case REPLAY_PICK:
315 return N_("cherry-pick");
316 case REPLAY_INTERACTIVE_REBASE:
317 return N_("rebase -i");
319 die(_("unknown action: %d"), opts->action);
322 struct commit_message {
323 char *parent_label;
324 char *label;
325 char *subject;
326 const char *message;
329 static const char *short_commit_name(struct commit *commit)
331 return find_unique_abbrev(&commit->object.oid, DEFAULT_ABBREV);
334 static int get_message(struct commit *commit, struct commit_message *out)
336 const char *abbrev, *subject;
337 int subject_len;
339 out->message = logmsg_reencode(commit, NULL, get_commit_output_encoding());
340 abbrev = short_commit_name(commit);
342 subject_len = find_commit_subject(out->message, &subject);
344 out->subject = xmemdupz(subject, subject_len);
345 out->label = xstrfmt("%s... %s", abbrev, out->subject);
346 out->parent_label = xstrfmt("parent of %s", out->label);
348 return 0;
351 static void free_message(struct commit *commit, struct commit_message *msg)
353 free(msg->parent_label);
354 free(msg->label);
355 free(msg->subject);
356 unuse_commit_buffer(commit, msg->message);
359 static void print_advice(struct repository *r, int show_hint,
360 struct replay_opts *opts)
362 char *msg = getenv("GIT_CHERRY_PICK_HELP");
364 if (msg) {
365 fprintf(stderr, "%s\n", msg);
367 * A conflict has occurred but the porcelain
368 * (typically rebase --interactive) wants to take care
369 * of the commit itself so remove CHERRY_PICK_HEAD
371 unlink(git_path_cherry_pick_head(r));
372 return;
375 if (show_hint) {
376 if (opts->no_commit)
377 advise(_("after resolving the conflicts, mark the corrected paths\n"
378 "with 'git add <paths>' or 'git rm <paths>'"));
379 else
380 advise(_("after resolving the conflicts, mark the corrected paths\n"
381 "with 'git add <paths>' or 'git rm <paths>'\n"
382 "and commit the result with 'git commit'"));
386 int write_message(const void *buf, size_t len, const char *filename,
387 int append_eol)
389 struct lock_file msg_file = LOCK_INIT;
391 int msg_fd = hold_lock_file_for_update(&msg_file, filename, 0);
392 if (msg_fd < 0)
393 return error_errno(_("could not lock '%s'"), filename);
394 if (write_in_full(msg_fd, buf, len) < 0) {
395 error_errno(_("could not write to '%s'"), filename);
396 rollback_lock_file(&msg_file);
397 return -1;
399 if (append_eol && write(msg_fd, "\n", 1) < 0) {
400 error_errno(_("could not write eol to '%s'"), filename);
401 rollback_lock_file(&msg_file);
402 return -1;
404 if (commit_lock_file(&msg_file) < 0)
405 return error(_("failed to finalize '%s'"), filename);
407 return 0;
411 * Reads a file that was presumably written by a shell script, i.e. with an
412 * end-of-line marker that needs to be stripped.
414 * Note that only the last end-of-line marker is stripped, consistent with the
415 * behavior of "$(cat path)" in a shell script.
417 * Returns 1 if the file was read, 0 if it could not be read or does not exist.
419 static int read_oneliner(struct strbuf *buf,
420 const char *path, int skip_if_empty)
422 int orig_len = buf->len;
424 if (!file_exists(path))
425 return 0;
427 if (strbuf_read_file(buf, path, 0) < 0) {
428 warning_errno(_("could not read '%s'"), path);
429 return 0;
432 if (buf->len > orig_len && buf->buf[buf->len - 1] == '\n') {
433 if (--buf->len > orig_len && buf->buf[buf->len - 1] == '\r')
434 --buf->len;
435 buf->buf[buf->len] = '\0';
438 if (skip_if_empty && buf->len == orig_len)
439 return 0;
441 return 1;
444 static struct tree *empty_tree(struct repository *r)
446 return lookup_tree(r, the_hash_algo->empty_tree);
449 static int error_dirty_index(struct index_state *istate, struct replay_opts *opts)
451 if (read_index_unmerged(istate))
452 return error_resolve_conflict(_(action_name(opts)));
454 error(_("your local changes would be overwritten by %s."),
455 _(action_name(opts)));
457 if (advice_commit_before_merge)
458 advise(_("commit your changes or stash them to proceed."));
459 return -1;
462 static void update_abort_safety_file(void)
464 struct object_id head;
466 /* Do nothing on a single-pick */
467 if (!file_exists(git_path_seq_dir()))
468 return;
470 if (!get_oid("HEAD", &head))
471 write_file(git_path_abort_safety_file(), "%s", oid_to_hex(&head));
472 else
473 write_file(git_path_abort_safety_file(), "%s", "");
476 static int fast_forward_to(struct repository *r,
477 const struct object_id *to,
478 const struct object_id *from,
479 int unborn,
480 struct replay_opts *opts)
482 struct ref_transaction *transaction;
483 struct strbuf sb = STRBUF_INIT;
484 struct strbuf err = STRBUF_INIT;
486 read_index(r->index);
487 if (checkout_fast_forward(r, from, to, 1))
488 return -1; /* the callee should have complained already */
490 strbuf_addf(&sb, _("%s: fast-forward"), _(action_name(opts)));
492 transaction = ref_transaction_begin(&err);
493 if (!transaction ||
494 ref_transaction_update(transaction, "HEAD",
495 to, unborn && !is_rebase_i(opts) ?
496 &null_oid : from,
497 0, sb.buf, &err) ||
498 ref_transaction_commit(transaction, &err)) {
499 ref_transaction_free(transaction);
500 error("%s", err.buf);
501 strbuf_release(&sb);
502 strbuf_release(&err);
503 return -1;
506 strbuf_release(&sb);
507 strbuf_release(&err);
508 ref_transaction_free(transaction);
509 update_abort_safety_file();
510 return 0;
513 void append_conflicts_hint(struct index_state *istate,
514 struct strbuf *msgbuf)
516 int i;
518 strbuf_addch(msgbuf, '\n');
519 strbuf_commented_addf(msgbuf, "Conflicts:\n");
520 for (i = 0; i < istate->cache_nr;) {
521 const struct cache_entry *ce = istate->cache[i++];
522 if (ce_stage(ce)) {
523 strbuf_commented_addf(msgbuf, "\t%s\n", ce->name);
524 while (i < istate->cache_nr &&
525 !strcmp(ce->name, istate->cache[i]->name))
526 i++;
531 static int do_recursive_merge(struct repository *r,
532 struct commit *base, struct commit *next,
533 const char *base_label, const char *next_label,
534 struct object_id *head, struct strbuf *msgbuf,
535 struct replay_opts *opts)
537 struct merge_options o;
538 struct tree *result, *next_tree, *base_tree, *head_tree;
539 int clean;
540 char **xopt;
541 struct lock_file index_lock = LOCK_INIT;
543 if (hold_locked_index(&index_lock, LOCK_REPORT_ON_ERROR) < 0)
544 return -1;
546 read_index(r->index);
548 init_merge_options(&o);
549 o.ancestor = base ? base_label : "(empty tree)";
550 o.branch1 = "HEAD";
551 o.branch2 = next ? next_label : "(empty tree)";
552 if (is_rebase_i(opts))
553 o.buffer_output = 2;
554 o.show_rename_progress = 1;
556 head_tree = parse_tree_indirect(head);
557 next_tree = next ? get_commit_tree(next) : empty_tree(r);
558 base_tree = base ? get_commit_tree(base) : empty_tree(r);
560 for (xopt = opts->xopts; xopt != opts->xopts + opts->xopts_nr; xopt++)
561 parse_merge_opt(&o, *xopt);
563 clean = merge_trees(&o,
564 head_tree,
565 next_tree, base_tree, &result);
566 if (is_rebase_i(opts) && clean <= 0)
567 fputs(o.obuf.buf, stdout);
568 strbuf_release(&o.obuf);
569 diff_warn_rename_limit("merge.renamelimit", o.needed_rename_limit, 0);
570 if (clean < 0) {
571 rollback_lock_file(&index_lock);
572 return clean;
575 if (write_locked_index(r->index, &index_lock,
576 COMMIT_LOCK | SKIP_IF_UNCHANGED))
578 * TRANSLATORS: %s will be "revert", "cherry-pick" or
579 * "rebase -i".
581 return error(_("%s: Unable to write new index file"),
582 _(action_name(opts)));
584 if (!clean)
585 append_conflicts_hint(r->index, msgbuf);
587 return !clean;
590 static struct object_id *get_cache_tree_oid(struct index_state *istate)
592 if (!istate->cache_tree)
593 istate->cache_tree = cache_tree();
595 if (!cache_tree_fully_valid(istate->cache_tree))
596 if (cache_tree_update(istate, 0)) {
597 error(_("unable to update cache tree"));
598 return NULL;
601 return &istate->cache_tree->oid;
604 static int is_index_unchanged(struct repository *r)
606 struct object_id head_oid, *cache_tree_oid;
607 struct commit *head_commit;
608 struct index_state *istate = r->index;
610 if (!resolve_ref_unsafe("HEAD", RESOLVE_REF_READING, &head_oid, NULL))
611 return error(_("could not resolve HEAD commit"));
613 head_commit = lookup_commit(r, &head_oid);
616 * If head_commit is NULL, check_commit, called from
617 * lookup_commit, would have indicated that head_commit is not
618 * a commit object already. parse_commit() will return failure
619 * without further complaints in such a case. Otherwise, if
620 * the commit is invalid, parse_commit() will complain. So
621 * there is nothing for us to say here. Just return failure.
623 if (parse_commit(head_commit))
624 return -1;
626 if (!(cache_tree_oid = get_cache_tree_oid(istate)))
627 return -1;
629 return oideq(cache_tree_oid, get_commit_tree_oid(head_commit));
632 static int write_author_script(const char *message)
634 struct strbuf buf = STRBUF_INIT;
635 const char *eol;
636 int res;
638 for (;;)
639 if (!*message || starts_with(message, "\n")) {
640 missing_author:
641 /* Missing 'author' line? */
642 unlink(rebase_path_author_script());
643 return 0;
644 } else if (skip_prefix(message, "author ", &message))
645 break;
646 else if ((eol = strchr(message, '\n')))
647 message = eol + 1;
648 else
649 goto missing_author;
651 strbuf_addstr(&buf, "GIT_AUTHOR_NAME='");
652 while (*message && *message != '\n' && *message != '\r')
653 if (skip_prefix(message, " <", &message))
654 break;
655 else if (*message != '\'')
656 strbuf_addch(&buf, *(message++));
657 else
658 strbuf_addf(&buf, "'\\%c'", *(message++));
659 strbuf_addstr(&buf, "'\nGIT_AUTHOR_EMAIL='");
660 while (*message && *message != '\n' && *message != '\r')
661 if (skip_prefix(message, "> ", &message))
662 break;
663 else if (*message != '\'')
664 strbuf_addch(&buf, *(message++));
665 else
666 strbuf_addf(&buf, "'\\%c'", *(message++));
667 strbuf_addstr(&buf, "'\nGIT_AUTHOR_DATE='@");
668 while (*message && *message != '\n' && *message != '\r')
669 if (*message != '\'')
670 strbuf_addch(&buf, *(message++));
671 else
672 strbuf_addf(&buf, "'\\%c'", *(message++));
673 strbuf_addch(&buf, '\'');
674 res = write_message(buf.buf, buf.len, rebase_path_author_script(), 1);
675 strbuf_release(&buf);
676 return res;
680 * Take a series of KEY='VALUE' lines where VALUE part is
681 * sq-quoted, and append <KEY, VALUE> at the end of the string list
683 static int parse_key_value_squoted(char *buf, struct string_list *list)
685 while (*buf) {
686 struct string_list_item *item;
687 char *np;
688 char *cp = strchr(buf, '=');
689 if (!cp) {
690 np = strchrnul(buf, '\n');
691 return error(_("no key present in '%.*s'"),
692 (int) (np - buf), buf);
694 np = strchrnul(cp, '\n');
695 *cp++ = '\0';
696 item = string_list_append(list, buf);
698 buf = np + (*np == '\n');
699 *np = '\0';
700 cp = sq_dequote(cp);
701 if (!cp)
702 return error(_("unable to dequote value of '%s'"),
703 item->string);
704 item->util = xstrdup(cp);
706 return 0;
710 * Reads and parses the state directory's "author-script" file, and sets name,
711 * email and date accordingly.
712 * Returns 0 on success, -1 if the file could not be parsed.
714 * The author script is of the format:
716 * GIT_AUTHOR_NAME='$author_name'
717 * GIT_AUTHOR_EMAIL='$author_email'
718 * GIT_AUTHOR_DATE='$author_date'
720 * where $author_name, $author_email and $author_date are quoted. We are strict
721 * with our parsing, as the file was meant to be eval'd in the old
722 * git-am.sh/git-rebase--interactive.sh scripts, and thus if the file differs
723 * from what this function expects, it is better to bail out than to do
724 * something that the user does not expect.
726 int read_author_script(const char *path, char **name, char **email, char **date,
727 int allow_missing)
729 struct strbuf buf = STRBUF_INIT;
730 struct string_list kv = STRING_LIST_INIT_DUP;
731 int retval = -1; /* assume failure */
732 int i, name_i = -2, email_i = -2, date_i = -2, err = 0;
734 if (strbuf_read_file(&buf, path, 256) <= 0) {
735 strbuf_release(&buf);
736 if (errno == ENOENT && allow_missing)
737 return 0;
738 else
739 return error_errno(_("could not open '%s' for reading"),
740 path);
743 if (parse_key_value_squoted(buf.buf, &kv))
744 goto finish;
746 for (i = 0; i < kv.nr; i++) {
747 if (!strcmp(kv.items[i].string, "GIT_AUTHOR_NAME")) {
748 if (name_i != -2)
749 name_i = error(_("'GIT_AUTHOR_NAME' already given"));
750 else
751 name_i = i;
752 } else if (!strcmp(kv.items[i].string, "GIT_AUTHOR_EMAIL")) {
753 if (email_i != -2)
754 email_i = error(_("'GIT_AUTHOR_EMAIL' already given"));
755 else
756 email_i = i;
757 } else if (!strcmp(kv.items[i].string, "GIT_AUTHOR_DATE")) {
758 if (date_i != -2)
759 date_i = error(_("'GIT_AUTHOR_DATE' already given"));
760 else
761 date_i = i;
762 } else {
763 err = error(_("unknown variable '%s'"),
764 kv.items[i].string);
767 if (name_i == -2)
768 error(_("missing 'GIT_AUTHOR_NAME'"));
769 if (email_i == -2)
770 error(_("missing 'GIT_AUTHOR_EMAIL'"));
771 if (date_i == -2)
772 error(_("missing 'GIT_AUTHOR_DATE'"));
773 if (date_i < 0 || email_i < 0 || date_i < 0 || err)
774 goto finish;
775 *name = kv.items[name_i].util;
776 *email = kv.items[email_i].util;
777 *date = kv.items[date_i].util;
778 retval = 0;
779 finish:
780 string_list_clear(&kv, !!retval);
781 strbuf_release(&buf);
782 return retval;
786 * Read a GIT_AUTHOR_NAME, GIT_AUTHOR_EMAIL AND GIT_AUTHOR_DATE from a
787 * file with shell quoting into struct argv_array. Returns -1 on
788 * error, 0 otherwise.
790 static int read_env_script(struct argv_array *env)
792 char *name, *email, *date;
794 if (read_author_script(rebase_path_author_script(),
795 &name, &email, &date, 0))
796 return -1;
798 argv_array_pushf(env, "GIT_AUTHOR_NAME=%s", name);
799 argv_array_pushf(env, "GIT_AUTHOR_EMAIL=%s", email);
800 argv_array_pushf(env, "GIT_AUTHOR_DATE=%s", date);
801 free(name);
802 free(email);
803 free(date);
805 return 0;
808 static char *get_author(const char *message)
810 size_t len;
811 const char *a;
813 a = find_commit_header(message, "author", &len);
814 if (a)
815 return xmemdupz(a, len);
817 return NULL;
820 /* Read author-script and return an ident line (author <email> timestamp) */
821 static const char *read_author_ident(struct strbuf *buf)
823 struct strbuf out = STRBUF_INIT;
824 char *name, *email, *date;
826 if (read_author_script(rebase_path_author_script(),
827 &name, &email, &date, 0))
828 return NULL;
830 /* validate date since fmt_ident() will die() on bad value */
831 if (parse_date(date, &out)){
832 warning(_("invalid date format '%s' in '%s'"),
833 date, rebase_path_author_script());
834 strbuf_release(&out);
835 return NULL;
838 strbuf_reset(&out);
839 strbuf_addstr(&out, fmt_ident(name, email, date, 0));
840 strbuf_swap(buf, &out);
841 strbuf_release(&out);
842 free(name);
843 free(email);
844 free(date);
845 return buf->buf;
848 static const char staged_changes_advice[] =
849 N_("you have staged changes in your working tree\n"
850 "If these changes are meant to be squashed into the previous commit, run:\n"
851 "\n"
852 " git commit --amend %s\n"
853 "\n"
854 "If they are meant to go into a new commit, run:\n"
855 "\n"
856 " git commit %s\n"
857 "\n"
858 "In both cases, once you're done, continue with:\n"
859 "\n"
860 " git rebase --continue\n");
862 #define ALLOW_EMPTY (1<<0)
863 #define EDIT_MSG (1<<1)
864 #define AMEND_MSG (1<<2)
865 #define CLEANUP_MSG (1<<3)
866 #define VERIFY_MSG (1<<4)
867 #define CREATE_ROOT_COMMIT (1<<5)
869 static int run_command_silent_on_success(struct child_process *cmd)
871 struct strbuf buf = STRBUF_INIT;
872 int rc;
874 cmd->stdout_to_stderr = 1;
875 rc = pipe_command(cmd,
876 NULL, 0,
877 NULL, 0,
878 &buf, 0);
880 if (rc)
881 fputs(buf.buf, stderr);
882 strbuf_release(&buf);
883 return rc;
887 * If we are cherry-pick, and if the merge did not result in
888 * hand-editing, we will hit this commit and inherit the original
889 * author date and name.
891 * If we are revert, or if our cherry-pick results in a hand merge,
892 * we had better say that the current user is responsible for that.
894 * An exception is when run_git_commit() is called during an
895 * interactive rebase: in that case, we will want to retain the
896 * author metadata.
898 static int run_git_commit(struct repository *r,
899 const char *defmsg,
900 struct replay_opts *opts,
901 unsigned int flags)
903 struct child_process cmd = CHILD_PROCESS_INIT;
904 const char *value;
906 if ((flags & CREATE_ROOT_COMMIT) && !(flags & AMEND_MSG)) {
907 struct strbuf msg = STRBUF_INIT, script = STRBUF_INIT;
908 const char *author = NULL;
909 struct object_id root_commit, *cache_tree_oid;
910 int res = 0;
912 if (is_rebase_i(opts)) {
913 author = read_author_ident(&script);
914 if (!author) {
915 strbuf_release(&script);
916 return -1;
920 if (!defmsg)
921 BUG("root commit without message");
923 if (!(cache_tree_oid = get_cache_tree_oid(r->index)))
924 res = -1;
926 if (!res)
927 res = strbuf_read_file(&msg, defmsg, 0);
929 if (res <= 0)
930 res = error_errno(_("could not read '%s'"), defmsg);
931 else
932 res = commit_tree(msg.buf, msg.len, cache_tree_oid,
933 NULL, &root_commit, author,
934 opts->gpg_sign);
936 strbuf_release(&msg);
937 strbuf_release(&script);
938 if (!res) {
939 update_ref(NULL, "CHERRY_PICK_HEAD", &root_commit, NULL,
940 REF_NO_DEREF, UPDATE_REFS_MSG_ON_ERR);
941 res = update_ref(NULL, "HEAD", &root_commit, NULL, 0,
942 UPDATE_REFS_MSG_ON_ERR);
944 return res < 0 ? error(_("writing root commit")) : 0;
947 cmd.git_cmd = 1;
949 if (is_rebase_i(opts) && read_env_script(&cmd.env_array)) {
950 const char *gpg_opt = gpg_sign_opt_quoted(opts);
952 return error(_(staged_changes_advice),
953 gpg_opt, gpg_opt);
956 argv_array_push(&cmd.args, "commit");
958 if (!(flags & VERIFY_MSG))
959 argv_array_push(&cmd.args, "-n");
960 if ((flags & AMEND_MSG))
961 argv_array_push(&cmd.args, "--amend");
962 if (opts->gpg_sign)
963 argv_array_pushf(&cmd.args, "-S%s", opts->gpg_sign);
964 if (defmsg)
965 argv_array_pushl(&cmd.args, "-F", defmsg, NULL);
966 else if (!(flags & EDIT_MSG))
967 argv_array_pushl(&cmd.args, "-C", "HEAD", NULL);
968 if ((flags & CLEANUP_MSG))
969 argv_array_push(&cmd.args, "--cleanup=strip");
970 if ((flags & EDIT_MSG))
971 argv_array_push(&cmd.args, "-e");
972 else if (!(flags & CLEANUP_MSG) &&
973 !opts->signoff && !opts->record_origin &&
974 git_config_get_value("commit.cleanup", &value))
975 argv_array_push(&cmd.args, "--cleanup=verbatim");
977 if ((flags & ALLOW_EMPTY))
978 argv_array_push(&cmd.args, "--allow-empty");
980 if (!(flags & EDIT_MSG))
981 argv_array_push(&cmd.args, "--allow-empty-message");
983 if (is_rebase_i(opts) && !(flags & EDIT_MSG))
984 return run_command_silent_on_success(&cmd);
985 else
986 return run_command(&cmd);
989 static int rest_is_empty(const struct strbuf *sb, int start)
991 int i, eol;
992 const char *nl;
994 /* Check if the rest is just whitespace and Signed-off-by's. */
995 for (i = start; i < sb->len; i++) {
996 nl = memchr(sb->buf + i, '\n', sb->len - i);
997 if (nl)
998 eol = nl - sb->buf;
999 else
1000 eol = sb->len;
1002 if (strlen(sign_off_header) <= eol - i &&
1003 starts_with(sb->buf + i, sign_off_header)) {
1004 i = eol;
1005 continue;
1007 while (i < eol)
1008 if (!isspace(sb->buf[i++]))
1009 return 0;
1012 return 1;
1016 * Find out if the message in the strbuf contains only whitespace and
1017 * Signed-off-by lines.
1019 int message_is_empty(const struct strbuf *sb,
1020 enum commit_msg_cleanup_mode cleanup_mode)
1022 if (cleanup_mode == COMMIT_MSG_CLEANUP_NONE && sb->len)
1023 return 0;
1024 return rest_is_empty(sb, 0);
1028 * See if the user edited the message in the editor or left what
1029 * was in the template intact
1031 int template_untouched(const struct strbuf *sb, const char *template_file,
1032 enum commit_msg_cleanup_mode cleanup_mode)
1034 struct strbuf tmpl = STRBUF_INIT;
1035 const char *start;
1037 if (cleanup_mode == COMMIT_MSG_CLEANUP_NONE && sb->len)
1038 return 0;
1040 if (!template_file || strbuf_read_file(&tmpl, template_file, 0) <= 0)
1041 return 0;
1043 strbuf_stripspace(&tmpl, cleanup_mode == COMMIT_MSG_CLEANUP_ALL);
1044 if (!skip_prefix(sb->buf, tmpl.buf, &start))
1045 start = sb->buf;
1046 strbuf_release(&tmpl);
1047 return rest_is_empty(sb, start - sb->buf);
1050 int update_head_with_reflog(const struct commit *old_head,
1051 const struct object_id *new_head,
1052 const char *action, const struct strbuf *msg,
1053 struct strbuf *err)
1055 struct ref_transaction *transaction;
1056 struct strbuf sb = STRBUF_INIT;
1057 const char *nl;
1058 int ret = 0;
1060 if (action) {
1061 strbuf_addstr(&sb, action);
1062 strbuf_addstr(&sb, ": ");
1065 nl = strchr(msg->buf, '\n');
1066 if (nl) {
1067 strbuf_add(&sb, msg->buf, nl + 1 - msg->buf);
1068 } else {
1069 strbuf_addbuf(&sb, msg);
1070 strbuf_addch(&sb, '\n');
1073 transaction = ref_transaction_begin(err);
1074 if (!transaction ||
1075 ref_transaction_update(transaction, "HEAD", new_head,
1076 old_head ? &old_head->object.oid : &null_oid,
1077 0, sb.buf, err) ||
1078 ref_transaction_commit(transaction, err)) {
1079 ret = -1;
1081 ref_transaction_free(transaction);
1082 strbuf_release(&sb);
1084 return ret;
1087 static int run_rewrite_hook(const struct object_id *oldoid,
1088 const struct object_id *newoid)
1090 struct child_process proc = CHILD_PROCESS_INIT;
1091 const char *argv[3];
1092 int code;
1093 struct strbuf sb = STRBUF_INIT;
1095 argv[0] = find_hook("post-rewrite");
1096 if (!argv[0])
1097 return 0;
1099 argv[1] = "amend";
1100 argv[2] = NULL;
1102 proc.argv = argv;
1103 proc.in = -1;
1104 proc.stdout_to_stderr = 1;
1106 code = start_command(&proc);
1107 if (code)
1108 return code;
1109 strbuf_addf(&sb, "%s %s\n", oid_to_hex(oldoid), oid_to_hex(newoid));
1110 sigchain_push(SIGPIPE, SIG_IGN);
1111 write_in_full(proc.in, sb.buf, sb.len);
1112 close(proc.in);
1113 strbuf_release(&sb);
1114 sigchain_pop(SIGPIPE);
1115 return finish_command(&proc);
1118 void commit_post_rewrite(const struct commit *old_head,
1119 const struct object_id *new_head)
1121 struct notes_rewrite_cfg *cfg;
1123 cfg = init_copy_notes_for_rewrite("amend");
1124 if (cfg) {
1125 /* we are amending, so old_head is not NULL */
1126 copy_note_for_rewrite(cfg, &old_head->object.oid, new_head);
1127 finish_copy_notes_for_rewrite(cfg, "Notes added by 'git commit --amend'");
1129 run_rewrite_hook(&old_head->object.oid, new_head);
1132 static int run_prepare_commit_msg_hook(struct repository *r,
1133 struct strbuf *msg,
1134 const char *commit)
1136 struct argv_array hook_env = ARGV_ARRAY_INIT;
1137 int ret;
1138 const char *name;
1140 name = git_path_commit_editmsg();
1141 if (write_message(msg->buf, msg->len, name, 0))
1142 return -1;
1144 argv_array_pushf(&hook_env, "GIT_INDEX_FILE=%s", r->index_file);
1145 argv_array_push(&hook_env, "GIT_EDITOR=:");
1146 if (commit)
1147 ret = run_hook_le(hook_env.argv, "prepare-commit-msg", name,
1148 "commit", commit, NULL);
1149 else
1150 ret = run_hook_le(hook_env.argv, "prepare-commit-msg", name,
1151 "message", NULL);
1152 if (ret)
1153 ret = error(_("'prepare-commit-msg' hook failed"));
1154 argv_array_clear(&hook_env);
1156 return ret;
1159 static const char implicit_ident_advice_noconfig[] =
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. Run the\n"
1163 "following command and follow the instructions in your editor to edit\n"
1164 "your configuration file:\n"
1165 "\n"
1166 " git config --global --edit\n"
1167 "\n"
1168 "After doing this, you may fix the identity used for this commit with:\n"
1169 "\n"
1170 " git commit --amend --reset-author\n");
1172 static const char implicit_ident_advice_config[] =
1173 N_("Your name and email address were configured automatically based\n"
1174 "on your username and hostname. Please check that they are accurate.\n"
1175 "You can suppress this message by setting them explicitly:\n"
1176 "\n"
1177 " git config --global user.name \"Your Name\"\n"
1178 " git config --global user.email you@example.com\n"
1179 "\n"
1180 "After doing this, you may fix the identity used for this commit with:\n"
1181 "\n"
1182 " git commit --amend --reset-author\n");
1184 static const char *implicit_ident_advice(void)
1186 char *user_config = expand_user_path("~/.gitconfig", 0);
1187 char *xdg_config = xdg_config_home("config");
1188 int config_exists = file_exists(user_config) || file_exists(xdg_config);
1190 free(user_config);
1191 free(xdg_config);
1193 if (config_exists)
1194 return _(implicit_ident_advice_config);
1195 else
1196 return _(implicit_ident_advice_noconfig);
1200 void print_commit_summary(struct repository *r,
1201 const char *prefix,
1202 const struct object_id *oid,
1203 unsigned int flags)
1205 struct rev_info rev;
1206 struct commit *commit;
1207 struct strbuf format = STRBUF_INIT;
1208 const char *head;
1209 struct pretty_print_context pctx = {0};
1210 struct strbuf author_ident = STRBUF_INIT;
1211 struct strbuf committer_ident = STRBUF_INIT;
1213 commit = lookup_commit(r, oid);
1214 if (!commit)
1215 die(_("couldn't look up newly created commit"));
1216 if (parse_commit(commit))
1217 die(_("could not parse newly created commit"));
1219 strbuf_addstr(&format, "format:%h] %s");
1221 format_commit_message(commit, "%an <%ae>", &author_ident, &pctx);
1222 format_commit_message(commit, "%cn <%ce>", &committer_ident, &pctx);
1223 if (strbuf_cmp(&author_ident, &committer_ident)) {
1224 strbuf_addstr(&format, "\n Author: ");
1225 strbuf_addbuf_percentquote(&format, &author_ident);
1227 if (flags & SUMMARY_SHOW_AUTHOR_DATE) {
1228 struct strbuf date = STRBUF_INIT;
1230 format_commit_message(commit, "%ad", &date, &pctx);
1231 strbuf_addstr(&format, "\n Date: ");
1232 strbuf_addbuf_percentquote(&format, &date);
1233 strbuf_release(&date);
1235 if (!committer_ident_sufficiently_given()) {
1236 strbuf_addstr(&format, "\n Committer: ");
1237 strbuf_addbuf_percentquote(&format, &committer_ident);
1238 if (advice_implicit_identity) {
1239 strbuf_addch(&format, '\n');
1240 strbuf_addstr(&format, implicit_ident_advice());
1243 strbuf_release(&author_ident);
1244 strbuf_release(&committer_ident);
1246 repo_init_revisions(r, &rev, prefix);
1247 setup_revisions(0, NULL, &rev, NULL);
1249 rev.diff = 1;
1250 rev.diffopt.output_format =
1251 DIFF_FORMAT_SHORTSTAT | DIFF_FORMAT_SUMMARY;
1253 rev.verbose_header = 1;
1254 rev.show_root_diff = 1;
1255 get_commit_format(format.buf, &rev);
1256 rev.always_show_header = 0;
1257 rev.diffopt.detect_rename = DIFF_DETECT_RENAME;
1258 rev.diffopt.break_opt = 0;
1259 diff_setup_done(&rev.diffopt);
1261 head = resolve_ref_unsafe("HEAD", 0, NULL, NULL);
1262 if (!head)
1263 die_errno(_("unable to resolve HEAD after creating commit"));
1264 if (!strcmp(head, "HEAD"))
1265 head = _("detached HEAD");
1266 else
1267 skip_prefix(head, "refs/heads/", &head);
1268 printf("[%s%s ", head, (flags & SUMMARY_INITIAL_COMMIT) ?
1269 _(" (root-commit)") : "");
1271 if (!log_tree_commit(&rev, commit)) {
1272 rev.always_show_header = 1;
1273 rev.use_terminator = 1;
1274 log_tree_commit(&rev, commit);
1277 strbuf_release(&format);
1280 static int parse_head(struct repository *r, struct commit **head)
1282 struct commit *current_head;
1283 struct object_id oid;
1285 if (get_oid("HEAD", &oid)) {
1286 current_head = NULL;
1287 } else {
1288 current_head = lookup_commit_reference(r, &oid);
1289 if (!current_head)
1290 return error(_("could not parse HEAD"));
1291 if (!oideq(&oid, &current_head->object.oid)) {
1292 warning(_("HEAD %s is not a commit!"),
1293 oid_to_hex(&oid));
1295 if (parse_commit(current_head))
1296 return error(_("could not parse HEAD commit"));
1298 *head = current_head;
1300 return 0;
1304 * Try to commit without forking 'git commit'. In some cases we need
1305 * to run 'git commit' to display an error message
1307 * Returns:
1308 * -1 - error unable to commit
1309 * 0 - success
1310 * 1 - run 'git commit'
1312 static int try_to_commit(struct repository *r,
1313 struct strbuf *msg, const char *author,
1314 struct replay_opts *opts, unsigned int flags,
1315 struct object_id *oid)
1317 struct object_id tree;
1318 struct commit *current_head;
1319 struct commit_list *parents = NULL;
1320 struct commit_extra_header *extra = NULL;
1321 struct strbuf err = STRBUF_INIT;
1322 struct strbuf commit_msg = STRBUF_INIT;
1323 char *amend_author = NULL;
1324 const char *hook_commit = NULL;
1325 enum commit_msg_cleanup_mode cleanup;
1326 int res = 0;
1328 if (parse_head(r, &current_head))
1329 return -1;
1331 if (flags & AMEND_MSG) {
1332 const char *exclude_gpgsig[] = { "gpgsig", NULL };
1333 const char *out_enc = get_commit_output_encoding();
1334 const char *message = logmsg_reencode(current_head, NULL,
1335 out_enc);
1337 if (!msg) {
1338 const char *orig_message = NULL;
1340 find_commit_subject(message, &orig_message);
1341 msg = &commit_msg;
1342 strbuf_addstr(msg, orig_message);
1343 hook_commit = "HEAD";
1345 author = amend_author = get_author(message);
1346 unuse_commit_buffer(current_head, message);
1347 if (!author) {
1348 res = error(_("unable to parse commit author"));
1349 goto out;
1351 parents = copy_commit_list(current_head->parents);
1352 extra = read_commit_extra_headers(current_head, exclude_gpgsig);
1353 } else if (current_head) {
1354 commit_list_insert(current_head, &parents);
1357 if (write_index_as_tree(&tree, r->index, r->index_file, 0, NULL)) {
1358 res = error(_("git write-tree failed to write a tree"));
1359 goto out;
1362 if (!(flags & ALLOW_EMPTY) && oideq(current_head ?
1363 get_commit_tree_oid(current_head) :
1364 the_hash_algo->empty_tree, &tree)) {
1365 res = 1; /* run 'git commit' to display error message */
1366 goto out;
1369 if (find_hook("prepare-commit-msg")) {
1370 res = run_prepare_commit_msg_hook(r, msg, hook_commit);
1371 if (res)
1372 goto out;
1373 if (strbuf_read_file(&commit_msg, git_path_commit_editmsg(),
1374 2048) < 0) {
1375 res = error_errno(_("unable to read commit message "
1376 "from '%s'"),
1377 git_path_commit_editmsg());
1378 goto out;
1380 msg = &commit_msg;
1383 cleanup = (flags & CLEANUP_MSG) ? COMMIT_MSG_CLEANUP_ALL :
1384 opts->default_msg_cleanup;
1386 if (cleanup != COMMIT_MSG_CLEANUP_NONE)
1387 strbuf_stripspace(msg, cleanup == COMMIT_MSG_CLEANUP_ALL);
1388 if ((flags & EDIT_MSG) && message_is_empty(msg, cleanup)) {
1389 res = 1; /* run 'git commit' to display error message */
1390 goto out;
1393 reset_ident_date();
1395 if (commit_tree_extended(msg->buf, msg->len, &tree, parents,
1396 oid, author, opts->gpg_sign, extra)) {
1397 res = error(_("failed to write commit object"));
1398 goto out;
1401 if (update_head_with_reflog(current_head, oid,
1402 getenv("GIT_REFLOG_ACTION"), msg, &err)) {
1403 res = error("%s", err.buf);
1404 goto out;
1407 if (flags & AMEND_MSG)
1408 commit_post_rewrite(current_head, oid);
1410 out:
1411 free_commit_extra_headers(extra);
1412 strbuf_release(&err);
1413 strbuf_release(&commit_msg);
1414 free(amend_author);
1416 return res;
1419 static int do_commit(struct repository *r,
1420 const char *msg_file, const char *author,
1421 struct replay_opts *opts, unsigned int flags)
1423 int res = 1;
1425 if (!(flags & EDIT_MSG) && !(flags & VERIFY_MSG) &&
1426 !(flags & CREATE_ROOT_COMMIT)) {
1427 struct object_id oid;
1428 struct strbuf sb = STRBUF_INIT;
1430 if (msg_file && strbuf_read_file(&sb, msg_file, 2048) < 0)
1431 return error_errno(_("unable to read commit message "
1432 "from '%s'"),
1433 msg_file);
1435 res = try_to_commit(r, msg_file ? &sb : NULL,
1436 author, opts, flags, &oid);
1437 strbuf_release(&sb);
1438 if (!res) {
1439 unlink(git_path_cherry_pick_head(r));
1440 unlink(git_path_merge_msg(r));
1441 if (!is_rebase_i(opts))
1442 print_commit_summary(r, NULL, &oid,
1443 SUMMARY_SHOW_AUTHOR_DATE);
1444 return res;
1447 if (res == 1)
1448 return run_git_commit(r, msg_file, opts, flags);
1450 return res;
1453 static int is_original_commit_empty(struct commit *commit)
1455 const struct object_id *ptree_oid;
1457 if (parse_commit(commit))
1458 return error(_("could not parse commit %s"),
1459 oid_to_hex(&commit->object.oid));
1460 if (commit->parents) {
1461 struct commit *parent = commit->parents->item;
1462 if (parse_commit(parent))
1463 return error(_("could not parse parent commit %s"),
1464 oid_to_hex(&parent->object.oid));
1465 ptree_oid = get_commit_tree_oid(parent);
1466 } else {
1467 ptree_oid = the_hash_algo->empty_tree; /* commit is root */
1470 return oideq(ptree_oid, get_commit_tree_oid(commit));
1474 * Do we run "git commit" with "--allow-empty"?
1476 static int allow_empty(struct repository *r,
1477 struct replay_opts *opts,
1478 struct commit *commit)
1480 int index_unchanged, empty_commit;
1483 * Three cases:
1485 * (1) we do not allow empty at all and error out.
1487 * (2) we allow ones that were initially empty, but
1488 * forbid the ones that become empty;
1490 * (3) we allow both.
1492 if (!opts->allow_empty)
1493 return 0; /* let "git commit" barf as necessary */
1495 index_unchanged = is_index_unchanged(r);
1496 if (index_unchanged < 0)
1497 return index_unchanged;
1498 if (!index_unchanged)
1499 return 0; /* we do not have to say --allow-empty */
1501 if (opts->keep_redundant_commits)
1502 return 1;
1504 empty_commit = is_original_commit_empty(commit);
1505 if (empty_commit < 0)
1506 return empty_commit;
1507 if (!empty_commit)
1508 return 0;
1509 else
1510 return 1;
1514 * Note that ordering matters in this enum. Not only must it match the mapping
1515 * below, it is also divided into several sections that matter. When adding
1516 * new commands, make sure you add it in the right section.
1518 enum todo_command {
1519 /* commands that handle commits */
1520 TODO_PICK = 0,
1521 TODO_REVERT,
1522 TODO_EDIT,
1523 TODO_REWORD,
1524 TODO_FIXUP,
1525 TODO_SQUASH,
1526 /* commands that do something else than handling a single commit */
1527 TODO_EXEC,
1528 TODO_BREAK,
1529 TODO_LABEL,
1530 TODO_RESET,
1531 TODO_MERGE,
1532 /* commands that do nothing but are counted for reporting progress */
1533 TODO_NOOP,
1534 TODO_DROP,
1535 /* comments (not counted for reporting progress) */
1536 TODO_COMMENT
1539 static struct {
1540 char c;
1541 const char *str;
1542 } todo_command_info[] = {
1543 { 'p', "pick" },
1544 { 0, "revert" },
1545 { 'e', "edit" },
1546 { 'r', "reword" },
1547 { 'f', "fixup" },
1548 { 's', "squash" },
1549 { 'x', "exec" },
1550 { 'b', "break" },
1551 { 'l', "label" },
1552 { 't', "reset" },
1553 { 'm', "merge" },
1554 { 0, "noop" },
1555 { 'd', "drop" },
1556 { 0, NULL }
1559 static const char *command_to_string(const enum todo_command command)
1561 if (command < TODO_COMMENT)
1562 return todo_command_info[command].str;
1563 die(_("unknown command: %d"), command);
1566 static char command_to_char(const enum todo_command command)
1568 if (command < TODO_COMMENT && todo_command_info[command].c)
1569 return todo_command_info[command].c;
1570 return comment_line_char;
1573 static int is_noop(const enum todo_command command)
1575 return TODO_NOOP <= command;
1578 static int is_fixup(enum todo_command command)
1580 return command == TODO_FIXUP || command == TODO_SQUASH;
1583 /* Does this command create a (non-merge) commit? */
1584 static int is_pick_or_similar(enum todo_command command)
1586 switch (command) {
1587 case TODO_PICK:
1588 case TODO_REVERT:
1589 case TODO_EDIT:
1590 case TODO_REWORD:
1591 case TODO_FIXUP:
1592 case TODO_SQUASH:
1593 return 1;
1594 default:
1595 return 0;
1599 static int update_squash_messages(struct repository *r,
1600 enum todo_command command,
1601 struct commit *commit,
1602 struct replay_opts *opts)
1604 struct strbuf buf = STRBUF_INIT;
1605 int res;
1606 const char *message, *body;
1608 if (opts->current_fixup_count > 0) {
1609 struct strbuf header = STRBUF_INIT;
1610 char *eol;
1612 if (strbuf_read_file(&buf, rebase_path_squash_msg(), 9) <= 0)
1613 return error(_("could not read '%s'"),
1614 rebase_path_squash_msg());
1616 eol = buf.buf[0] != comment_line_char ?
1617 buf.buf : strchrnul(buf.buf, '\n');
1619 strbuf_addf(&header, "%c ", comment_line_char);
1620 strbuf_addf(&header, _("This is a combination of %d commits."),
1621 opts->current_fixup_count + 2);
1622 strbuf_splice(&buf, 0, eol - buf.buf, header.buf, header.len);
1623 strbuf_release(&header);
1624 } else {
1625 struct object_id head;
1626 struct commit *head_commit;
1627 const char *head_message, *body;
1629 if (get_oid("HEAD", &head))
1630 return error(_("need a HEAD to fixup"));
1631 if (!(head_commit = lookup_commit_reference(r, &head)))
1632 return error(_("could not read HEAD"));
1633 if (!(head_message = get_commit_buffer(head_commit, NULL)))
1634 return error(_("could not read HEAD's commit message"));
1636 find_commit_subject(head_message, &body);
1637 if (write_message(body, strlen(body),
1638 rebase_path_fixup_msg(), 0)) {
1639 unuse_commit_buffer(head_commit, head_message);
1640 return error(_("cannot write '%s'"),
1641 rebase_path_fixup_msg());
1644 strbuf_addf(&buf, "%c ", comment_line_char);
1645 strbuf_addf(&buf, _("This is a combination of %d commits."), 2);
1646 strbuf_addf(&buf, "\n%c ", comment_line_char);
1647 strbuf_addstr(&buf, _("This is the 1st commit message:"));
1648 strbuf_addstr(&buf, "\n\n");
1649 strbuf_addstr(&buf, body);
1651 unuse_commit_buffer(head_commit, head_message);
1654 if (!(message = get_commit_buffer(commit, NULL)))
1655 return error(_("could not read commit message of %s"),
1656 oid_to_hex(&commit->object.oid));
1657 find_commit_subject(message, &body);
1659 if (command == TODO_SQUASH) {
1660 unlink(rebase_path_fixup_msg());
1661 strbuf_addf(&buf, "\n%c ", comment_line_char);
1662 strbuf_addf(&buf, _("This is the commit message #%d:"),
1663 ++opts->current_fixup_count + 1);
1664 strbuf_addstr(&buf, "\n\n");
1665 strbuf_addstr(&buf, body);
1666 } else if (command == TODO_FIXUP) {
1667 strbuf_addf(&buf, "\n%c ", comment_line_char);
1668 strbuf_addf(&buf, _("The commit message #%d will be skipped:"),
1669 ++opts->current_fixup_count + 1);
1670 strbuf_addstr(&buf, "\n\n");
1671 strbuf_add_commented_lines(&buf, body, strlen(body));
1672 } else
1673 return error(_("unknown command: %d"), command);
1674 unuse_commit_buffer(commit, message);
1676 res = write_message(buf.buf, buf.len, rebase_path_squash_msg(), 0);
1677 strbuf_release(&buf);
1679 if (!res) {
1680 strbuf_addf(&opts->current_fixups, "%s%s %s",
1681 opts->current_fixups.len ? "\n" : "",
1682 command_to_string(command),
1683 oid_to_hex(&commit->object.oid));
1684 res = write_message(opts->current_fixups.buf,
1685 opts->current_fixups.len,
1686 rebase_path_current_fixups(), 0);
1689 return res;
1692 static void flush_rewritten_pending(void) {
1693 struct strbuf buf = STRBUF_INIT;
1694 struct object_id newoid;
1695 FILE *out;
1697 if (strbuf_read_file(&buf, rebase_path_rewritten_pending(), (GIT_MAX_HEXSZ + 1) * 2) > 0 &&
1698 !get_oid("HEAD", &newoid) &&
1699 (out = fopen_or_warn(rebase_path_rewritten_list(), "a"))) {
1700 char *bol = buf.buf, *eol;
1702 while (*bol) {
1703 eol = strchrnul(bol, '\n');
1704 fprintf(out, "%.*s %s\n", (int)(eol - bol),
1705 bol, oid_to_hex(&newoid));
1706 if (!*eol)
1707 break;
1708 bol = eol + 1;
1710 fclose(out);
1711 unlink(rebase_path_rewritten_pending());
1713 strbuf_release(&buf);
1716 static void record_in_rewritten(struct object_id *oid,
1717 enum todo_command next_command) {
1718 FILE *out = fopen_or_warn(rebase_path_rewritten_pending(), "a");
1720 if (!out)
1721 return;
1723 fprintf(out, "%s\n", oid_to_hex(oid));
1724 fclose(out);
1726 if (!is_fixup(next_command))
1727 flush_rewritten_pending();
1730 static int do_pick_commit(struct repository *r,
1731 enum todo_command command,
1732 struct commit *commit,
1733 struct replay_opts *opts,
1734 int final_fixup)
1736 unsigned int flags = opts->edit ? EDIT_MSG : 0;
1737 const char *msg_file = opts->edit ? NULL : git_path_merge_msg(r);
1738 struct object_id head;
1739 struct commit *base, *next, *parent;
1740 const char *base_label, *next_label;
1741 char *author = NULL;
1742 struct commit_message msg = { NULL, NULL, NULL, NULL };
1743 struct strbuf msgbuf = STRBUF_INIT;
1744 int res, unborn = 0, allow;
1746 if (opts->no_commit) {
1748 * We do not intend to commit immediately. We just want to
1749 * merge the differences in, so let's compute the tree
1750 * that represents the "current" state for merge-recursive
1751 * to work on.
1753 if (write_index_as_tree(&head, r->index, r->index_file, 0, NULL))
1754 return error(_("your index file is unmerged."));
1755 } else {
1756 unborn = get_oid("HEAD", &head);
1757 /* Do we want to generate a root commit? */
1758 if (is_pick_or_similar(command) && opts->have_squash_onto &&
1759 oideq(&head, &opts->squash_onto)) {
1760 if (is_fixup(command))
1761 return error(_("cannot fixup root commit"));
1762 flags |= CREATE_ROOT_COMMIT;
1763 unborn = 1;
1764 } else if (unborn)
1765 oidcpy(&head, the_hash_algo->empty_tree);
1766 if (index_differs_from(r, unborn ? empty_tree_oid_hex() : "HEAD",
1767 NULL, 0))
1768 return error_dirty_index(r->index, opts);
1770 discard_index(r->index);
1772 if (!commit->parents)
1773 parent = NULL;
1774 else if (commit->parents->next) {
1775 /* Reverting or cherry-picking a merge commit */
1776 int cnt;
1777 struct commit_list *p;
1779 if (!opts->mainline)
1780 return error(_("commit %s is a merge but no -m option was given."),
1781 oid_to_hex(&commit->object.oid));
1783 for (cnt = 1, p = commit->parents;
1784 cnt != opts->mainline && p;
1785 cnt++)
1786 p = p->next;
1787 if (cnt != opts->mainline || !p)
1788 return error(_("commit %s does not have parent %d"),
1789 oid_to_hex(&commit->object.oid), opts->mainline);
1790 parent = p->item;
1791 } else if (0 < opts->mainline)
1792 return error(_("mainline was specified but commit %s is not a merge."),
1793 oid_to_hex(&commit->object.oid));
1794 else
1795 parent = commit->parents->item;
1797 if (get_message(commit, &msg) != 0)
1798 return error(_("cannot get commit message for %s"),
1799 oid_to_hex(&commit->object.oid));
1801 if (opts->allow_ff && !is_fixup(command) &&
1802 ((parent && oideq(&parent->object.oid, &head)) ||
1803 (!parent && unborn))) {
1804 if (is_rebase_i(opts))
1805 write_author_script(msg.message);
1806 res = fast_forward_to(r, &commit->object.oid, &head, unborn,
1807 opts);
1808 if (res || command != TODO_REWORD)
1809 goto leave;
1810 flags |= EDIT_MSG | AMEND_MSG | VERIFY_MSG;
1811 msg_file = NULL;
1812 goto fast_forward_edit;
1814 if (parent && parse_commit(parent) < 0)
1815 /* TRANSLATORS: The first %s will be a "todo" command like
1816 "revert" or "pick", the second %s a SHA1. */
1817 return error(_("%s: cannot parse parent commit %s"),
1818 command_to_string(command),
1819 oid_to_hex(&parent->object.oid));
1822 * "commit" is an existing commit. We would want to apply
1823 * the difference it introduces since its first parent "prev"
1824 * on top of the current HEAD if we are cherry-pick. Or the
1825 * reverse of it if we are revert.
1828 if (command == TODO_REVERT) {
1829 base = commit;
1830 base_label = msg.label;
1831 next = parent;
1832 next_label = msg.parent_label;
1833 strbuf_addstr(&msgbuf, "Revert \"");
1834 strbuf_addstr(&msgbuf, msg.subject);
1835 strbuf_addstr(&msgbuf, "\"\n\nThis reverts commit ");
1836 strbuf_addstr(&msgbuf, oid_to_hex(&commit->object.oid));
1838 if (commit->parents && commit->parents->next) {
1839 strbuf_addstr(&msgbuf, ", reversing\nchanges made to ");
1840 strbuf_addstr(&msgbuf, oid_to_hex(&parent->object.oid));
1842 strbuf_addstr(&msgbuf, ".\n");
1843 } else {
1844 const char *p;
1846 base = parent;
1847 base_label = msg.parent_label;
1848 next = commit;
1849 next_label = msg.label;
1851 /* Append the commit log message to msgbuf. */
1852 if (find_commit_subject(msg.message, &p))
1853 strbuf_addstr(&msgbuf, p);
1855 if (opts->record_origin) {
1856 strbuf_complete_line(&msgbuf);
1857 if (!has_conforming_footer(&msgbuf, NULL, 0))
1858 strbuf_addch(&msgbuf, '\n');
1859 strbuf_addstr(&msgbuf, cherry_picked_prefix);
1860 strbuf_addstr(&msgbuf, oid_to_hex(&commit->object.oid));
1861 strbuf_addstr(&msgbuf, ")\n");
1863 if (!is_fixup(command))
1864 author = get_author(msg.message);
1867 if (command == TODO_REWORD)
1868 flags |= EDIT_MSG | VERIFY_MSG;
1869 else if (is_fixup(command)) {
1870 if (update_squash_messages(r, command, commit, opts))
1871 return -1;
1872 flags |= AMEND_MSG;
1873 if (!final_fixup)
1874 msg_file = rebase_path_squash_msg();
1875 else if (file_exists(rebase_path_fixup_msg())) {
1876 flags |= CLEANUP_MSG;
1877 msg_file = rebase_path_fixup_msg();
1878 } else {
1879 const char *dest = git_path_squash_msg(r);
1880 unlink(dest);
1881 if (copy_file(dest, rebase_path_squash_msg(), 0666))
1882 return error(_("could not rename '%s' to '%s'"),
1883 rebase_path_squash_msg(), dest);
1884 unlink(git_path_merge_msg(r));
1885 msg_file = dest;
1886 flags |= EDIT_MSG;
1890 if (opts->signoff && !is_fixup(command))
1891 append_signoff(&msgbuf, 0, 0);
1893 if (is_rebase_i(opts) && write_author_script(msg.message) < 0)
1894 res = -1;
1895 else if (!opts->strategy || !strcmp(opts->strategy, "recursive") || command == TODO_REVERT) {
1896 res = do_recursive_merge(r, base, next, base_label, next_label,
1897 &head, &msgbuf, opts);
1898 if (res < 0)
1899 goto leave;
1901 res |= write_message(msgbuf.buf, msgbuf.len,
1902 git_path_merge_msg(r), 0);
1903 } else {
1904 struct commit_list *common = NULL;
1905 struct commit_list *remotes = NULL;
1907 res = write_message(msgbuf.buf, msgbuf.len,
1908 git_path_merge_msg(r), 0);
1910 commit_list_insert(base, &common);
1911 commit_list_insert(next, &remotes);
1912 res |= try_merge_command(r, opts->strategy,
1913 opts->xopts_nr, (const char **)opts->xopts,
1914 common, oid_to_hex(&head), remotes);
1915 free_commit_list(common);
1916 free_commit_list(remotes);
1918 strbuf_release(&msgbuf);
1921 * If the merge was clean or if it failed due to conflict, we write
1922 * CHERRY_PICK_HEAD for the subsequent invocation of commit to use.
1923 * However, if the merge did not even start, then we don't want to
1924 * write it at all.
1926 if (command == TODO_PICK && !opts->no_commit && (res == 0 || res == 1) &&
1927 update_ref(NULL, "CHERRY_PICK_HEAD", &commit->object.oid, NULL,
1928 REF_NO_DEREF, UPDATE_REFS_MSG_ON_ERR))
1929 res = -1;
1930 if (command == TODO_REVERT && ((opts->no_commit && res == 0) || res == 1) &&
1931 update_ref(NULL, "REVERT_HEAD", &commit->object.oid, NULL,
1932 REF_NO_DEREF, UPDATE_REFS_MSG_ON_ERR))
1933 res = -1;
1935 if (res) {
1936 error(command == TODO_REVERT
1937 ? _("could not revert %s... %s")
1938 : _("could not apply %s... %s"),
1939 short_commit_name(commit), msg.subject);
1940 print_advice(r, res == 1, opts);
1941 repo_rerere(r, opts->allow_rerere_auto);
1942 goto leave;
1945 allow = allow_empty(r, opts, commit);
1946 if (allow < 0) {
1947 res = allow;
1948 goto leave;
1949 } else if (allow)
1950 flags |= ALLOW_EMPTY;
1951 if (!opts->no_commit) {
1952 fast_forward_edit:
1953 if (author || command == TODO_REVERT || (flags & AMEND_MSG))
1954 res = do_commit(r, msg_file, author, opts, flags);
1955 else
1956 res = error(_("unable to parse commit author"));
1959 if (!res && final_fixup) {
1960 unlink(rebase_path_fixup_msg());
1961 unlink(rebase_path_squash_msg());
1962 unlink(rebase_path_current_fixups());
1963 strbuf_reset(&opts->current_fixups);
1964 opts->current_fixup_count = 0;
1967 leave:
1968 free_message(commit, &msg);
1969 free(author);
1970 update_abort_safety_file();
1972 return res;
1975 static int prepare_revs(struct replay_opts *opts)
1978 * picking (but not reverting) ranges (but not individual revisions)
1979 * should be done in reverse
1981 if (opts->action == REPLAY_PICK && !opts->revs->no_walk)
1982 opts->revs->reverse ^= 1;
1984 if (prepare_revision_walk(opts->revs))
1985 return error(_("revision walk setup failed"));
1987 return 0;
1990 static int read_and_refresh_cache(struct repository *r,
1991 struct replay_opts *opts)
1993 struct lock_file index_lock = LOCK_INIT;
1994 int index_fd = hold_locked_index(&index_lock, 0);
1995 if (read_index(r->index) < 0) {
1996 rollback_lock_file(&index_lock);
1997 return error(_("git %s: failed to read the index"),
1998 _(action_name(opts)));
2000 refresh_index(r->index, REFRESH_QUIET|REFRESH_UNMERGED, NULL, NULL, NULL);
2001 if (index_fd >= 0) {
2002 if (write_locked_index(r->index, &index_lock,
2003 COMMIT_LOCK | SKIP_IF_UNCHANGED)) {
2004 return error(_("git %s: failed to refresh the index"),
2005 _(action_name(opts)));
2008 return 0;
2011 enum todo_item_flags {
2012 TODO_EDIT_MERGE_MSG = 1
2015 struct todo_item {
2016 enum todo_command command;
2017 struct commit *commit;
2018 unsigned int flags;
2019 const char *arg;
2020 int arg_len;
2021 size_t offset_in_buf;
2024 struct todo_list {
2025 struct strbuf buf;
2026 struct todo_item *items;
2027 int nr, alloc, current;
2028 int done_nr, total_nr;
2029 struct stat_data stat;
2032 #define TODO_LIST_INIT { STRBUF_INIT }
2034 static void todo_list_release(struct todo_list *todo_list)
2036 strbuf_release(&todo_list->buf);
2037 FREE_AND_NULL(todo_list->items);
2038 todo_list->nr = todo_list->alloc = 0;
2041 static struct todo_item *append_new_todo(struct todo_list *todo_list)
2043 ALLOC_GROW(todo_list->items, todo_list->nr + 1, todo_list->alloc);
2044 return todo_list->items + todo_list->nr++;
2047 static int parse_insn_line(struct repository *r, struct todo_item *item,
2048 const char *bol, char *eol)
2050 struct object_id commit_oid;
2051 char *end_of_object_name;
2052 int i, saved, status, padding;
2054 item->flags = 0;
2056 /* left-trim */
2057 bol += strspn(bol, " \t");
2059 if (bol == eol || *bol == '\r' || *bol == comment_line_char) {
2060 item->command = TODO_COMMENT;
2061 item->commit = NULL;
2062 item->arg = bol;
2063 item->arg_len = eol - bol;
2064 return 0;
2067 for (i = 0; i < TODO_COMMENT; i++)
2068 if (skip_prefix(bol, todo_command_info[i].str, &bol)) {
2069 item->command = i;
2070 break;
2071 } else if ((bol + 1 == eol || bol[1] == ' ') &&
2072 *bol == todo_command_info[i].c) {
2073 bol++;
2074 item->command = i;
2075 break;
2077 if (i >= TODO_COMMENT)
2078 return -1;
2080 /* Eat up extra spaces/ tabs before object name */
2081 padding = strspn(bol, " \t");
2082 bol += padding;
2084 if (item->command == TODO_NOOP || item->command == TODO_BREAK) {
2085 if (bol != eol)
2086 return error(_("%s does not accept arguments: '%s'"),
2087 command_to_string(item->command), bol);
2088 item->commit = NULL;
2089 item->arg = bol;
2090 item->arg_len = eol - bol;
2091 return 0;
2094 if (!padding)
2095 return error(_("missing arguments for %s"),
2096 command_to_string(item->command));
2098 if (item->command == TODO_EXEC || item->command == TODO_LABEL ||
2099 item->command == TODO_RESET) {
2100 item->commit = NULL;
2101 item->arg = bol;
2102 item->arg_len = (int)(eol - bol);
2103 return 0;
2106 if (item->command == TODO_MERGE) {
2107 if (skip_prefix(bol, "-C", &bol))
2108 bol += strspn(bol, " \t");
2109 else if (skip_prefix(bol, "-c", &bol)) {
2110 bol += strspn(bol, " \t");
2111 item->flags |= TODO_EDIT_MERGE_MSG;
2112 } else {
2113 item->flags |= TODO_EDIT_MERGE_MSG;
2114 item->commit = NULL;
2115 item->arg = bol;
2116 item->arg_len = (int)(eol - bol);
2117 return 0;
2121 end_of_object_name = (char *) bol + strcspn(bol, " \t\n");
2122 saved = *end_of_object_name;
2123 *end_of_object_name = '\0';
2124 status = get_oid(bol, &commit_oid);
2125 *end_of_object_name = saved;
2127 item->arg = end_of_object_name + strspn(end_of_object_name, " \t");
2128 item->arg_len = (int)(eol - item->arg);
2130 if (status < 0)
2131 return -1;
2133 item->commit = lookup_commit_reference(r, &commit_oid);
2134 return !item->commit;
2137 static int parse_insn_buffer(struct repository *r, char *buf,
2138 struct todo_list *todo_list)
2140 struct todo_item *item;
2141 char *p = buf, *next_p;
2142 int i, res = 0, fixup_okay = file_exists(rebase_path_done());
2144 for (i = 1; *p; i++, p = next_p) {
2145 char *eol = strchrnul(p, '\n');
2147 next_p = *eol ? eol + 1 /* skip LF */ : eol;
2149 if (p != eol && eol[-1] == '\r')
2150 eol--; /* strip Carriage Return */
2152 item = append_new_todo(todo_list);
2153 item->offset_in_buf = p - todo_list->buf.buf;
2154 if (parse_insn_line(r, item, p, eol)) {
2155 res = error(_("invalid line %d: %.*s"),
2156 i, (int)(eol - p), p);
2157 item->command = TODO_NOOP;
2160 if (fixup_okay)
2161 ; /* do nothing */
2162 else if (is_fixup(item->command))
2163 return error(_("cannot '%s' without a previous commit"),
2164 command_to_string(item->command));
2165 else if (!is_noop(item->command))
2166 fixup_okay = 1;
2169 return res;
2172 static int count_commands(struct todo_list *todo_list)
2174 int count = 0, i;
2176 for (i = 0; i < todo_list->nr; i++)
2177 if (todo_list->items[i].command != TODO_COMMENT)
2178 count++;
2180 return count;
2183 static int get_item_line_offset(struct todo_list *todo_list, int index)
2185 return index < todo_list->nr ?
2186 todo_list->items[index].offset_in_buf : todo_list->buf.len;
2189 static const char *get_item_line(struct todo_list *todo_list, int index)
2191 return todo_list->buf.buf + get_item_line_offset(todo_list, index);
2194 static int get_item_line_length(struct todo_list *todo_list, int index)
2196 return get_item_line_offset(todo_list, index + 1)
2197 - get_item_line_offset(todo_list, index);
2200 static ssize_t strbuf_read_file_or_whine(struct strbuf *sb, const char *path)
2202 int fd;
2203 ssize_t len;
2205 fd = open(path, O_RDONLY);
2206 if (fd < 0)
2207 return error_errno(_("could not open '%s'"), path);
2208 len = strbuf_read(sb, fd, 0);
2209 close(fd);
2210 if (len < 0)
2211 return error(_("could not read '%s'."), path);
2212 return len;
2215 static int read_populate_todo(struct repository *r,
2216 struct todo_list *todo_list,
2217 struct replay_opts *opts)
2219 struct stat st;
2220 const char *todo_file = get_todo_path(opts);
2221 int res;
2223 strbuf_reset(&todo_list->buf);
2224 if (strbuf_read_file_or_whine(&todo_list->buf, todo_file) < 0)
2225 return -1;
2227 res = stat(todo_file, &st);
2228 if (res)
2229 return error(_("could not stat '%s'"), todo_file);
2230 fill_stat_data(&todo_list->stat, &st);
2232 res = parse_insn_buffer(r, todo_list->buf.buf, todo_list);
2233 if (res) {
2234 if (is_rebase_i(opts))
2235 return error(_("please fix this using "
2236 "'git rebase --edit-todo'."));
2237 return error(_("unusable instruction sheet: '%s'"), todo_file);
2240 if (!todo_list->nr &&
2241 (!is_rebase_i(opts) || !file_exists(rebase_path_done())))
2242 return error(_("no commits parsed."));
2244 if (!is_rebase_i(opts)) {
2245 enum todo_command valid =
2246 opts->action == REPLAY_PICK ? TODO_PICK : TODO_REVERT;
2247 int i;
2249 for (i = 0; i < todo_list->nr; i++)
2250 if (valid == todo_list->items[i].command)
2251 continue;
2252 else if (valid == TODO_PICK)
2253 return error(_("cannot cherry-pick during a revert."));
2254 else
2255 return error(_("cannot revert during a cherry-pick."));
2258 if (is_rebase_i(opts)) {
2259 struct todo_list done = TODO_LIST_INIT;
2260 FILE *f = fopen_or_warn(rebase_path_msgtotal(), "w");
2262 if (strbuf_read_file(&done.buf, rebase_path_done(), 0) > 0 &&
2263 !parse_insn_buffer(r, done.buf.buf, &done))
2264 todo_list->done_nr = count_commands(&done);
2265 else
2266 todo_list->done_nr = 0;
2268 todo_list->total_nr = todo_list->done_nr
2269 + count_commands(todo_list);
2270 todo_list_release(&done);
2272 if (f) {
2273 fprintf(f, "%d\n", todo_list->total_nr);
2274 fclose(f);
2278 return 0;
2281 static int git_config_string_dup(char **dest,
2282 const char *var, const char *value)
2284 if (!value)
2285 return config_error_nonbool(var);
2286 free(*dest);
2287 *dest = xstrdup(value);
2288 return 0;
2291 static int populate_opts_cb(const char *key, const char *value, void *data)
2293 struct replay_opts *opts = data;
2294 int error_flag = 1;
2296 if (!value)
2297 error_flag = 0;
2298 else if (!strcmp(key, "options.no-commit"))
2299 opts->no_commit = git_config_bool_or_int(key, value, &error_flag);
2300 else if (!strcmp(key, "options.edit"))
2301 opts->edit = git_config_bool_or_int(key, value, &error_flag);
2302 else if (!strcmp(key, "options.signoff"))
2303 opts->signoff = git_config_bool_or_int(key, value, &error_flag);
2304 else if (!strcmp(key, "options.record-origin"))
2305 opts->record_origin = git_config_bool_or_int(key, value, &error_flag);
2306 else if (!strcmp(key, "options.allow-ff"))
2307 opts->allow_ff = git_config_bool_or_int(key, value, &error_flag);
2308 else if (!strcmp(key, "options.mainline"))
2309 opts->mainline = git_config_int(key, value);
2310 else if (!strcmp(key, "options.strategy"))
2311 git_config_string_dup(&opts->strategy, key, value);
2312 else if (!strcmp(key, "options.gpg-sign"))
2313 git_config_string_dup(&opts->gpg_sign, key, value);
2314 else if (!strcmp(key, "options.strategy-option")) {
2315 ALLOC_GROW(opts->xopts, opts->xopts_nr + 1, opts->xopts_alloc);
2316 opts->xopts[opts->xopts_nr++] = xstrdup(value);
2317 } else if (!strcmp(key, "options.allow-rerere-auto"))
2318 opts->allow_rerere_auto =
2319 git_config_bool_or_int(key, value, &error_flag) ?
2320 RERERE_AUTOUPDATE : RERERE_NOAUTOUPDATE;
2321 else
2322 return error(_("invalid key: %s"), key);
2324 if (!error_flag)
2325 return error(_("invalid value for %s: %s"), key, value);
2327 return 0;
2330 void parse_strategy_opts(struct replay_opts *opts, char *raw_opts)
2332 int i;
2333 char *strategy_opts_string = raw_opts;
2335 if (*strategy_opts_string == ' ')
2336 strategy_opts_string++;
2338 opts->xopts_nr = split_cmdline(strategy_opts_string,
2339 (const char ***)&opts->xopts);
2340 for (i = 0; i < opts->xopts_nr; i++) {
2341 const char *arg = opts->xopts[i];
2343 skip_prefix(arg, "--", &arg);
2344 opts->xopts[i] = xstrdup(arg);
2348 static void read_strategy_opts(struct replay_opts *opts, struct strbuf *buf)
2350 strbuf_reset(buf);
2351 if (!read_oneliner(buf, rebase_path_strategy(), 0))
2352 return;
2353 opts->strategy = strbuf_detach(buf, NULL);
2354 if (!read_oneliner(buf, rebase_path_strategy_opts(), 0))
2355 return;
2357 parse_strategy_opts(opts, buf->buf);
2360 static int read_populate_opts(struct replay_opts *opts)
2362 if (is_rebase_i(opts)) {
2363 struct strbuf buf = STRBUF_INIT;
2365 if (read_oneliner(&buf, rebase_path_gpg_sign_opt(), 1)) {
2366 if (!starts_with(buf.buf, "-S"))
2367 strbuf_reset(&buf);
2368 else {
2369 free(opts->gpg_sign);
2370 opts->gpg_sign = xstrdup(buf.buf + 2);
2372 strbuf_reset(&buf);
2375 if (read_oneliner(&buf, rebase_path_allow_rerere_autoupdate(), 1)) {
2376 if (!strcmp(buf.buf, "--rerere-autoupdate"))
2377 opts->allow_rerere_auto = RERERE_AUTOUPDATE;
2378 else if (!strcmp(buf.buf, "--no-rerere-autoupdate"))
2379 opts->allow_rerere_auto = RERERE_NOAUTOUPDATE;
2380 strbuf_reset(&buf);
2383 if (file_exists(rebase_path_verbose()))
2384 opts->verbose = 1;
2386 if (file_exists(rebase_path_signoff())) {
2387 opts->allow_ff = 0;
2388 opts->signoff = 1;
2391 read_strategy_opts(opts, &buf);
2392 strbuf_release(&buf);
2394 if (read_oneliner(&opts->current_fixups,
2395 rebase_path_current_fixups(), 1)) {
2396 const char *p = opts->current_fixups.buf;
2397 opts->current_fixup_count = 1;
2398 while ((p = strchr(p, '\n'))) {
2399 opts->current_fixup_count++;
2400 p++;
2404 if (read_oneliner(&buf, rebase_path_squash_onto(), 0)) {
2405 if (get_oid_hex(buf.buf, &opts->squash_onto) < 0)
2406 return error(_("unusable squash-onto"));
2407 opts->have_squash_onto = 1;
2410 return 0;
2413 if (!file_exists(git_path_opts_file()))
2414 return 0;
2416 * The function git_parse_source(), called from git_config_from_file(),
2417 * may die() in case of a syntactically incorrect file. We do not care
2418 * about this case, though, because we wrote that file ourselves, so we
2419 * are pretty certain that it is syntactically correct.
2421 if (git_config_from_file(populate_opts_cb, git_path_opts_file(), opts) < 0)
2422 return error(_("malformed options sheet: '%s'"),
2423 git_path_opts_file());
2424 return 0;
2427 static void write_strategy_opts(struct replay_opts *opts)
2429 int i;
2430 struct strbuf buf = STRBUF_INIT;
2432 for (i = 0; i < opts->xopts_nr; ++i)
2433 strbuf_addf(&buf, " --%s", opts->xopts[i]);
2435 write_file(rebase_path_strategy_opts(), "%s\n", buf.buf);
2436 strbuf_release(&buf);
2439 int write_basic_state(struct replay_opts *opts, const char *head_name,
2440 const char *onto, const char *orig_head)
2442 const char *quiet = getenv("GIT_QUIET");
2444 if (head_name)
2445 write_file(rebase_path_head_name(), "%s\n", head_name);
2446 if (onto)
2447 write_file(rebase_path_onto(), "%s\n", onto);
2448 if (orig_head)
2449 write_file(rebase_path_orig_head(), "%s\n", orig_head);
2451 if (quiet)
2452 write_file(rebase_path_quiet(), "%s\n", quiet);
2453 else
2454 write_file(rebase_path_quiet(), "\n");
2456 if (opts->verbose)
2457 write_file(rebase_path_verbose(), "%s", "");
2458 if (opts->strategy)
2459 write_file(rebase_path_strategy(), "%s\n", opts->strategy);
2460 if (opts->xopts_nr > 0)
2461 write_strategy_opts(opts);
2463 if (opts->allow_rerere_auto == RERERE_AUTOUPDATE)
2464 write_file(rebase_path_allow_rerere_autoupdate(), "--rerere-autoupdate\n");
2465 else if (opts->allow_rerere_auto == RERERE_NOAUTOUPDATE)
2466 write_file(rebase_path_allow_rerere_autoupdate(), "--no-rerere-autoupdate\n");
2468 if (opts->gpg_sign)
2469 write_file(rebase_path_gpg_sign_opt(), "-S%s\n", opts->gpg_sign);
2470 if (opts->signoff)
2471 write_file(rebase_path_signoff(), "--signoff\n");
2473 return 0;
2476 static int walk_revs_populate_todo(struct todo_list *todo_list,
2477 struct replay_opts *opts)
2479 enum todo_command command = opts->action == REPLAY_PICK ?
2480 TODO_PICK : TODO_REVERT;
2481 const char *command_string = todo_command_info[command].str;
2482 struct commit *commit;
2484 if (prepare_revs(opts))
2485 return -1;
2487 while ((commit = get_revision(opts->revs))) {
2488 struct todo_item *item = append_new_todo(todo_list);
2489 const char *commit_buffer = get_commit_buffer(commit, NULL);
2490 const char *subject;
2491 int subject_len;
2493 item->command = command;
2494 item->commit = commit;
2495 item->arg = NULL;
2496 item->arg_len = 0;
2497 item->offset_in_buf = todo_list->buf.len;
2498 subject_len = find_commit_subject(commit_buffer, &subject);
2499 strbuf_addf(&todo_list->buf, "%s %s %.*s\n", command_string,
2500 short_commit_name(commit), subject_len, subject);
2501 unuse_commit_buffer(commit, commit_buffer);
2504 if (!todo_list->nr)
2505 return error(_("empty commit set passed"));
2507 return 0;
2510 static int create_seq_dir(void)
2512 if (file_exists(git_path_seq_dir())) {
2513 error(_("a cherry-pick or revert is already in progress"));
2514 advise(_("try \"git cherry-pick (--continue | --quit | --abort)\""));
2515 return -1;
2516 } else if (mkdir(git_path_seq_dir(), 0777) < 0)
2517 return error_errno(_("could not create sequencer directory '%s'"),
2518 git_path_seq_dir());
2519 return 0;
2522 static int save_head(const char *head)
2524 struct lock_file head_lock = LOCK_INIT;
2525 struct strbuf buf = STRBUF_INIT;
2526 int fd;
2527 ssize_t written;
2529 fd = hold_lock_file_for_update(&head_lock, git_path_head_file(), 0);
2530 if (fd < 0)
2531 return error_errno(_("could not lock HEAD"));
2532 strbuf_addf(&buf, "%s\n", head);
2533 written = write_in_full(fd, buf.buf, buf.len);
2534 strbuf_release(&buf);
2535 if (written < 0) {
2536 error_errno(_("could not write to '%s'"), git_path_head_file());
2537 rollback_lock_file(&head_lock);
2538 return -1;
2540 if (commit_lock_file(&head_lock) < 0)
2541 return error(_("failed to finalize '%s'"), git_path_head_file());
2542 return 0;
2545 static int rollback_is_safe(void)
2547 struct strbuf sb = STRBUF_INIT;
2548 struct object_id expected_head, actual_head;
2550 if (strbuf_read_file(&sb, git_path_abort_safety_file(), 0) >= 0) {
2551 strbuf_trim(&sb);
2552 if (get_oid_hex(sb.buf, &expected_head)) {
2553 strbuf_release(&sb);
2554 die(_("could not parse %s"), git_path_abort_safety_file());
2556 strbuf_release(&sb);
2558 else if (errno == ENOENT)
2559 oidclr(&expected_head);
2560 else
2561 die_errno(_("could not read '%s'"), git_path_abort_safety_file());
2563 if (get_oid("HEAD", &actual_head))
2564 oidclr(&actual_head);
2566 return oideq(&actual_head, &expected_head);
2569 static int reset_for_rollback(const struct object_id *oid)
2571 const char *argv[4]; /* reset --merge <arg> + NULL */
2573 argv[0] = "reset";
2574 argv[1] = "--merge";
2575 argv[2] = oid_to_hex(oid);
2576 argv[3] = NULL;
2577 return run_command_v_opt(argv, RUN_GIT_CMD);
2580 static int rollback_single_pick(struct repository *r)
2582 struct object_id head_oid;
2584 if (!file_exists(git_path_cherry_pick_head(r)) &&
2585 !file_exists(git_path_revert_head(r)))
2586 return error(_("no cherry-pick or revert in progress"));
2587 if (read_ref_full("HEAD", 0, &head_oid, NULL))
2588 return error(_("cannot resolve HEAD"));
2589 if (is_null_oid(&head_oid))
2590 return error(_("cannot abort from a branch yet to be born"));
2591 return reset_for_rollback(&head_oid);
2594 int sequencer_rollback(struct repository *r, struct replay_opts *opts)
2596 FILE *f;
2597 struct object_id oid;
2598 struct strbuf buf = STRBUF_INIT;
2599 const char *p;
2601 f = fopen(git_path_head_file(), "r");
2602 if (!f && errno == ENOENT) {
2604 * There is no multiple-cherry-pick in progress.
2605 * If CHERRY_PICK_HEAD or REVERT_HEAD indicates
2606 * a single-cherry-pick in progress, abort that.
2608 return rollback_single_pick(r);
2610 if (!f)
2611 return error_errno(_("cannot open '%s'"), git_path_head_file());
2612 if (strbuf_getline_lf(&buf, f)) {
2613 error(_("cannot read '%s': %s"), git_path_head_file(),
2614 ferror(f) ? strerror(errno) : _("unexpected end of file"));
2615 fclose(f);
2616 goto fail;
2618 fclose(f);
2619 if (parse_oid_hex(buf.buf, &oid, &p) || *p != '\0') {
2620 error(_("stored pre-cherry-pick HEAD file '%s' is corrupt"),
2621 git_path_head_file());
2622 goto fail;
2624 if (is_null_oid(&oid)) {
2625 error(_("cannot abort from a branch yet to be born"));
2626 goto fail;
2629 if (!rollback_is_safe()) {
2630 /* Do not error, just do not rollback */
2631 warning(_("You seem to have moved HEAD. "
2632 "Not rewinding, check your HEAD!"));
2633 } else
2634 if (reset_for_rollback(&oid))
2635 goto fail;
2636 strbuf_release(&buf);
2637 return sequencer_remove_state(opts);
2638 fail:
2639 strbuf_release(&buf);
2640 return -1;
2643 static int save_todo(struct todo_list *todo_list, struct replay_opts *opts)
2645 struct lock_file todo_lock = LOCK_INIT;
2646 const char *todo_path = get_todo_path(opts);
2647 int next = todo_list->current, offset, fd;
2650 * rebase -i writes "git-rebase-todo" without the currently executing
2651 * command, appending it to "done" instead.
2653 if (is_rebase_i(opts))
2654 next++;
2656 fd = hold_lock_file_for_update(&todo_lock, todo_path, 0);
2657 if (fd < 0)
2658 return error_errno(_("could not lock '%s'"), todo_path);
2659 offset = get_item_line_offset(todo_list, next);
2660 if (write_in_full(fd, todo_list->buf.buf + offset,
2661 todo_list->buf.len - offset) < 0)
2662 return error_errno(_("could not write to '%s'"), todo_path);
2663 if (commit_lock_file(&todo_lock) < 0)
2664 return error(_("failed to finalize '%s'"), todo_path);
2666 if (is_rebase_i(opts) && next > 0) {
2667 const char *done = rebase_path_done();
2668 int fd = open(done, O_CREAT | O_WRONLY | O_APPEND, 0666);
2669 int ret = 0;
2671 if (fd < 0)
2672 return 0;
2673 if (write_in_full(fd, get_item_line(todo_list, next - 1),
2674 get_item_line_length(todo_list, next - 1))
2675 < 0)
2676 ret = error_errno(_("could not write to '%s'"), done);
2677 if (close(fd) < 0)
2678 ret = error_errno(_("failed to finalize '%s'"), done);
2679 return ret;
2681 return 0;
2684 static int save_opts(struct replay_opts *opts)
2686 const char *opts_file = git_path_opts_file();
2687 int res = 0;
2689 if (opts->no_commit)
2690 res |= git_config_set_in_file_gently(opts_file, "options.no-commit", "true");
2691 if (opts->edit)
2692 res |= git_config_set_in_file_gently(opts_file, "options.edit", "true");
2693 if (opts->signoff)
2694 res |= git_config_set_in_file_gently(opts_file, "options.signoff", "true");
2695 if (opts->record_origin)
2696 res |= git_config_set_in_file_gently(opts_file, "options.record-origin", "true");
2697 if (opts->allow_ff)
2698 res |= git_config_set_in_file_gently(opts_file, "options.allow-ff", "true");
2699 if (opts->mainline) {
2700 struct strbuf buf = STRBUF_INIT;
2701 strbuf_addf(&buf, "%d", opts->mainline);
2702 res |= git_config_set_in_file_gently(opts_file, "options.mainline", buf.buf);
2703 strbuf_release(&buf);
2705 if (opts->strategy)
2706 res |= git_config_set_in_file_gently(opts_file, "options.strategy", opts->strategy);
2707 if (opts->gpg_sign)
2708 res |= git_config_set_in_file_gently(opts_file, "options.gpg-sign", opts->gpg_sign);
2709 if (opts->xopts) {
2710 int i;
2711 for (i = 0; i < opts->xopts_nr; i++)
2712 res |= git_config_set_multivar_in_file_gently(opts_file,
2713 "options.strategy-option",
2714 opts->xopts[i], "^$", 0);
2716 if (opts->allow_rerere_auto)
2717 res |= git_config_set_in_file_gently(opts_file, "options.allow-rerere-auto",
2718 opts->allow_rerere_auto == RERERE_AUTOUPDATE ?
2719 "true" : "false");
2720 return res;
2723 static int make_patch(struct repository *r,
2724 struct commit *commit,
2725 struct replay_opts *opts)
2727 struct strbuf buf = STRBUF_INIT;
2728 struct rev_info log_tree_opt;
2729 const char *subject, *p;
2730 int res = 0;
2732 p = short_commit_name(commit);
2733 if (write_message(p, strlen(p), rebase_path_stopped_sha(), 1) < 0)
2734 return -1;
2735 if (update_ref("rebase", "REBASE_HEAD", &commit->object.oid,
2736 NULL, REF_NO_DEREF, UPDATE_REFS_MSG_ON_ERR))
2737 res |= error(_("could not update %s"), "REBASE_HEAD");
2739 strbuf_addf(&buf, "%s/patch", get_dir(opts));
2740 memset(&log_tree_opt, 0, sizeof(log_tree_opt));
2741 repo_init_revisions(r, &log_tree_opt, NULL);
2742 log_tree_opt.abbrev = 0;
2743 log_tree_opt.diff = 1;
2744 log_tree_opt.diffopt.output_format = DIFF_FORMAT_PATCH;
2745 log_tree_opt.disable_stdin = 1;
2746 log_tree_opt.no_commit_id = 1;
2747 log_tree_opt.diffopt.file = fopen(buf.buf, "w");
2748 log_tree_opt.diffopt.use_color = GIT_COLOR_NEVER;
2749 if (!log_tree_opt.diffopt.file)
2750 res |= error_errno(_("could not open '%s'"), buf.buf);
2751 else {
2752 res |= log_tree_commit(&log_tree_opt, commit);
2753 fclose(log_tree_opt.diffopt.file);
2755 strbuf_reset(&buf);
2757 strbuf_addf(&buf, "%s/message", get_dir(opts));
2758 if (!file_exists(buf.buf)) {
2759 const char *commit_buffer = get_commit_buffer(commit, NULL);
2760 find_commit_subject(commit_buffer, &subject);
2761 res |= write_message(subject, strlen(subject), buf.buf, 1);
2762 unuse_commit_buffer(commit, commit_buffer);
2764 strbuf_release(&buf);
2766 return res;
2769 static int intend_to_amend(void)
2771 struct object_id head;
2772 char *p;
2774 if (get_oid("HEAD", &head))
2775 return error(_("cannot read HEAD"));
2777 p = oid_to_hex(&head);
2778 return write_message(p, strlen(p), rebase_path_amend(), 1);
2781 static int error_with_patch(struct repository *r,
2782 struct commit *commit,
2783 const char *subject, int subject_len,
2784 struct replay_opts *opts,
2785 int exit_code, int to_amend)
2787 if (commit) {
2788 if (make_patch(r, commit, opts))
2789 return -1;
2790 } else if (copy_file(rebase_path_message(),
2791 git_path_merge_msg(r), 0666))
2792 return error(_("unable to copy '%s' to '%s'"),
2793 git_path_merge_msg(r), rebase_path_message());
2795 if (to_amend) {
2796 if (intend_to_amend())
2797 return -1;
2799 fprintf(stderr,
2800 _("You can amend the commit now, with\n"
2801 "\n"
2802 " git commit --amend %s\n"
2803 "\n"
2804 "Once you are satisfied with your changes, run\n"
2805 "\n"
2806 " git rebase --continue\n"),
2807 gpg_sign_opt_quoted(opts));
2808 } else if (exit_code) {
2809 if (commit)
2810 fprintf_ln(stderr, _("Could not apply %s... %.*s"),
2811 short_commit_name(commit), subject_len, subject);
2812 else
2814 * We don't have the hash of the parent so
2815 * just print the line from the todo file.
2817 fprintf_ln(stderr, _("Could not merge %.*s"),
2818 subject_len, subject);
2821 return exit_code;
2824 static int error_failed_squash(struct repository *r,
2825 struct commit *commit,
2826 struct replay_opts *opts,
2827 int subject_len,
2828 const char *subject)
2830 if (copy_file(rebase_path_message(), rebase_path_squash_msg(), 0666))
2831 return error(_("could not copy '%s' to '%s'"),
2832 rebase_path_squash_msg(), rebase_path_message());
2833 unlink(git_path_merge_msg(r));
2834 if (copy_file(git_path_merge_msg(r), rebase_path_message(), 0666))
2835 return error(_("could not copy '%s' to '%s'"),
2836 rebase_path_message(),
2837 git_path_merge_msg(r));
2838 return error_with_patch(r, commit, subject, subject_len, opts, 1, 0);
2841 static int do_exec(struct repository *r, const char *command_line)
2843 struct argv_array child_env = ARGV_ARRAY_INIT;
2844 const char *child_argv[] = { NULL, NULL };
2845 int dirty, status;
2847 fprintf(stderr, "Executing: %s\n", command_line);
2848 child_argv[0] = command_line;
2849 argv_array_pushf(&child_env, "GIT_DIR=%s", absolute_path(get_git_dir()));
2850 argv_array_pushf(&child_env, "GIT_WORK_TREE=%s",
2851 absolute_path(get_git_work_tree()));
2852 status = run_command_v_opt_cd_env(child_argv, RUN_USING_SHELL, NULL,
2853 child_env.argv);
2855 /* force re-reading of the cache */
2856 if (discard_index(r->index) < 0 || read_index(r->index) < 0)
2857 return error(_("could not read index"));
2859 dirty = require_clean_work_tree(r, "rebase", NULL, 1, 1);
2861 if (status) {
2862 warning(_("execution failed: %s\n%s"
2863 "You can fix the problem, and then run\n"
2864 "\n"
2865 " git rebase --continue\n"
2866 "\n"),
2867 command_line,
2868 dirty ? N_("and made changes to the index and/or the "
2869 "working tree\n") : "");
2870 if (status == 127)
2871 /* command not found */
2872 status = 1;
2873 } else if (dirty) {
2874 warning(_("execution succeeded: %s\nbut "
2875 "left changes to the index and/or the working tree\n"
2876 "Commit or stash your changes, and then run\n"
2877 "\n"
2878 " git rebase --continue\n"
2879 "\n"), command_line);
2880 status = 1;
2883 argv_array_clear(&child_env);
2885 return status;
2888 static int safe_append(const char *filename, const char *fmt, ...)
2890 va_list ap;
2891 struct lock_file lock = LOCK_INIT;
2892 int fd = hold_lock_file_for_update(&lock, filename,
2893 LOCK_REPORT_ON_ERROR);
2894 struct strbuf buf = STRBUF_INIT;
2896 if (fd < 0)
2897 return -1;
2899 if (strbuf_read_file(&buf, filename, 0) < 0 && errno != ENOENT) {
2900 error_errno(_("could not read '%s'"), filename);
2901 rollback_lock_file(&lock);
2902 return -1;
2904 strbuf_complete(&buf, '\n');
2905 va_start(ap, fmt);
2906 strbuf_vaddf(&buf, fmt, ap);
2907 va_end(ap);
2909 if (write_in_full(fd, buf.buf, buf.len) < 0) {
2910 error_errno(_("could not write to '%s'"), filename);
2911 strbuf_release(&buf);
2912 rollback_lock_file(&lock);
2913 return -1;
2915 if (commit_lock_file(&lock) < 0) {
2916 strbuf_release(&buf);
2917 rollback_lock_file(&lock);
2918 return error(_("failed to finalize '%s'"), filename);
2921 strbuf_release(&buf);
2922 return 0;
2925 static int do_label(struct repository *r, const char *name, int len)
2927 struct ref_store *refs = get_main_ref_store(r);
2928 struct ref_transaction *transaction;
2929 struct strbuf ref_name = STRBUF_INIT, err = STRBUF_INIT;
2930 struct strbuf msg = STRBUF_INIT;
2931 int ret = 0;
2932 struct object_id head_oid;
2934 if (len == 1 && *name == '#')
2935 return error(_("illegal label name: '%.*s'"), len, name);
2937 strbuf_addf(&ref_name, "refs/rewritten/%.*s", len, name);
2938 strbuf_addf(&msg, "rebase -i (label) '%.*s'", len, name);
2940 transaction = ref_store_transaction_begin(refs, &err);
2941 if (!transaction) {
2942 error("%s", err.buf);
2943 ret = -1;
2944 } else if (get_oid("HEAD", &head_oid)) {
2945 error(_("could not read HEAD"));
2946 ret = -1;
2947 } else if (ref_transaction_update(transaction, ref_name.buf, &head_oid,
2948 NULL, 0, msg.buf, &err) < 0 ||
2949 ref_transaction_commit(transaction, &err)) {
2950 error("%s", err.buf);
2951 ret = -1;
2953 ref_transaction_free(transaction);
2954 strbuf_release(&err);
2955 strbuf_release(&msg);
2957 if (!ret)
2958 ret = safe_append(rebase_path_refs_to_delete(),
2959 "%s\n", ref_name.buf);
2960 strbuf_release(&ref_name);
2962 return ret;
2965 static const char *reflog_message(struct replay_opts *opts,
2966 const char *sub_action, const char *fmt, ...);
2968 static int do_reset(struct repository *r,
2969 const char *name, int len,
2970 struct replay_opts *opts)
2972 struct strbuf ref_name = STRBUF_INIT;
2973 struct object_id oid;
2974 struct lock_file lock = LOCK_INIT;
2975 struct tree_desc desc;
2976 struct tree *tree;
2977 struct unpack_trees_options unpack_tree_opts;
2978 int ret = 0;
2980 if (hold_locked_index(&lock, LOCK_REPORT_ON_ERROR) < 0)
2981 return -1;
2983 if (len == 10 && !strncmp("[new root]", name, len)) {
2984 if (!opts->have_squash_onto) {
2985 const char *hex;
2986 if (commit_tree("", 0, the_hash_algo->empty_tree,
2987 NULL, &opts->squash_onto,
2988 NULL, NULL))
2989 return error(_("writing fake root commit"));
2990 opts->have_squash_onto = 1;
2991 hex = oid_to_hex(&opts->squash_onto);
2992 if (write_message(hex, strlen(hex),
2993 rebase_path_squash_onto(), 0))
2994 return error(_("writing squash-onto"));
2996 oidcpy(&oid, &opts->squash_onto);
2997 } else {
2998 int i;
3000 /* Determine the length of the label */
3001 for (i = 0; i < len; i++)
3002 if (isspace(name[i]))
3003 break;
3004 len = i;
3006 strbuf_addf(&ref_name, "refs/rewritten/%.*s", len, name);
3007 if (get_oid(ref_name.buf, &oid) &&
3008 get_oid(ref_name.buf + strlen("refs/rewritten/"), &oid)) {
3009 error(_("could not read '%s'"), ref_name.buf);
3010 rollback_lock_file(&lock);
3011 strbuf_release(&ref_name);
3012 return -1;
3016 memset(&unpack_tree_opts, 0, sizeof(unpack_tree_opts));
3017 setup_unpack_trees_porcelain(&unpack_tree_opts, "reset");
3018 unpack_tree_opts.head_idx = 1;
3019 unpack_tree_opts.src_index = r->index;
3020 unpack_tree_opts.dst_index = r->index;
3021 unpack_tree_opts.fn = oneway_merge;
3022 unpack_tree_opts.merge = 1;
3023 unpack_tree_opts.update = 1;
3025 if (read_index_unmerged(r->index)) {
3026 rollback_lock_file(&lock);
3027 strbuf_release(&ref_name);
3028 return error_resolve_conflict(_(action_name(opts)));
3031 if (!fill_tree_descriptor(&desc, &oid)) {
3032 error(_("failed to find tree of %s"), oid_to_hex(&oid));
3033 rollback_lock_file(&lock);
3034 free((void *)desc.buffer);
3035 strbuf_release(&ref_name);
3036 return -1;
3039 if (unpack_trees(1, &desc, &unpack_tree_opts)) {
3040 rollback_lock_file(&lock);
3041 free((void *)desc.buffer);
3042 strbuf_release(&ref_name);
3043 return -1;
3046 tree = parse_tree_indirect(&oid);
3047 prime_cache_tree(r, r->index, tree);
3049 if (write_locked_index(r->index, &lock, COMMIT_LOCK) < 0)
3050 ret = error(_("could not write index"));
3051 free((void *)desc.buffer);
3053 if (!ret)
3054 ret = update_ref(reflog_message(opts, "reset", "'%.*s'",
3055 len, name), "HEAD", &oid,
3056 NULL, 0, UPDATE_REFS_MSG_ON_ERR);
3058 strbuf_release(&ref_name);
3059 return ret;
3062 static struct commit *lookup_label(const char *label, int len,
3063 struct strbuf *buf)
3065 struct commit *commit;
3067 strbuf_reset(buf);
3068 strbuf_addf(buf, "refs/rewritten/%.*s", len, label);
3069 commit = lookup_commit_reference_by_name(buf->buf);
3070 if (!commit) {
3071 /* fall back to non-rewritten ref or commit */
3072 strbuf_splice(buf, 0, strlen("refs/rewritten/"), "", 0);
3073 commit = lookup_commit_reference_by_name(buf->buf);
3076 if (!commit)
3077 error(_("could not resolve '%s'"), buf->buf);
3079 return commit;
3082 static int do_merge(struct repository *r,
3083 struct commit *commit,
3084 const char *arg, int arg_len,
3085 int flags, struct replay_opts *opts)
3087 int run_commit_flags = (flags & TODO_EDIT_MERGE_MSG) ?
3088 EDIT_MSG | VERIFY_MSG : 0;
3089 struct strbuf ref_name = STRBUF_INIT;
3090 struct commit *head_commit, *merge_commit, *i;
3091 struct commit_list *bases, *j, *reversed = NULL;
3092 struct commit_list *to_merge = NULL, **tail = &to_merge;
3093 struct merge_options o;
3094 int merge_arg_len, oneline_offset, can_fast_forward, ret, k;
3095 static struct lock_file lock;
3096 const char *p;
3098 if (hold_locked_index(&lock, LOCK_REPORT_ON_ERROR) < 0) {
3099 ret = -1;
3100 goto leave_merge;
3103 head_commit = lookup_commit_reference_by_name("HEAD");
3104 if (!head_commit) {
3105 ret = error(_("cannot merge without a current revision"));
3106 goto leave_merge;
3110 * For octopus merges, the arg starts with the list of revisions to be
3111 * merged. The list is optionally followed by '#' and the oneline.
3113 merge_arg_len = oneline_offset = arg_len;
3114 for (p = arg; p - arg < arg_len; p += strspn(p, " \t\n")) {
3115 if (!*p)
3116 break;
3117 if (*p == '#' && (!p[1] || isspace(p[1]))) {
3118 p += 1 + strspn(p + 1, " \t\n");
3119 oneline_offset = p - arg;
3120 break;
3122 k = strcspn(p, " \t\n");
3123 if (!k)
3124 continue;
3125 merge_commit = lookup_label(p, k, &ref_name);
3126 if (!merge_commit) {
3127 ret = error(_("unable to parse '%.*s'"), k, p);
3128 goto leave_merge;
3130 tail = &commit_list_insert(merge_commit, tail)->next;
3131 p += k;
3132 merge_arg_len = p - arg;
3135 if (!to_merge) {
3136 ret = error(_("nothing to merge: '%.*s'"), arg_len, arg);
3137 goto leave_merge;
3140 if (opts->have_squash_onto &&
3141 oideq(&head_commit->object.oid, &opts->squash_onto)) {
3143 * When the user tells us to "merge" something into a
3144 * "[new root]", let's simply fast-forward to the merge head.
3146 rollback_lock_file(&lock);
3147 if (to_merge->next)
3148 ret = error(_("octopus merge cannot be executed on "
3149 "top of a [new root]"));
3150 else
3151 ret = fast_forward_to(r, &to_merge->item->object.oid,
3152 &head_commit->object.oid, 0,
3153 opts);
3154 goto leave_merge;
3157 if (commit) {
3158 const char *message = get_commit_buffer(commit, NULL);
3159 const char *body;
3160 int len;
3162 if (!message) {
3163 ret = error(_("could not get commit message of '%s'"),
3164 oid_to_hex(&commit->object.oid));
3165 goto leave_merge;
3167 write_author_script(message);
3168 find_commit_subject(message, &body);
3169 len = strlen(body);
3170 ret = write_message(body, len, git_path_merge_msg(r), 0);
3171 unuse_commit_buffer(commit, message);
3172 if (ret) {
3173 error_errno(_("could not write '%s'"),
3174 git_path_merge_msg(r));
3175 goto leave_merge;
3177 } else {
3178 struct strbuf buf = STRBUF_INIT;
3179 int len;
3181 strbuf_addf(&buf, "author %s", git_author_info(0));
3182 write_author_script(buf.buf);
3183 strbuf_reset(&buf);
3185 if (oneline_offset < arg_len) {
3186 p = arg + oneline_offset;
3187 len = arg_len - oneline_offset;
3188 } else {
3189 strbuf_addf(&buf, "Merge %s '%.*s'",
3190 to_merge->next ? "branches" : "branch",
3191 merge_arg_len, arg);
3192 p = buf.buf;
3193 len = buf.len;
3196 ret = write_message(p, len, git_path_merge_msg(r), 0);
3197 strbuf_release(&buf);
3198 if (ret) {
3199 error_errno(_("could not write '%s'"),
3200 git_path_merge_msg(r));
3201 goto leave_merge;
3206 * If HEAD is not identical to the first parent of the original merge
3207 * commit, we cannot fast-forward.
3209 can_fast_forward = opts->allow_ff && commit && commit->parents &&
3210 oideq(&commit->parents->item->object.oid,
3211 &head_commit->object.oid);
3214 * If any merge head is different from the original one, we cannot
3215 * fast-forward.
3217 if (can_fast_forward) {
3218 struct commit_list *p = commit->parents->next;
3220 for (j = to_merge; j && p; j = j->next, p = p->next)
3221 if (!oideq(&j->item->object.oid,
3222 &p->item->object.oid)) {
3223 can_fast_forward = 0;
3224 break;
3227 * If the number of merge heads differs from the original merge
3228 * commit, we cannot fast-forward.
3230 if (j || p)
3231 can_fast_forward = 0;
3234 if (can_fast_forward) {
3235 rollback_lock_file(&lock);
3236 ret = fast_forward_to(r, &commit->object.oid,
3237 &head_commit->object.oid, 0, opts);
3238 goto leave_merge;
3241 if (to_merge->next) {
3242 /* Octopus merge */
3243 struct child_process cmd = CHILD_PROCESS_INIT;
3245 if (read_env_script(&cmd.env_array)) {
3246 const char *gpg_opt = gpg_sign_opt_quoted(opts);
3248 ret = error(_(staged_changes_advice), gpg_opt, gpg_opt);
3249 goto leave_merge;
3252 cmd.git_cmd = 1;
3253 argv_array_push(&cmd.args, "merge");
3254 argv_array_push(&cmd.args, "-s");
3255 argv_array_push(&cmd.args, "octopus");
3256 argv_array_push(&cmd.args, "--no-edit");
3257 argv_array_push(&cmd.args, "--no-ff");
3258 argv_array_push(&cmd.args, "--no-log");
3259 argv_array_push(&cmd.args, "--no-stat");
3260 argv_array_push(&cmd.args, "-F");
3261 argv_array_push(&cmd.args, git_path_merge_msg(r));
3262 if (opts->gpg_sign)
3263 argv_array_push(&cmd.args, opts->gpg_sign);
3265 /* Add the tips to be merged */
3266 for (j = to_merge; j; j = j->next)
3267 argv_array_push(&cmd.args,
3268 oid_to_hex(&j->item->object.oid));
3270 strbuf_release(&ref_name);
3271 unlink(git_path_cherry_pick_head(r));
3272 rollback_lock_file(&lock);
3274 rollback_lock_file(&lock);
3275 ret = run_command(&cmd);
3277 /* force re-reading of the cache */
3278 if (!ret && (discard_index(r->index) < 0 ||
3279 read_index(r->index) < 0))
3280 ret = error(_("could not read index"));
3281 goto leave_merge;
3284 merge_commit = to_merge->item;
3285 bases = get_merge_bases(head_commit, merge_commit);
3286 if (bases && oideq(&merge_commit->object.oid,
3287 &bases->item->object.oid)) {
3288 ret = 0;
3289 /* skip merging an ancestor of HEAD */
3290 goto leave_merge;
3293 write_message(oid_to_hex(&merge_commit->object.oid), GIT_SHA1_HEXSZ,
3294 git_path_merge_head(r), 0);
3295 write_message("no-ff", 5, git_path_merge_mode(r), 0);
3297 for (j = bases; j; j = j->next)
3298 commit_list_insert(j->item, &reversed);
3299 free_commit_list(bases);
3301 read_index(r->index);
3302 init_merge_options(&o);
3303 o.branch1 = "HEAD";
3304 o.branch2 = ref_name.buf;
3305 o.buffer_output = 2;
3307 ret = merge_recursive(&o, head_commit, merge_commit, reversed, &i);
3308 if (ret <= 0)
3309 fputs(o.obuf.buf, stdout);
3310 strbuf_release(&o.obuf);
3311 if (ret < 0) {
3312 error(_("could not even attempt to merge '%.*s'"),
3313 merge_arg_len, arg);
3314 goto leave_merge;
3317 * The return value of merge_recursive() is 1 on clean, and 0 on
3318 * unclean merge.
3320 * Let's reverse that, so that do_merge() returns 0 upon success and
3321 * 1 upon failed merge (keeping the return value -1 for the cases where
3322 * we will want to reschedule the `merge` command).
3324 ret = !ret;
3326 if (r->index->cache_changed &&
3327 write_locked_index(r->index, &lock, COMMIT_LOCK)) {
3328 ret = error(_("merge: Unable to write new index file"));
3329 goto leave_merge;
3332 rollback_lock_file(&lock);
3333 if (ret)
3334 repo_rerere(r, opts->allow_rerere_auto);
3335 else
3337 * In case of problems, we now want to return a positive
3338 * value (a negative one would indicate that the `merge`
3339 * command needs to be rescheduled).
3341 ret = !!run_git_commit(r, git_path_merge_msg(r), opts,
3342 run_commit_flags);
3344 leave_merge:
3345 strbuf_release(&ref_name);
3346 rollback_lock_file(&lock);
3347 free_commit_list(to_merge);
3348 return ret;
3351 static int is_final_fixup(struct todo_list *todo_list)
3353 int i = todo_list->current;
3355 if (!is_fixup(todo_list->items[i].command))
3356 return 0;
3358 while (++i < todo_list->nr)
3359 if (is_fixup(todo_list->items[i].command))
3360 return 0;
3361 else if (!is_noop(todo_list->items[i].command))
3362 break;
3363 return 1;
3366 static enum todo_command peek_command(struct todo_list *todo_list, int offset)
3368 int i;
3370 for (i = todo_list->current + offset; i < todo_list->nr; i++)
3371 if (!is_noop(todo_list->items[i].command))
3372 return todo_list->items[i].command;
3374 return -1;
3377 static int apply_autostash(struct replay_opts *opts)
3379 struct strbuf stash_sha1 = STRBUF_INIT;
3380 struct child_process child = CHILD_PROCESS_INIT;
3381 int ret = 0;
3383 if (!read_oneliner(&stash_sha1, rebase_path_autostash(), 1)) {
3384 strbuf_release(&stash_sha1);
3385 return 0;
3387 strbuf_trim(&stash_sha1);
3389 child.git_cmd = 1;
3390 child.no_stdout = 1;
3391 child.no_stderr = 1;
3392 argv_array_push(&child.args, "stash");
3393 argv_array_push(&child.args, "apply");
3394 argv_array_push(&child.args, stash_sha1.buf);
3395 if (!run_command(&child))
3396 fprintf(stderr, _("Applied autostash.\n"));
3397 else {
3398 struct child_process store = CHILD_PROCESS_INIT;
3400 store.git_cmd = 1;
3401 argv_array_push(&store.args, "stash");
3402 argv_array_push(&store.args, "store");
3403 argv_array_push(&store.args, "-m");
3404 argv_array_push(&store.args, "autostash");
3405 argv_array_push(&store.args, "-q");
3406 argv_array_push(&store.args, stash_sha1.buf);
3407 if (run_command(&store))
3408 ret = error(_("cannot store %s"), stash_sha1.buf);
3409 else
3410 fprintf(stderr,
3411 _("Applying autostash resulted in conflicts.\n"
3412 "Your changes are safe in the stash.\n"
3413 "You can run \"git stash pop\" or"
3414 " \"git stash drop\" at any time.\n"));
3417 strbuf_release(&stash_sha1);
3418 return ret;
3421 static const char *reflog_message(struct replay_opts *opts,
3422 const char *sub_action, const char *fmt, ...)
3424 va_list ap;
3425 static struct strbuf buf = STRBUF_INIT;
3427 va_start(ap, fmt);
3428 strbuf_reset(&buf);
3429 strbuf_addstr(&buf, action_name(opts));
3430 if (sub_action)
3431 strbuf_addf(&buf, " (%s)", sub_action);
3432 if (fmt) {
3433 strbuf_addstr(&buf, ": ");
3434 strbuf_vaddf(&buf, fmt, ap);
3436 va_end(ap);
3438 return buf.buf;
3441 static int run_git_checkout(struct replay_opts *opts, const char *commit,
3442 const char *action)
3444 struct child_process cmd = CHILD_PROCESS_INIT;
3446 cmd.git_cmd = 1;
3448 argv_array_push(&cmd.args, "checkout");
3449 argv_array_push(&cmd.args, commit);
3450 argv_array_pushf(&cmd.env_array, GIT_REFLOG_ACTION "=%s", action);
3452 if (opts->verbose)
3453 return run_command(&cmd);
3454 else
3455 return run_command_silent_on_success(&cmd);
3458 int prepare_branch_to_be_rebased(struct replay_opts *opts, const char *commit)
3460 const char *action;
3462 if (commit && *commit) {
3463 action = reflog_message(opts, "start", "checkout %s", commit);
3464 if (run_git_checkout(opts, commit, action))
3465 return error(_("could not checkout %s"), commit);
3468 return 0;
3471 static int checkout_onto(struct replay_opts *opts,
3472 const char *onto_name, const char *onto,
3473 const char *orig_head)
3475 struct object_id oid;
3476 const char *action = reflog_message(opts, "start", "checkout %s", onto_name);
3478 if (get_oid(orig_head, &oid))
3479 return error(_("%s: not a valid OID"), orig_head);
3481 if (run_git_checkout(opts, onto, action)) {
3482 apply_autostash(opts);
3483 sequencer_remove_state(opts);
3484 return error(_("could not detach HEAD"));
3487 return update_ref(NULL, "ORIG_HEAD", &oid, NULL, 0, UPDATE_REFS_MSG_ON_ERR);
3490 static int stopped_at_head(struct repository *r)
3492 struct object_id head;
3493 struct commit *commit;
3494 struct commit_message message;
3496 if (get_oid("HEAD", &head) ||
3497 !(commit = lookup_commit(r, &head)) ||
3498 parse_commit(commit) || get_message(commit, &message))
3499 fprintf(stderr, _("Stopped at HEAD\n"));
3500 else {
3501 fprintf(stderr, _("Stopped at %s\n"), message.label);
3502 free_message(commit, &message);
3504 return 0;
3508 static const char rescheduled_advice[] =
3509 N_("Could not execute the todo command\n"
3510 "\n"
3511 " %.*s"
3512 "\n"
3513 "It has been rescheduled; To edit the command before continuing, please\n"
3514 "edit the todo list first:\n"
3515 "\n"
3516 " git rebase --edit-todo\n"
3517 " git rebase --continue\n");
3519 static int pick_commits(struct repository *r,
3520 struct todo_list *todo_list,
3521 struct replay_opts *opts)
3523 int res = 0, reschedule = 0;
3525 setenv(GIT_REFLOG_ACTION, action_name(opts), 0);
3526 if (opts->allow_ff)
3527 assert(!(opts->signoff || opts->no_commit ||
3528 opts->record_origin || opts->edit));
3529 if (read_and_refresh_cache(r, opts))
3530 return -1;
3532 while (todo_list->current < todo_list->nr) {
3533 struct todo_item *item = todo_list->items + todo_list->current;
3534 if (save_todo(todo_list, opts))
3535 return -1;
3536 if (is_rebase_i(opts)) {
3537 if (item->command != TODO_COMMENT) {
3538 FILE *f = fopen(rebase_path_msgnum(), "w");
3540 todo_list->done_nr++;
3542 if (f) {
3543 fprintf(f, "%d\n", todo_list->done_nr);
3544 fclose(f);
3546 fprintf(stderr, "Rebasing (%d/%d)%s",
3547 todo_list->done_nr,
3548 todo_list->total_nr,
3549 opts->verbose ? "\n" : "\r");
3551 unlink(rebase_path_message());
3552 unlink(rebase_path_author_script());
3553 unlink(rebase_path_stopped_sha());
3554 unlink(rebase_path_amend());
3555 unlink(git_path_merge_head(the_repository));
3556 delete_ref(NULL, "REBASE_HEAD", NULL, REF_NO_DEREF);
3558 if (item->command == TODO_BREAK)
3559 return stopped_at_head(r);
3561 if (item->command <= TODO_SQUASH) {
3562 if (is_rebase_i(opts))
3563 setenv("GIT_REFLOG_ACTION", reflog_message(opts,
3564 command_to_string(item->command), NULL),
3566 res = do_pick_commit(r, item->command, item->commit,
3567 opts, is_final_fixup(todo_list));
3568 if (is_rebase_i(opts) && res < 0) {
3569 /* Reschedule */
3570 advise(_(rescheduled_advice),
3571 get_item_line_length(todo_list,
3572 todo_list->current),
3573 get_item_line(todo_list,
3574 todo_list->current));
3575 todo_list->current--;
3576 if (save_todo(todo_list, opts))
3577 return -1;
3579 if (item->command == TODO_EDIT) {
3580 struct commit *commit = item->commit;
3581 if (!res)
3582 fprintf(stderr,
3583 _("Stopped at %s... %.*s\n"),
3584 short_commit_name(commit),
3585 item->arg_len, item->arg);
3586 return error_with_patch(r, commit,
3587 item->arg, item->arg_len, opts, res,
3588 !res);
3590 if (is_rebase_i(opts) && !res)
3591 record_in_rewritten(&item->commit->object.oid,
3592 peek_command(todo_list, 1));
3593 if (res && is_fixup(item->command)) {
3594 if (res == 1)
3595 intend_to_amend();
3596 return error_failed_squash(r, item->commit, opts,
3597 item->arg_len, item->arg);
3598 } else if (res && is_rebase_i(opts) && item->commit) {
3599 int to_amend = 0;
3600 struct object_id oid;
3603 * If we are rewording and have either
3604 * fast-forwarded already, or are about to
3605 * create a new root commit, we want to amend,
3606 * otherwise we do not.
3608 if (item->command == TODO_REWORD &&
3609 !get_oid("HEAD", &oid) &&
3610 (oideq(&item->commit->object.oid, &oid) ||
3611 (opts->have_squash_onto &&
3612 oideq(&opts->squash_onto, &oid))))
3613 to_amend = 1;
3615 return res | error_with_patch(r, item->commit,
3616 item->arg, item->arg_len, opts,
3617 res, to_amend);
3619 } else if (item->command == TODO_EXEC) {
3620 char *end_of_arg = (char *)(item->arg + item->arg_len);
3621 int saved = *end_of_arg;
3622 struct stat st;
3624 *end_of_arg = '\0';
3625 res = do_exec(r, item->arg);
3626 *end_of_arg = saved;
3628 /* Reread the todo file if it has changed. */
3629 if (res)
3630 ; /* fall through */
3631 else if (stat(get_todo_path(opts), &st))
3632 res = error_errno(_("could not stat '%s'"),
3633 get_todo_path(opts));
3634 else if (match_stat_data(&todo_list->stat, &st)) {
3635 todo_list_release(todo_list);
3636 if (read_populate_todo(r, todo_list, opts))
3637 res = -1; /* message was printed */
3638 /* `current` will be incremented below */
3639 todo_list->current = -1;
3641 } else if (item->command == TODO_LABEL) {
3642 if ((res = do_label(r, item->arg, item->arg_len)))
3643 reschedule = 1;
3644 } else if (item->command == TODO_RESET) {
3645 if ((res = do_reset(r, item->arg, item->arg_len, opts)))
3646 reschedule = 1;
3647 } else if (item->command == TODO_MERGE) {
3648 if ((res = do_merge(r, item->commit,
3649 item->arg, item->arg_len,
3650 item->flags, opts)) < 0)
3651 reschedule = 1;
3652 else if (item->commit)
3653 record_in_rewritten(&item->commit->object.oid,
3654 peek_command(todo_list, 1));
3655 if (res > 0)
3656 /* failed with merge conflicts */
3657 return error_with_patch(r, item->commit,
3658 item->arg,
3659 item->arg_len, opts,
3660 res, 0);
3661 } else if (!is_noop(item->command))
3662 return error(_("unknown command %d"), item->command);
3664 if (reschedule) {
3665 advise(_(rescheduled_advice),
3666 get_item_line_length(todo_list,
3667 todo_list->current),
3668 get_item_line(todo_list, todo_list->current));
3669 todo_list->current--;
3670 if (save_todo(todo_list, opts))
3671 return -1;
3672 if (item->commit)
3673 return error_with_patch(r,
3674 item->commit,
3675 item->arg,
3676 item->arg_len, opts,
3677 res, 0);
3680 todo_list->current++;
3681 if (res)
3682 return res;
3685 if (is_rebase_i(opts)) {
3686 struct strbuf head_ref = STRBUF_INIT, buf = STRBUF_INIT;
3687 struct stat st;
3689 /* Stopped in the middle, as planned? */
3690 if (todo_list->current < todo_list->nr)
3691 return 0;
3693 if (read_oneliner(&head_ref, rebase_path_head_name(), 0) &&
3694 starts_with(head_ref.buf, "refs/")) {
3695 const char *msg;
3696 struct object_id head, orig;
3697 int res;
3699 if (get_oid("HEAD", &head)) {
3700 res = error(_("cannot read HEAD"));
3701 cleanup_head_ref:
3702 strbuf_release(&head_ref);
3703 strbuf_release(&buf);
3704 return res;
3706 if (!read_oneliner(&buf, rebase_path_orig_head(), 0) ||
3707 get_oid_hex(buf.buf, &orig)) {
3708 res = error(_("could not read orig-head"));
3709 goto cleanup_head_ref;
3711 strbuf_reset(&buf);
3712 if (!read_oneliner(&buf, rebase_path_onto(), 0)) {
3713 res = error(_("could not read 'onto'"));
3714 goto cleanup_head_ref;
3716 msg = reflog_message(opts, "finish", "%s onto %s",
3717 head_ref.buf, buf.buf);
3718 if (update_ref(msg, head_ref.buf, &head, &orig,
3719 REF_NO_DEREF, UPDATE_REFS_MSG_ON_ERR)) {
3720 res = error(_("could not update %s"),
3721 head_ref.buf);
3722 goto cleanup_head_ref;
3724 msg = reflog_message(opts, "finish", "returning to %s",
3725 head_ref.buf);
3726 if (create_symref("HEAD", head_ref.buf, msg)) {
3727 res = error(_("could not update HEAD to %s"),
3728 head_ref.buf);
3729 goto cleanup_head_ref;
3731 strbuf_reset(&buf);
3734 if (opts->verbose) {
3735 struct rev_info log_tree_opt;
3736 struct object_id orig, head;
3738 memset(&log_tree_opt, 0, sizeof(log_tree_opt));
3739 repo_init_revisions(r, &log_tree_opt, NULL