tests: always test fetch of unreachable with v0
[git.git] / sequencer.c
blob213815dbfc116bc7d9a11b1c7acc429fb078f732
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")
161 static GIT_PATH_FUNC(rebase_path_reschedule_failed_exec, "rebase-merge/reschedule-failed-exec")
163 static int git_sequencer_config(const char *k, const char *v, void *cb)
165 struct replay_opts *opts = cb;
166 int status;
168 if (!strcmp(k, "commit.cleanup")) {
169 const char *s;
171 status = git_config_string(&s, k, v);
172 if (status)
173 return status;
175 if (!strcmp(s, "verbatim"))
176 opts->default_msg_cleanup = COMMIT_MSG_CLEANUP_NONE;
177 else if (!strcmp(s, "whitespace"))
178 opts->default_msg_cleanup = COMMIT_MSG_CLEANUP_SPACE;
179 else if (!strcmp(s, "strip"))
180 opts->default_msg_cleanup = COMMIT_MSG_CLEANUP_ALL;
181 else if (!strcmp(s, "scissors"))
182 opts->default_msg_cleanup = COMMIT_MSG_CLEANUP_SPACE;
183 else
184 warning(_("invalid commit message cleanup mode '%s'"),
187 free((char *)s);
188 return status;
191 if (!strcmp(k, "commit.gpgsign")) {
192 opts->gpg_sign = git_config_bool(k, v) ? xstrdup("") : NULL;
193 return 0;
196 status = git_gpg_config(k, v, NULL);
197 if (status)
198 return status;
200 return git_diff_basic_config(k, v, NULL);
203 void sequencer_init_config(struct replay_opts *opts)
205 opts->default_msg_cleanup = COMMIT_MSG_CLEANUP_NONE;
206 git_config(git_sequencer_config, opts);
209 static inline int is_rebase_i(const struct replay_opts *opts)
211 return opts->action == REPLAY_INTERACTIVE_REBASE;
214 static const char *get_dir(const struct replay_opts *opts)
216 if (is_rebase_i(opts))
217 return rebase_path();
218 return git_path_seq_dir();
221 static const char *get_todo_path(const struct replay_opts *opts)
223 if (is_rebase_i(opts))
224 return rebase_path_todo();
225 return git_path_todo_file();
229 * Returns 0 for non-conforming footer
230 * Returns 1 for conforming footer
231 * Returns 2 when sob exists within conforming footer
232 * Returns 3 when sob exists within conforming footer as last entry
234 static int has_conforming_footer(struct strbuf *sb, struct strbuf *sob,
235 size_t ignore_footer)
237 struct process_trailer_options opts = PROCESS_TRAILER_OPTIONS_INIT;
238 struct trailer_info info;
239 size_t i;
240 int found_sob = 0, found_sob_last = 0;
242 opts.no_divider = 1;
244 trailer_info_get(&info, sb->buf, &opts);
246 if (info.trailer_start == info.trailer_end)
247 return 0;
249 for (i = 0; i < info.trailer_nr; i++)
250 if (sob && !strncmp(info.trailers[i], sob->buf, sob->len)) {
251 found_sob = 1;
252 if (i == info.trailer_nr - 1)
253 found_sob_last = 1;
256 trailer_info_release(&info);
258 if (found_sob_last)
259 return 3;
260 if (found_sob)
261 return 2;
262 return 1;
265 static const char *gpg_sign_opt_quoted(struct replay_opts *opts)
267 static struct strbuf buf = STRBUF_INIT;
269 strbuf_reset(&buf);
270 if (opts->gpg_sign)
271 sq_quotef(&buf, "-S%s", opts->gpg_sign);
272 return buf.buf;
275 int sequencer_remove_state(struct replay_opts *opts)
277 struct strbuf buf = STRBUF_INIT;
278 int i;
280 if (is_rebase_i(opts) &&
281 strbuf_read_file(&buf, rebase_path_refs_to_delete(), 0) > 0) {
282 char *p = buf.buf;
283 while (*p) {
284 char *eol = strchr(p, '\n');
285 if (eol)
286 *eol = '\0';
287 if (delete_ref("(rebase -i) cleanup", p, NULL, 0) < 0)
288 warning(_("could not delete '%s'"), p);
289 if (!eol)
290 break;
291 p = eol + 1;
295 free(opts->gpg_sign);
296 free(opts->strategy);
297 for (i = 0; i < opts->xopts_nr; i++)
298 free(opts->xopts[i]);
299 free(opts->xopts);
300 strbuf_release(&opts->current_fixups);
302 strbuf_reset(&buf);
303 strbuf_addstr(&buf, get_dir(opts));
304 remove_dir_recursively(&buf, 0);
305 strbuf_release(&buf);
307 return 0;
310 static const char *action_name(const struct replay_opts *opts)
312 switch (opts->action) {
313 case REPLAY_REVERT:
314 return N_("revert");
315 case REPLAY_PICK:
316 return N_("cherry-pick");
317 case REPLAY_INTERACTIVE_REBASE:
318 return N_("rebase -i");
320 die(_("unknown action: %d"), opts->action);
323 struct commit_message {
324 char *parent_label;
325 char *label;
326 char *subject;
327 const char *message;
330 static const char *short_commit_name(struct commit *commit)
332 return find_unique_abbrev(&commit->object.oid, DEFAULT_ABBREV);
335 static int get_message(struct commit *commit, struct commit_message *out)
337 const char *abbrev, *subject;
338 int subject_len;
340 out->message = logmsg_reencode(commit, NULL, get_commit_output_encoding());
341 abbrev = short_commit_name(commit);
343 subject_len = find_commit_subject(out->message, &subject);
345 out->subject = xmemdupz(subject, subject_len);
346 out->label = xstrfmt("%s... %s", abbrev, out->subject);
347 out->parent_label = xstrfmt("parent of %s", out->label);
349 return 0;
352 static void free_message(struct commit *commit, struct commit_message *msg)
354 free(msg->parent_label);
355 free(msg->label);
356 free(msg->subject);
357 unuse_commit_buffer(commit, msg->message);
360 static void print_advice(struct repository *r, int show_hint,
361 struct replay_opts *opts)
363 char *msg = getenv("GIT_CHERRY_PICK_HELP");
365 if (msg) {
366 fprintf(stderr, "%s\n", msg);
368 * A conflict has occurred but the porcelain
369 * (typically rebase --interactive) wants to take care
370 * of the commit itself so remove CHERRY_PICK_HEAD
372 unlink(git_path_cherry_pick_head(r));
373 return;
376 if (show_hint) {
377 if (opts->no_commit)
378 advise(_("after resolving the conflicts, mark the corrected paths\n"
379 "with 'git add <paths>' or 'git rm <paths>'"));
380 else
381 advise(_("after resolving the conflicts, mark the corrected paths\n"
382 "with 'git add <paths>' or 'git rm <paths>'\n"
383 "and commit the result with 'git commit'"));
387 int write_message(const void *buf, size_t len, const char *filename,
388 int append_eol)
390 struct lock_file msg_file = LOCK_INIT;
392 int msg_fd = hold_lock_file_for_update(&msg_file, filename, 0);
393 if (msg_fd < 0)
394 return error_errno(_("could not lock '%s'"), filename);
395 if (write_in_full(msg_fd, buf, len) < 0) {
396 error_errno(_("could not write to '%s'"), filename);
397 rollback_lock_file(&msg_file);
398 return -1;
400 if (append_eol && write(msg_fd, "\n", 1) < 0) {
401 error_errno(_("could not write eol to '%s'"), filename);
402 rollback_lock_file(&msg_file);
403 return -1;
405 if (commit_lock_file(&msg_file) < 0)
406 return error(_("failed to finalize '%s'"), filename);
408 return 0;
412 * Reads a file that was presumably written by a shell script, i.e. with an
413 * end-of-line marker that needs to be stripped.
415 * Note that only the last end-of-line marker is stripped, consistent with the
416 * behavior of "$(cat path)" in a shell script.
418 * Returns 1 if the file was read, 0 if it could not be read or does not exist.
420 static int read_oneliner(struct strbuf *buf,
421 const char *path, int skip_if_empty)
423 int orig_len = buf->len;
425 if (!file_exists(path))
426 return 0;
428 if (strbuf_read_file(buf, path, 0) < 0) {
429 warning_errno(_("could not read '%s'"), path);
430 return 0;
433 if (buf->len > orig_len && buf->buf[buf->len - 1] == '\n') {
434 if (--buf->len > orig_len && buf->buf[buf->len - 1] == '\r')
435 --buf->len;
436 buf->buf[buf->len] = '\0';
439 if (skip_if_empty && buf->len == orig_len)
440 return 0;
442 return 1;
445 static struct tree *empty_tree(struct repository *r)
447 return lookup_tree(r, the_hash_algo->empty_tree);
450 static int error_dirty_index(struct index_state *istate, struct replay_opts *opts)
452 if (read_index_unmerged(istate))
453 return error_resolve_conflict(_(action_name(opts)));
455 error(_("your local changes would be overwritten by %s."),
456 _(action_name(opts)));
458 if (advice_commit_before_merge)
459 advise(_("commit your changes or stash them to proceed."));
460 return -1;
463 static void update_abort_safety_file(void)
465 struct object_id head;
467 /* Do nothing on a single-pick */
468 if (!file_exists(git_path_seq_dir()))
469 return;
471 if (!get_oid("HEAD", &head))
472 write_file(git_path_abort_safety_file(), "%s", oid_to_hex(&head));
473 else
474 write_file(git_path_abort_safety_file(), "%s", "");
477 static int fast_forward_to(struct repository *r,
478 const struct object_id *to,
479 const struct object_id *from,
480 int unborn,
481 struct replay_opts *opts)
483 struct ref_transaction *transaction;
484 struct strbuf sb = STRBUF_INIT;
485 struct strbuf err = STRBUF_INIT;
487 read_index(r->index);
488 if (checkout_fast_forward(r, from, to, 1))
489 return -1; /* the callee should have complained already */
491 strbuf_addf(&sb, _("%s: fast-forward"), _(action_name(opts)));
493 transaction = ref_transaction_begin(&err);
494 if (!transaction ||
495 ref_transaction_update(transaction, "HEAD",
496 to, unborn && !is_rebase_i(opts) ?
497 &null_oid : from,
498 0, sb.buf, &err) ||
499 ref_transaction_commit(transaction, &err)) {
500 ref_transaction_free(transaction);
501 error("%s", err.buf);
502 strbuf_release(&sb);
503 strbuf_release(&err);
504 return -1;
507 strbuf_release(&sb);
508 strbuf_release(&err);
509 ref_transaction_free(transaction);
510 update_abort_safety_file();
511 return 0;
514 void append_conflicts_hint(struct index_state *istate,
515 struct strbuf *msgbuf)
517 int i;
519 strbuf_addch(msgbuf, '\n');
520 strbuf_commented_addf(msgbuf, "Conflicts:\n");
521 for (i = 0; i < istate->cache_nr;) {
522 const struct cache_entry *ce = istate->cache[i++];
523 if (ce_stage(ce)) {
524 strbuf_commented_addf(msgbuf, "\t%s\n", ce->name);
525 while (i < istate->cache_nr &&
526 !strcmp(ce->name, istate->cache[i]->name))
527 i++;
532 static int do_recursive_merge(struct repository *r,
533 struct commit *base, struct commit *next,
534 const char *base_label, const char *next_label,
535 struct object_id *head, struct strbuf *msgbuf,
536 struct replay_opts *opts)
538 struct merge_options o;
539 struct tree *result, *next_tree, *base_tree, *head_tree;
540 int clean;
541 char **xopt;
542 struct lock_file index_lock = LOCK_INIT;
544 if (hold_locked_index(&index_lock, LOCK_REPORT_ON_ERROR) < 0)
545 return -1;
547 read_index(r->index);
549 init_merge_options(&o);
550 o.ancestor = base ? base_label : "(empty tree)";
551 o.branch1 = "HEAD";
552 o.branch2 = next ? next_label : "(empty tree)";
553 if (is_rebase_i(opts))
554 o.buffer_output = 2;
555 o.show_rename_progress = 1;
557 head_tree = parse_tree_indirect(head);
558 next_tree = next ? get_commit_tree(next) : empty_tree(r);
559 base_tree = base ? get_commit_tree(base) : empty_tree(r);
561 for (xopt = opts->xopts; xopt != opts->xopts + opts->xopts_nr; xopt++)
562 parse_merge_opt(&o, *xopt);
564 clean = merge_trees(&o,
565 head_tree,
566 next_tree, base_tree, &result);
567 if (is_rebase_i(opts) && clean <= 0)
568 fputs(o.obuf.buf, stdout);
569 strbuf_release(&o.obuf);
570 diff_warn_rename_limit("merge.renamelimit", o.needed_rename_limit, 0);
571 if (clean < 0) {
572 rollback_lock_file(&index_lock);
573 return clean;
576 if (write_locked_index(r->index, &index_lock,
577 COMMIT_LOCK | SKIP_IF_UNCHANGED))
579 * TRANSLATORS: %s will be "revert", "cherry-pick" or
580 * "rebase -i".
582 return error(_("%s: Unable to write new index file"),
583 _(action_name(opts)));
585 if (!clean)
586 append_conflicts_hint(r->index, msgbuf);
588 return !clean;
591 static struct object_id *get_cache_tree_oid(struct index_state *istate)
593 if (!istate->cache_tree)
594 istate->cache_tree = cache_tree();
596 if (!cache_tree_fully_valid(istate->cache_tree))
597 if (cache_tree_update(istate, 0)) {
598 error(_("unable to update cache tree"));
599 return NULL;
602 return &istate->cache_tree->oid;
605 static int is_index_unchanged(struct repository *r)
607 struct object_id head_oid, *cache_tree_oid;
608 struct commit *head_commit;
609 struct index_state *istate = r->index;
611 if (!resolve_ref_unsafe("HEAD", RESOLVE_REF_READING, &head_oid, NULL))
612 return error(_("could not resolve HEAD commit"));
614 head_commit = lookup_commit(r, &head_oid);
617 * If head_commit is NULL, check_commit, called from
618 * lookup_commit, would have indicated that head_commit is not
619 * a commit object already. parse_commit() will return failure
620 * without further complaints in such a case. Otherwise, if
621 * the commit is invalid, parse_commit() will complain. So
622 * there is nothing for us to say here. Just return failure.
624 if (parse_commit(head_commit))
625 return -1;
627 if (!(cache_tree_oid = get_cache_tree_oid(istate)))
628 return -1;
630 return oideq(cache_tree_oid, get_commit_tree_oid(head_commit));
633 static int write_author_script(const char *message)
635 struct strbuf buf = STRBUF_INIT;
636 const char *eol;
637 int res;
639 for (;;)
640 if (!*message || starts_with(message, "\n")) {
641 missing_author:
642 /* Missing 'author' line? */
643 unlink(rebase_path_author_script());
644 return 0;
645 } else if (skip_prefix(message, "author ", &message))
646 break;
647 else if ((eol = strchr(message, '\n')))
648 message = eol + 1;
649 else
650 goto missing_author;
652 strbuf_addstr(&buf, "GIT_AUTHOR_NAME='");
653 while (*message && *message != '\n' && *message != '\r')
654 if (skip_prefix(message, " <", &message))
655 break;
656 else if (*message != '\'')
657 strbuf_addch(&buf, *(message++));
658 else
659 strbuf_addf(&buf, "'\\%c'", *(message++));
660 strbuf_addstr(&buf, "'\nGIT_AUTHOR_EMAIL='");
661 while (*message && *message != '\n' && *message != '\r')
662 if (skip_prefix(message, "> ", &message))
663 break;
664 else if (*message != '\'')
665 strbuf_addch(&buf, *(message++));
666 else
667 strbuf_addf(&buf, "'\\%c'", *(message++));
668 strbuf_addstr(&buf, "'\nGIT_AUTHOR_DATE='@");
669 while (*message && *message != '\n' && *message != '\r')
670 if (*message != '\'')
671 strbuf_addch(&buf, *(message++));
672 else
673 strbuf_addf(&buf, "'\\%c'", *(message++));
674 strbuf_addch(&buf, '\'');
675 res = write_message(buf.buf, buf.len, rebase_path_author_script(), 1);
676 strbuf_release(&buf);
677 return res;
681 * Take a series of KEY='VALUE' lines where VALUE part is
682 * sq-quoted, and append <KEY, VALUE> at the end of the string list
684 static int parse_key_value_squoted(char *buf, struct string_list *list)
686 while (*buf) {
687 struct string_list_item *item;
688 char *np;
689 char *cp = strchr(buf, '=');
690 if (!cp) {
691 np = strchrnul(buf, '\n');
692 return error(_("no key present in '%.*s'"),
693 (int) (np - buf), buf);
695 np = strchrnul(cp, '\n');
696 *cp++ = '\0';
697 item = string_list_append(list, buf);
699 buf = np + (*np == '\n');
700 *np = '\0';
701 cp = sq_dequote(cp);
702 if (!cp)
703 return error(_("unable to dequote value of '%s'"),
704 item->string);
705 item->util = xstrdup(cp);
707 return 0;
711 * Reads and parses the state directory's "author-script" file, and sets name,
712 * email and date accordingly.
713 * Returns 0 on success, -1 if the file could not be parsed.
715 * The author script is of the format:
717 * GIT_AUTHOR_NAME='$author_name'
718 * GIT_AUTHOR_EMAIL='$author_email'
719 * GIT_AUTHOR_DATE='$author_date'
721 * where $author_name, $author_email and $author_date are quoted. We are strict
722 * with our parsing, as the file was meant to be eval'd in the old
723 * git-am.sh/git-rebase--interactive.sh scripts, and thus if the file differs
724 * from what this function expects, it is better to bail out than to do
725 * something that the user does not expect.
727 int read_author_script(const char *path, char **name, char **email, char **date,
728 int allow_missing)
730 struct strbuf buf = STRBUF_INIT;
731 struct string_list kv = STRING_LIST_INIT_DUP;
732 int retval = -1; /* assume failure */
733 int i, name_i = -2, email_i = -2, date_i = -2, err = 0;
735 if (strbuf_read_file(&buf, path, 256) <= 0) {
736 strbuf_release(&buf);
737 if (errno == ENOENT && allow_missing)
738 return 0;
739 else
740 return error_errno(_("could not open '%s' for reading"),
741 path);
744 if (parse_key_value_squoted(buf.buf, &kv))
745 goto finish;
747 for (i = 0; i < kv.nr; i++) {
748 if (!strcmp(kv.items[i].string, "GIT_AUTHOR_NAME")) {
749 if (name_i != -2)
750 name_i = error(_("'GIT_AUTHOR_NAME' already given"));
751 else
752 name_i = i;
753 } else if (!strcmp(kv.items[i].string, "GIT_AUTHOR_EMAIL")) {
754 if (email_i != -2)
755 email_i = error(_("'GIT_AUTHOR_EMAIL' already given"));
756 else
757 email_i = i;
758 } else if (!strcmp(kv.items[i].string, "GIT_AUTHOR_DATE")) {
759 if (date_i != -2)
760 date_i = error(_("'GIT_AUTHOR_DATE' already given"));
761 else
762 date_i = i;
763 } else {
764 err = error(_("unknown variable '%s'"),
765 kv.items[i].string);
768 if (name_i == -2)
769 error(_("missing 'GIT_AUTHOR_NAME'"));
770 if (email_i == -2)
771 error(_("missing 'GIT_AUTHOR_EMAIL'"));
772 if (date_i == -2)
773 error(_("missing 'GIT_AUTHOR_DATE'"));
774 if (date_i < 0 || email_i < 0 || date_i < 0 || err)
775 goto finish;
776 *name = kv.items[name_i].util;
777 *email = kv.items[email_i].util;
778 *date = kv.items[date_i].util;
779 retval = 0;
780 finish:
781 string_list_clear(&kv, !!retval);
782 strbuf_release(&buf);
783 return retval;
787 * Read a GIT_AUTHOR_NAME, GIT_AUTHOR_EMAIL AND GIT_AUTHOR_DATE from a
788 * file with shell quoting into struct argv_array. Returns -1 on
789 * error, 0 otherwise.
791 static int read_env_script(struct argv_array *env)
793 char *name, *email, *date;
795 if (read_author_script(rebase_path_author_script(),
796 &name, &email, &date, 0))
797 return -1;
799 argv_array_pushf(env, "GIT_AUTHOR_NAME=%s", name);
800 argv_array_pushf(env, "GIT_AUTHOR_EMAIL=%s", email);
801 argv_array_pushf(env, "GIT_AUTHOR_DATE=%s", date);
802 free(name);
803 free(email);
804 free(date);
806 return 0;
809 static char *get_author(const char *message)
811 size_t len;
812 const char *a;
814 a = find_commit_header(message, "author", &len);
815 if (a)
816 return xmemdupz(a, len);
818 return NULL;
821 /* Read author-script and return an ident line (author <email> timestamp) */
822 static const char *read_author_ident(struct strbuf *buf)
824 struct strbuf out = STRBUF_INIT;
825 char *name, *email, *date;
827 if (read_author_script(rebase_path_author_script(),
828 &name, &email, &date, 0))
829 return NULL;
831 /* validate date since fmt_ident() will die() on bad value */
832 if (parse_date(date, &out)){
833 warning(_("invalid date format '%s' in '%s'"),
834 date, rebase_path_author_script());
835 strbuf_release(&out);
836 return NULL;
839 strbuf_reset(&out);
840 strbuf_addstr(&out, fmt_ident(name, email, date, 0));
841 strbuf_swap(buf, &out);
842 strbuf_release(&out);
843 free(name);
844 free(email);
845 free(date);
846 return buf->buf;
849 static const char staged_changes_advice[] =
850 N_("you have staged changes in your working tree\n"
851 "If these changes are meant to be squashed into the previous commit, run:\n"
852 "\n"
853 " git commit --amend %s\n"
854 "\n"
855 "If they are meant to go into a new commit, run:\n"
856 "\n"
857 " git commit %s\n"
858 "\n"
859 "In both cases, once you're done, continue with:\n"
860 "\n"
861 " git rebase --continue\n");
863 #define ALLOW_EMPTY (1<<0)
864 #define EDIT_MSG (1<<1)
865 #define AMEND_MSG (1<<2)
866 #define CLEANUP_MSG (1<<3)
867 #define VERIFY_MSG (1<<4)
868 #define CREATE_ROOT_COMMIT (1<<5)
870 static int run_command_silent_on_success(struct child_process *cmd)
872 struct strbuf buf = STRBUF_INIT;
873 int rc;
875 cmd->stdout_to_stderr = 1;
876 rc = pipe_command(cmd,
877 NULL, 0,
878 NULL, 0,
879 &buf, 0);
881 if (rc)
882 fputs(buf.buf, stderr);
883 strbuf_release(&buf);
884 return rc;
888 * If we are cherry-pick, and if the merge did not result in
889 * hand-editing, we will hit this commit and inherit the original
890 * author date and name.
892 * If we are revert, or if our cherry-pick results in a hand merge,
893 * we had better say that the current user is responsible for that.
895 * An exception is when run_git_commit() is called during an
896 * interactive rebase: in that case, we will want to retain the
897 * author metadata.
899 static int run_git_commit(struct repository *r,
900 const char *defmsg,
901 struct replay_opts *opts,
902 unsigned int flags)
904 struct child_process cmd = CHILD_PROCESS_INIT;
905 const char *value;
907 if ((flags & CREATE_ROOT_COMMIT) && !(flags & AMEND_MSG)) {
908 struct strbuf msg = STRBUF_INIT, script = STRBUF_INIT;
909 const char *author = NULL;
910 struct object_id root_commit, *cache_tree_oid;
911 int res = 0;
913 if (is_rebase_i(opts)) {
914 author = read_author_ident(&script);
915 if (!author) {
916 strbuf_release(&script);
917 return -1;
921 if (!defmsg)
922 BUG("root commit without message");
924 if (!(cache_tree_oid = get_cache_tree_oid(r->index)))
925 res = -1;
927 if (!res)
928 res = strbuf_read_file(&msg, defmsg, 0);
930 if (res <= 0)
931 res = error_errno(_("could not read '%s'"), defmsg);
932 else
933 res = commit_tree(msg.buf, msg.len, cache_tree_oid,
934 NULL, &root_commit, author,
935 opts->gpg_sign);
937 strbuf_release(&msg);
938 strbuf_release(&script);
939 if (!res) {
940 update_ref(NULL, "CHERRY_PICK_HEAD", &root_commit, NULL,
941 REF_NO_DEREF, UPDATE_REFS_MSG_ON_ERR);
942 res = update_ref(NULL, "HEAD", &root_commit, NULL, 0,
943 UPDATE_REFS_MSG_ON_ERR);
945 return res < 0 ? error(_("writing root commit")) : 0;
948 cmd.git_cmd = 1;
950 if (is_rebase_i(opts) && read_env_script(&cmd.env_array)) {
951 const char *gpg_opt = gpg_sign_opt_quoted(opts);
953 return error(_(staged_changes_advice),
954 gpg_opt, gpg_opt);
957 argv_array_push(&cmd.args, "commit");
959 if (!(flags & VERIFY_MSG))
960 argv_array_push(&cmd.args, "-n");
961 if ((flags & AMEND_MSG))
962 argv_array_push(&cmd.args, "--amend");
963 if (opts->gpg_sign)
964 argv_array_pushf(&cmd.args, "-S%s", opts->gpg_sign);
965 if (defmsg)
966 argv_array_pushl(&cmd.args, "-F", defmsg, NULL);
967 else if (!(flags & EDIT_MSG))
968 argv_array_pushl(&cmd.args, "-C", "HEAD", NULL);
969 if ((flags & CLEANUP_MSG))
970 argv_array_push(&cmd.args, "--cleanup=strip");
971 if ((flags & EDIT_MSG))
972 argv_array_push(&cmd.args, "-e");
973 else if (!(flags & CLEANUP_MSG) &&
974 !opts->signoff && !opts->record_origin &&
975 git_config_get_value("commit.cleanup", &value))
976 argv_array_push(&cmd.args, "--cleanup=verbatim");
978 if ((flags & ALLOW_EMPTY))
979 argv_array_push(&cmd.args, "--allow-empty");
981 if (!(flags & EDIT_MSG))
982 argv_array_push(&cmd.args, "--allow-empty-message");
984 if (is_rebase_i(opts) && !(flags & EDIT_MSG))
985 return run_command_silent_on_success(&cmd);
986 else
987 return run_command(&cmd);
990 static int rest_is_empty(const struct strbuf *sb, int start)
992 int i, eol;
993 const char *nl;
995 /* Check if the rest is just whitespace and Signed-off-by's. */
996 for (i = start; i < sb->len; i++) {
997 nl = memchr(sb->buf + i, '\n', sb->len - i);
998 if (nl)
999 eol = nl - sb->buf;
1000 else
1001 eol = sb->len;
1003 if (strlen(sign_off_header) <= eol - i &&
1004 starts_with(sb->buf + i, sign_off_header)) {
1005 i = eol;
1006 continue;
1008 while (i < eol)
1009 if (!isspace(sb->buf[i++]))
1010 return 0;
1013 return 1;
1017 * Find out if the message in the strbuf contains only whitespace and
1018 * Signed-off-by lines.
1020 int message_is_empty(const struct strbuf *sb,
1021 enum commit_msg_cleanup_mode cleanup_mode)
1023 if (cleanup_mode == COMMIT_MSG_CLEANUP_NONE && sb->len)
1024 return 0;
1025 return rest_is_empty(sb, 0);
1029 * See if the user edited the message in the editor or left what
1030 * was in the template intact
1032 int template_untouched(const struct strbuf *sb, const char *template_file,
1033 enum commit_msg_cleanup_mode cleanup_mode)
1035 struct strbuf tmpl = STRBUF_INIT;
1036 const char *start;
1038 if (cleanup_mode == COMMIT_MSG_CLEANUP_NONE && sb->len)
1039 return 0;
1041 if (!template_file || strbuf_read_file(&tmpl, template_file, 0) <= 0)
1042 return 0;
1044 strbuf_stripspace(&tmpl, cleanup_mode == COMMIT_MSG_CLEANUP_ALL);
1045 if (!skip_prefix(sb->buf, tmpl.buf, &start))
1046 start = sb->buf;
1047 strbuf_release(&tmpl);
1048 return rest_is_empty(sb, start - sb->buf);
1051 int update_head_with_reflog(const struct commit *old_head,
1052 const struct object_id *new_head,
1053 const char *action, const struct strbuf *msg,
1054 struct strbuf *err)
1056 struct ref_transaction *transaction;
1057 struct strbuf sb = STRBUF_INIT;
1058 const char *nl;
1059 int ret = 0;
1061 if (action) {
1062 strbuf_addstr(&sb, action);
1063 strbuf_addstr(&sb, ": ");
1066 nl = strchr(msg->buf, '\n');
1067 if (nl) {
1068 strbuf_add(&sb, msg->buf, nl + 1 - msg->buf);
1069 } else {
1070 strbuf_addbuf(&sb, msg);
1071 strbuf_addch(&sb, '\n');
1074 transaction = ref_transaction_begin(err);
1075 if (!transaction ||
1076 ref_transaction_update(transaction, "HEAD", new_head,
1077 old_head ? &old_head->object.oid : &null_oid,
1078 0, sb.buf, err) ||
1079 ref_transaction_commit(transaction, err)) {
1080 ret = -1;
1082 ref_transaction_free(transaction);
1083 strbuf_release(&sb);
1085 return ret;
1088 static int run_rewrite_hook(const struct object_id *oldoid,
1089 const struct object_id *newoid)
1091 struct child_process proc = CHILD_PROCESS_INIT;
1092 const char *argv[3];
1093 int code;
1094 struct strbuf sb = STRBUF_INIT;
1096 argv[0] = find_hook("post-rewrite");
1097 if (!argv[0])
1098 return 0;
1100 argv[1] = "amend";
1101 argv[2] = NULL;
1103 proc.argv = argv;
1104 proc.in = -1;
1105 proc.stdout_to_stderr = 1;
1107 code = start_command(&proc);
1108 if (code)
1109 return code;
1110 strbuf_addf(&sb, "%s %s\n", oid_to_hex(oldoid), oid_to_hex(newoid));
1111 sigchain_push(SIGPIPE, SIG_IGN);
1112 write_in_full(proc.in, sb.buf, sb.len);
1113 close(proc.in);
1114 strbuf_release(&sb);
1115 sigchain_pop(SIGPIPE);
1116 return finish_command(&proc);
1119 void commit_post_rewrite(const struct commit *old_head,
1120 const struct object_id *new_head)
1122 struct notes_rewrite_cfg *cfg;
1124 cfg = init_copy_notes_for_rewrite("amend");
1125 if (cfg) {
1126 /* we are amending, so old_head is not NULL */
1127 copy_note_for_rewrite(cfg, &old_head->object.oid, new_head);
1128 finish_copy_notes_for_rewrite(cfg, "Notes added by 'git commit --amend'");
1130 run_rewrite_hook(&old_head->object.oid, new_head);
1133 static int run_prepare_commit_msg_hook(struct repository *r,
1134 struct strbuf *msg,
1135 const char *commit)
1137 struct argv_array hook_env = ARGV_ARRAY_INIT;
1138 int ret;
1139 const char *name;
1141 name = git_path_commit_editmsg();
1142 if (write_message(msg->buf, msg->len, name, 0))
1143 return -1;
1145 argv_array_pushf(&hook_env, "GIT_INDEX_FILE=%s", r->index_file);
1146 argv_array_push(&hook_env, "GIT_EDITOR=:");
1147 if (commit)
1148 ret = run_hook_le(hook_env.argv, "prepare-commit-msg", name,
1149 "commit", commit, NULL);
1150 else
1151 ret = run_hook_le(hook_env.argv, "prepare-commit-msg", name,
1152 "message", NULL);
1153 if (ret)
1154 ret = error(_("'prepare-commit-msg' hook failed"));
1155 argv_array_clear(&hook_env);
1157 return ret;
1160 static const char implicit_ident_advice_noconfig[] =
1161 N_("Your name and email address were configured automatically based\n"
1162 "on your username and hostname. Please check that they are accurate.\n"
1163 "You can suppress this message by setting them explicitly. Run the\n"
1164 "following command and follow the instructions in your editor to edit\n"
1165 "your configuration file:\n"
1166 "\n"
1167 " git config --global --edit\n"
1168 "\n"
1169 "After doing this, you may fix the identity used for this commit with:\n"
1170 "\n"
1171 " git commit --amend --reset-author\n");
1173 static const char implicit_ident_advice_config[] =
1174 N_("Your name and email address were configured automatically based\n"
1175 "on your username and hostname. Please check that they are accurate.\n"
1176 "You can suppress this message by setting them explicitly:\n"
1177 "\n"
1178 " git config --global user.name \"Your Name\"\n"
1179 " git config --global user.email you@example.com\n"
1180 "\n"
1181 "After doing this, you may fix the identity used for this commit with:\n"
1182 "\n"
1183 " git commit --amend --reset-author\n");
1185 static const char *implicit_ident_advice(void)
1187 char *user_config = expand_user_path("~/.gitconfig", 0);
1188 char *xdg_config = xdg_config_home("config");
1189 int config_exists = file_exists(user_config) || file_exists(xdg_config);
1191 free(user_config);
1192 free(xdg_config);
1194 if (config_exists)
1195 return _(implicit_ident_advice_config);
1196 else
1197 return _(implicit_ident_advice_noconfig);
1201 void print_commit_summary(struct repository *r,
1202 const char *prefix,
1203 const struct object_id *oid,
1204 unsigned int flags)
1206 struct rev_info rev;
1207 struct commit *commit;
1208 struct strbuf format = STRBUF_INIT;
1209 const char *head;
1210 struct pretty_print_context pctx = {0};
1211 struct strbuf author_ident = STRBUF_INIT;
1212 struct strbuf committer_ident = STRBUF_INIT;
1214 commit = lookup_commit(r, oid);
1215 if (!commit)
1216 die(_("couldn't look up newly created commit"));
1217 if (parse_commit(commit))
1218 die(_("could not parse newly created commit"));
1220 strbuf_addstr(&format, "format:%h] %s");
1222 format_commit_message(commit, "%an <%ae>", &author_ident, &pctx);
1223 format_commit_message(commit, "%cn <%ce>", &committer_ident, &pctx);
1224 if (strbuf_cmp(&author_ident, &committer_ident)) {
1225 strbuf_addstr(&format, "\n Author: ");
1226 strbuf_addbuf_percentquote(&format, &author_ident);
1228 if (flags & SUMMARY_SHOW_AUTHOR_DATE) {
1229 struct strbuf date = STRBUF_INIT;
1231 format_commit_message(commit, "%ad", &date, &pctx);
1232 strbuf_addstr(&format, "\n Date: ");
1233 strbuf_addbuf_percentquote(&format, &date);
1234 strbuf_release(&date);
1236 if (!committer_ident_sufficiently_given()) {
1237 strbuf_addstr(&format, "\n Committer: ");
1238 strbuf_addbuf_percentquote(&format, &committer_ident);
1239 if (advice_implicit_identity) {
1240 strbuf_addch(&format, '\n');
1241 strbuf_addstr(&format, implicit_ident_advice());
1244 strbuf_release(&author_ident);
1245 strbuf_release(&committer_ident);
1247 repo_init_revisions(r, &rev, prefix);
1248 setup_revisions(0, NULL, &rev, NULL);
1250 rev.diff = 1;
1251 rev.diffopt.output_format =
1252 DIFF_FORMAT_SHORTSTAT | DIFF_FORMAT_SUMMARY;
1254 rev.verbose_header = 1;
1255 rev.show_root_diff = 1;
1256 get_commit_format(format.buf, &rev);
1257 rev.always_show_header = 0;
1258 rev.diffopt.detect_rename = DIFF_DETECT_RENAME;
1259 rev.diffopt.break_opt = 0;
1260 diff_setup_done(&rev.diffopt);
1262 head = resolve_ref_unsafe("HEAD", 0, NULL, NULL);
1263 if (!head)
1264 die_errno(_("unable to resolve HEAD after creating commit"));
1265 if (!strcmp(head, "HEAD"))
1266 head = _("detached HEAD");
1267 else
1268 skip_prefix(head, "refs/heads/", &head);
1269 printf("[%s%s ", head, (flags & SUMMARY_INITIAL_COMMIT) ?
1270 _(" (root-commit)") : "");
1272 if (!log_tree_commit(&rev, commit)) {
1273 rev.always_show_header = 1;
1274 rev.use_terminator = 1;
1275 log_tree_commit(&rev, commit);
1278 strbuf_release(&format);
1281 static int parse_head(struct repository *r, struct commit **head)
1283 struct commit *current_head;
1284 struct object_id oid;
1286 if (get_oid("HEAD", &oid)) {
1287 current_head = NULL;
1288 } else {
1289 current_head = lookup_commit_reference(r, &oid);
1290 if (!current_head)
1291 return error(_("could not parse HEAD"));
1292 if (!oideq(&oid, &current_head->object.oid)) {
1293 warning(_("HEAD %s is not a commit!"),
1294 oid_to_hex(&oid));
1296 if (parse_commit(current_head))
1297 return error(_("could not parse HEAD commit"));
1299 *head = current_head;
1301 return 0;
1305 * Try to commit without forking 'git commit'. In some cases we need
1306 * to run 'git commit' to display an error message
1308 * Returns:
1309 * -1 - error unable to commit
1310 * 0 - success
1311 * 1 - run 'git commit'
1313 static int try_to_commit(struct repository *r,
1314 struct strbuf *msg, const char *author,
1315 struct replay_opts *opts, unsigned int flags,
1316 struct object_id *oid)
1318 struct object_id tree;
1319 struct commit *current_head;
1320 struct commit_list *parents = NULL;
1321 struct commit_extra_header *extra = NULL;
1322 struct strbuf err = STRBUF_INIT;
1323 struct strbuf commit_msg = STRBUF_INIT;
1324 char *amend_author = NULL;
1325 const char *hook_commit = NULL;
1326 enum commit_msg_cleanup_mode cleanup;
1327 int res = 0;
1329 if (parse_head(r, &current_head))
1330 return -1;
1332 if (flags & AMEND_MSG) {
1333 const char *exclude_gpgsig[] = { "gpgsig", NULL };
1334 const char *out_enc = get_commit_output_encoding();
1335 const char *message = logmsg_reencode(current_head, NULL,
1336 out_enc);
1338 if (!msg) {
1339 const char *orig_message = NULL;
1341 find_commit_subject(message, &orig_message);
1342 msg = &commit_msg;
1343 strbuf_addstr(msg, orig_message);
1344 hook_commit = "HEAD";
1346 author = amend_author = get_author(message);
1347 unuse_commit_buffer(current_head, message);
1348 if (!author) {
1349 res = error(_("unable to parse commit author"));
1350 goto out;
1352 parents = copy_commit_list(current_head->parents);
1353 extra = read_commit_extra_headers(current_head, exclude_gpgsig);
1354 } else if (current_head) {
1355 commit_list_insert(current_head, &parents);
1358 if (write_index_as_tree(&tree, r->index, r->index_file, 0, NULL)) {
1359 res = error(_("git write-tree failed to write a tree"));
1360 goto out;
1363 if (!(flags & ALLOW_EMPTY) && oideq(current_head ?
1364 get_commit_tree_oid(current_head) :
1365 the_hash_algo->empty_tree, &tree)) {
1366 res = 1; /* run 'git commit' to display error message */
1367 goto out;
1370 if (find_hook("prepare-commit-msg")) {
1371 res = run_prepare_commit_msg_hook(r, msg, hook_commit);
1372 if (res)
1373 goto out;
1374 if (strbuf_read_file(&commit_msg, git_path_commit_editmsg(),
1375 2048) < 0) {
1376 res = error_errno(_("unable to read commit message "
1377 "from '%s'"),
1378 git_path_commit_editmsg());
1379 goto out;
1381 msg = &commit_msg;
1384 cleanup = (flags & CLEANUP_MSG) ? COMMIT_MSG_CLEANUP_ALL :
1385 opts->default_msg_cleanup;
1387 if (cleanup != COMMIT_MSG_CLEANUP_NONE)
1388 strbuf_stripspace(msg, cleanup == COMMIT_MSG_CLEANUP_ALL);
1389 if ((flags & EDIT_MSG) && message_is_empty(msg, cleanup)) {
1390 res = 1; /* run 'git commit' to display error message */
1391 goto out;
1394 reset_ident_date();
1396 if (commit_tree_extended(msg->buf, msg->len, &tree, parents,
1397 oid, author, opts->gpg_sign, extra)) {
1398 res = error(_("failed to write commit object"));
1399 goto out;
1402 if (update_head_with_reflog(current_head, oid,
1403 getenv("GIT_REFLOG_ACTION"), msg, &err)) {
1404 res = error("%s", err.buf);
1405 goto out;
1408 if (flags & AMEND_MSG)
1409 commit_post_rewrite(current_head, oid);
1411 out:
1412 free_commit_extra_headers(extra);
1413 strbuf_release(&err);
1414 strbuf_release(&commit_msg);
1415 free(amend_author);
1417 return res;
1420 static int do_commit(struct repository *r,
1421 const char *msg_file, const char *author,
1422 struct replay_opts *opts, unsigned int flags)
1424 int res = 1;
1426 if (!(flags & EDIT_MSG) && !(flags & VERIFY_MSG) &&
1427 !(flags & CREATE_ROOT_COMMIT)) {
1428 struct object_id oid;
1429 struct strbuf sb = STRBUF_INIT;
1431 if (msg_file && strbuf_read_file(&sb, msg_file, 2048) < 0)
1432 return error_errno(_("unable to read commit message "
1433 "from '%s'"),
1434 msg_file);
1436 res = try_to_commit(r, msg_file ? &sb : NULL,
1437 author, opts, flags, &oid);
1438 strbuf_release(&sb);
1439 if (!res) {
1440 unlink(git_path_cherry_pick_head(r));
1441 unlink(git_path_merge_msg(r));
1442 if (!is_rebase_i(opts))
1443 print_commit_summary(r, NULL, &oid,
1444 SUMMARY_SHOW_AUTHOR_DATE);
1445 return res;
1448 if (res == 1)
1449 return run_git_commit(r, msg_file, opts, flags);
1451 return res;
1454 static int is_original_commit_empty(struct commit *commit)
1456 const struct object_id *ptree_oid;
1458 if (parse_commit(commit))
1459 return error(_("could not parse commit %s"),
1460 oid_to_hex(&commit->object.oid));
1461 if (commit->parents) {
1462 struct commit *parent = commit->parents->item;
1463 if (parse_commit(parent))
1464 return error(_("could not parse parent commit %s"),
1465 oid_to_hex(&parent->object.oid));
1466 ptree_oid = get_commit_tree_oid(parent);
1467 } else {
1468 ptree_oid = the_hash_algo->empty_tree; /* commit is root */
1471 return oideq(ptree_oid, get_commit_tree_oid(commit));
1475 * Do we run "git commit" with "--allow-empty"?
1477 static int allow_empty(struct repository *r,
1478 struct replay_opts *opts,
1479 struct commit *commit)
1481 int index_unchanged, empty_commit;
1484 * Three cases:
1486 * (1) we do not allow empty at all and error out.
1488 * (2) we allow ones that were initially empty, but
1489 * forbid the ones that become empty;
1491 * (3) we allow both.
1493 if (!opts->allow_empty)
1494 return 0; /* let "git commit" barf as necessary */
1496 index_unchanged = is_index_unchanged(r);
1497 if (index_unchanged < 0)
1498 return index_unchanged;
1499 if (!index_unchanged)
1500 return 0; /* we do not have to say --allow-empty */
1502 if (opts->keep_redundant_commits)
1503 return 1;
1505 empty_commit = is_original_commit_empty(commit);
1506 if (empty_commit < 0)
1507 return empty_commit;
1508 if (!empty_commit)
1509 return 0;
1510 else
1511 return 1;
1515 * Note that ordering matters in this enum. Not only must it match the mapping
1516 * below, it is also divided into several sections that matter. When adding
1517 * new commands, make sure you add it in the right section.
1519 enum todo_command {
1520 /* commands that handle commits */
1521 TODO_PICK = 0,
1522 TODO_REVERT,
1523 TODO_EDIT,
1524 TODO_REWORD,
1525 TODO_FIXUP,
1526 TODO_SQUASH,
1527 /* commands that do something else than handling a single commit */
1528 TODO_EXEC,
1529 TODO_BREAK,
1530 TODO_LABEL,
1531 TODO_RESET,
1532 TODO_MERGE,
1533 /* commands that do nothing but are counted for reporting progress */
1534 TODO_NOOP,
1535 TODO_DROP,
1536 /* comments (not counted for reporting progress) */
1537 TODO_COMMENT
1540 static struct {
1541 char c;
1542 const char *str;
1543 } todo_command_info[] = {
1544 { 'p', "pick" },
1545 { 0, "revert" },
1546 { 'e', "edit" },
1547 { 'r', "reword" },
1548 { 'f', "fixup" },
1549 { 's', "squash" },
1550 { 'x', "exec" },
1551 { 'b', "break" },
1552 { 'l', "label" },
1553 { 't', "reset" },
1554 { 'm', "merge" },
1555 { 0, "noop" },
1556 { 'd', "drop" },
1557 { 0, NULL }
1560 static const char *command_to_string(const enum todo_command command)
1562 if (command < TODO_COMMENT)
1563 return todo_command_info[command].str;
1564 die(_("unknown command: %d"), command);
1567 static char command_to_char(const enum todo_command command)
1569 if (command < TODO_COMMENT && todo_command_info[command].c)
1570 return todo_command_info[command].c;
1571 return comment_line_char;
1574 static int is_noop(const enum todo_command command)
1576 return TODO_NOOP <= command;
1579 static int is_fixup(enum todo_command command)
1581 return command == TODO_FIXUP || command == TODO_SQUASH;
1584 /* Does this command create a (non-merge) commit? */
1585 static int is_pick_or_similar(enum todo_command command)
1587 switch (command) {
1588 case TODO_PICK:
1589 case TODO_REVERT:
1590 case TODO_EDIT:
1591 case TODO_REWORD:
1592 case TODO_FIXUP:
1593 case TODO_SQUASH:
1594 return 1;
1595 default:
1596 return 0;
1600 static int update_squash_messages(struct repository *r,
1601 enum todo_command command,
1602 struct commit *commit,
1603 struct replay_opts *opts)
1605 struct strbuf buf = STRBUF_INIT;
1606 int res;
1607 const char *message, *body;
1609 if (opts->current_fixup_count > 0) {
1610 struct strbuf header = STRBUF_INIT;
1611 char *eol;
1613 if (strbuf_read_file(&buf, rebase_path_squash_msg(), 9) <= 0)
1614 return error(_("could not read '%s'"),
1615 rebase_path_squash_msg());
1617 eol = buf.buf[0] != comment_line_char ?
1618 buf.buf : strchrnul(buf.buf, '\n');
1620 strbuf_addf(&header, "%c ", comment_line_char);
1621 strbuf_addf(&header, _("This is a combination of %d commits."),
1622 opts->current_fixup_count + 2);
1623 strbuf_splice(&buf, 0, eol - buf.buf, header.buf, header.len);
1624 strbuf_release(&header);
1625 } else {
1626 struct object_id head;
1627 struct commit *head_commit;
1628 const char *head_message, *body;
1630 if (get_oid("HEAD", &head))
1631 return error(_("need a HEAD to fixup"));
1632 if (!(head_commit = lookup_commit_reference(r, &head)))
1633 return error(_("could not read HEAD"));
1634 if (!(head_message = get_commit_buffer(head_commit, NULL)))
1635 return error(_("could not read HEAD's commit message"));
1637 find_commit_subject(head_message, &body);
1638 if (write_message(body, strlen(body),
1639 rebase_path_fixup_msg(), 0)) {
1640 unuse_commit_buffer(head_commit, head_message);
1641 return error(_("cannot write '%s'"),
1642 rebase_path_fixup_msg());
1645 strbuf_addf(&buf, "%c ", comment_line_char);
1646 strbuf_addf(&buf, _("This is a combination of %d commits."), 2);
1647 strbuf_addf(&buf, "\n%c ", comment_line_char);
1648 strbuf_addstr(&buf, _("This is the 1st commit message:"));
1649 strbuf_addstr(&buf, "\n\n");
1650 strbuf_addstr(&buf, body);
1652 unuse_commit_buffer(head_commit, head_message);
1655 if (!(message = get_commit_buffer(commit, NULL)))
1656 return error(_("could not read commit message of %s"),
1657 oid_to_hex(&commit->object.oid));
1658 find_commit_subject(message, &body);
1660 if (command == TODO_SQUASH) {
1661 unlink(rebase_path_fixup_msg());
1662 strbuf_addf(&buf, "\n%c ", comment_line_char);
1663 strbuf_addf(&buf, _("This is the commit message #%d:"),
1664 ++opts->current_fixup_count + 1);
1665 strbuf_addstr(&buf, "\n\n");
1666 strbuf_addstr(&buf, body);
1667 } else if (command == TODO_FIXUP) {
1668 strbuf_addf(&buf, "\n%c ", comment_line_char);
1669 strbuf_addf(&buf, _("The commit message #%d will be skipped:"),
1670 ++opts->current_fixup_count + 1);
1671 strbuf_addstr(&buf, "\n\n");
1672 strbuf_add_commented_lines(&buf, body, strlen(body));
1673 } else
1674 return error(_("unknown command: %d"), command);
1675 unuse_commit_buffer(commit, message);
1677 res = write_message(buf.buf, buf.len, rebase_path_squash_msg(), 0);
1678 strbuf_release(&buf);
1680 if (!res) {
1681 strbuf_addf(&opts->current_fixups, "%s%s %s",
1682 opts->current_fixups.len ? "\n" : "",
1683 command_to_string(command),
1684 oid_to_hex(&commit->object.oid));
1685 res = write_message(opts->current_fixups.buf,
1686 opts->current_fixups.len,
1687 rebase_path_current_fixups(), 0);
1690 return res;
1693 static void flush_rewritten_pending(void)
1695 struct strbuf buf = STRBUF_INIT;
1696 struct object_id newoid;
1697 FILE *out;
1699 if (strbuf_read_file(&buf, rebase_path_rewritten_pending(), (GIT_MAX_HEXSZ + 1) * 2) > 0 &&
1700 !get_oid("HEAD", &newoid) &&
1701 (out = fopen_or_warn(rebase_path_rewritten_list(), "a"))) {
1702 char *bol = buf.buf, *eol;
1704 while (*bol) {
1705 eol = strchrnul(bol, '\n');
1706 fprintf(out, "%.*s %s\n", (int)(eol - bol),
1707 bol, oid_to_hex(&newoid));
1708 if (!*eol)
1709 break;
1710 bol = eol + 1;
1712 fclose(out);
1713 unlink(rebase_path_rewritten_pending());
1715 strbuf_release(&buf);
1718 static void record_in_rewritten(struct object_id *oid,
1719 enum todo_command next_command)
1721 FILE *out = fopen_or_warn(rebase_path_rewritten_pending(), "a");
1723 if (!out)
1724 return;
1726 fprintf(out, "%s\n", oid_to_hex(oid));
1727 fclose(out);
1729 if (!is_fixup(next_command))
1730 flush_rewritten_pending();
1733 static int do_pick_commit(struct repository *r,
1734 enum todo_command command,
1735 struct commit *commit,
1736 struct replay_opts *opts,
1737 int final_fixup)
1739 unsigned int flags = opts->edit ? EDIT_MSG : 0;
1740 const char *msg_file = opts->edit ? NULL : git_path_merge_msg(r);
1741 struct object_id head;
1742 struct commit *base, *next, *parent;
1743 const char *base_label, *next_label;
1744 char *author = NULL;
1745 struct commit_message msg = { NULL, NULL, NULL, NULL };
1746 struct strbuf msgbuf = STRBUF_INIT;
1747 int res, unborn = 0, allow;
1749 if (opts->no_commit) {
1751 * We do not intend to commit immediately. We just want to
1752 * merge the differences in, so let's compute the tree
1753 * that represents the "current" state for merge-recursive
1754 * to work on.
1756 if (write_index_as_tree(&head, r->index, r->index_file, 0, NULL))
1757 return error(_("your index file is unmerged."));
1758 } else {
1759 unborn = get_oid("HEAD", &head);
1760 /* Do we want to generate a root commit? */
1761 if (is_pick_or_similar(command) && opts->have_squash_onto &&
1762 oideq(&head, &opts->squash_onto)) {
1763 if (is_fixup(command))
1764 return error(_("cannot fixup root commit"));
1765 flags |= CREATE_ROOT_COMMIT;
1766 unborn = 1;
1767 } else if (unborn)
1768 oidcpy(&head, the_hash_algo->empty_tree);
1769 if (index_differs_from(r, unborn ? empty_tree_oid_hex() : "HEAD",
1770 NULL, 0))
1771 return error_dirty_index(r->index, opts);
1773 discard_index(r->index);
1775 if (!commit->parents)
1776 parent = NULL;
1777 else if (commit->parents->next) {
1778 /* Reverting or cherry-picking a merge commit */
1779 int cnt;
1780 struct commit_list *p;
1782 if (!opts->mainline)
1783 return error(_("commit %s is a merge but no -m option was given."),
1784 oid_to_hex(&commit->object.oid));
1786 for (cnt = 1, p = commit->parents;
1787 cnt != opts->mainline && p;
1788 cnt++)
1789 p = p->next;
1790 if (cnt != opts->mainline || !p)
1791 return error(_("commit %s does not have parent %d"),
1792 oid_to_hex(&commit->object.oid), opts->mainline);
1793 parent = p->item;
1794 } else if (1 < opts->mainline)
1796 * Non-first parent explicitly specified as mainline for
1797 * non-merge commit
1799 return error(_("commit %s does not have parent %d"),
1800 oid_to_hex(&commit->object.oid), opts->mainline);
1801 else
1802 parent = commit->parents->item;
1804 if (get_message(commit, &msg) != 0)
1805 return error(_("cannot get commit message for %s"),
1806 oid_to_hex(&commit->object.oid));
1808 if (opts->allow_ff && !is_fixup(command) &&
1809 ((parent && oideq(&parent->object.oid, &head)) ||
1810 (!parent && unborn))) {
1811 if (is_rebase_i(opts))
1812 write_author_script(msg.message);
1813 res = fast_forward_to(r, &commit->object.oid, &head, unborn,
1814 opts);
1815 if (res || command != TODO_REWORD)
1816 goto leave;
1817 flags |= EDIT_MSG | AMEND_MSG | VERIFY_MSG;
1818 msg_file = NULL;
1819 goto fast_forward_edit;
1821 if (parent && parse_commit(parent) < 0)
1822 /* TRANSLATORS: The first %s will be a "todo" command like
1823 "revert" or "pick", the second %s a SHA1. */
1824 return error(_("%s: cannot parse parent commit %s"),
1825 command_to_string(command),
1826 oid_to_hex(&parent->object.oid));
1829 * "commit" is an existing commit. We would want to apply
1830 * the difference it introduces since its first parent "prev"
1831 * on top of the current HEAD if we are cherry-pick. Or the
1832 * reverse of it if we are revert.
1835 if (command == TODO_REVERT) {
1836 base = commit;
1837 base_label = msg.label;
1838 next = parent;
1839 next_label = msg.parent_label;
1840 strbuf_addstr(&msgbuf, "Revert \"");
1841 strbuf_addstr(&msgbuf, msg.subject);
1842 strbuf_addstr(&msgbuf, "\"\n\nThis reverts commit ");
1843 strbuf_addstr(&msgbuf, oid_to_hex(&commit->object.oid));
1845 if (commit->parents && commit->parents->next) {
1846 strbuf_addstr(&msgbuf, ", reversing\nchanges made to ");
1847 strbuf_addstr(&msgbuf, oid_to_hex(&parent->object.oid));
1849 strbuf_addstr(&msgbuf, ".\n");
1850 } else {
1851 const char *p;
1853 base = parent;
1854 base_label = msg.parent_label;
1855 next = commit;
1856 next_label = msg.label;
1858 /* Append the commit log message to msgbuf. */
1859 if (find_commit_subject(msg.message, &p))
1860 strbuf_addstr(&msgbuf, p);
1862 if (opts->record_origin) {
1863 strbuf_complete_line(&msgbuf);
1864 if (!has_conforming_footer(&msgbuf, NULL, 0))
1865 strbuf_addch(&msgbuf, '\n');
1866 strbuf_addstr(&msgbuf, cherry_picked_prefix);
1867 strbuf_addstr(&msgbuf, oid_to_hex(&commit->object.oid));
1868 strbuf_addstr(&msgbuf, ")\n");
1870 if (!is_fixup(command))
1871 author = get_author(msg.message);
1874 if (command == TODO_REWORD)
1875 flags |= EDIT_MSG | VERIFY_MSG;
1876 else if (is_fixup(command)) {
1877 if (update_squash_messages(r, command, commit, opts))
1878 return -1;
1879 flags |= AMEND_MSG;
1880 if (!final_fixup)
1881 msg_file = rebase_path_squash_msg();
1882 else if (file_exists(rebase_path_fixup_msg())) {
1883 flags |= CLEANUP_MSG;
1884 msg_file = rebase_path_fixup_msg();
1885 } else {
1886 const char *dest = git_path_squash_msg(r);
1887 unlink(dest);
1888 if (copy_file(dest, rebase_path_squash_msg(), 0666))
1889 return error(_("could not rename '%s' to '%s'"),
1890 rebase_path_squash_msg(), dest);
1891 unlink(git_path_merge_msg(r));
1892 msg_file = dest;
1893 flags |= EDIT_MSG;
1897 if (opts->signoff && !is_fixup(command))
1898 append_signoff(&msgbuf, 0, 0);
1900 if (is_rebase_i(opts) && write_author_script(msg.message) < 0)
1901 res = -1;
1902 else if (!opts->strategy || !strcmp(opts->strategy, "recursive") || command == TODO_REVERT) {
1903 res = do_recursive_merge(r, base, next, base_label, next_label,
1904 &head, &msgbuf, opts);
1905 if (res < 0)
1906 goto leave;
1908 res |= write_message(msgbuf.buf, msgbuf.len,
1909 git_path_merge_msg(r), 0);
1910 } else {
1911 struct commit_list *common = NULL;
1912 struct commit_list *remotes = NULL;
1914 res = write_message(msgbuf.buf, msgbuf.len,
1915 git_path_merge_msg(r), 0);
1917 commit_list_insert(base, &common);
1918 commit_list_insert(next, &remotes);
1919 res |= try_merge_command(r, opts->strategy,
1920 opts->xopts_nr, (const char **)opts->xopts,
1921 common, oid_to_hex(&head), remotes);
1922 free_commit_list(common);
1923 free_commit_list(remotes);
1925 strbuf_release(&msgbuf);
1928 * If the merge was clean or if it failed due to conflict, we write
1929 * CHERRY_PICK_HEAD for the subsequent invocation of commit to use.
1930 * However, if the merge did not even start, then we don't want to
1931 * write it at all.
1933 if (command == TODO_PICK && !opts->no_commit && (res == 0 || res == 1) &&
1934 update_ref(NULL, "CHERRY_PICK_HEAD", &commit->object.oid, NULL,
1935 REF_NO_DEREF, UPDATE_REFS_MSG_ON_ERR))
1936 res = -1;
1937 if (command == TODO_REVERT && ((opts->no_commit && res == 0) || res == 1) &&
1938 update_ref(NULL, "REVERT_HEAD", &commit->object.oid, NULL,
1939 REF_NO_DEREF, UPDATE_REFS_MSG_ON_ERR))
1940 res = -1;
1942 if (res) {
1943 error(command == TODO_REVERT
1944 ? _("could not revert %s... %s")
1945 : _("could not apply %s... %s"),
1946 short_commit_name(commit), msg.subject);
1947 print_advice(r, res == 1, opts);
1948 repo_rerere(r, opts->allow_rerere_auto);
1949 goto leave;
1952 allow = allow_empty(r, opts, commit);
1953 if (allow < 0) {
1954 res = allow;
1955 goto leave;
1956 } else if (allow)
1957 flags |= ALLOW_EMPTY;
1958 if (!opts->no_commit) {
1959 fast_forward_edit:
1960 if (author || command == TODO_REVERT || (flags & AMEND_MSG))
1961 res = do_commit(r, msg_file, author, opts, flags);
1962 else
1963 res = error(_("unable to parse commit author"));
1966 if (!res && final_fixup) {
1967 unlink(rebase_path_fixup_msg());
1968 unlink(rebase_path_squash_msg());
1969 unlink(rebase_path_current_fixups());
1970 strbuf_reset(&opts->current_fixups);
1971 opts->current_fixup_count = 0;
1974 leave:
1975 free_message(commit, &msg);
1976 free(author);
1977 update_abort_safety_file();
1979 return res;
1982 static int prepare_revs(struct replay_opts *opts)
1985 * picking (but not reverting) ranges (but not individual revisions)
1986 * should be done in reverse
1988 if (opts->action == REPLAY_PICK && !opts->revs->no_walk)
1989 opts->revs->reverse ^= 1;
1991 if (prepare_revision_walk(opts->revs))
1992 return error(_("revision walk setup failed"));
1994 return 0;
1997 static int read_and_refresh_cache(struct repository *r,
1998 struct replay_opts *opts)
2000 struct lock_file index_lock = LOCK_INIT;
2001 int index_fd = hold_locked_index(&index_lock, 0);
2002 if (read_index(r->index) < 0) {
2003 rollback_lock_file(&index_lock);
2004 return error(_("git %s: failed to read the index"),
2005 _(action_name(opts)));
2007 refresh_index(r->index, REFRESH_QUIET|REFRESH_UNMERGED, NULL, NULL, NULL);
2008 if (index_fd >= 0) {
2009 if (write_locked_index(r->index, &index_lock,
2010 COMMIT_LOCK | SKIP_IF_UNCHANGED)) {
2011 return error(_("git %s: failed to refresh the index"),
2012 _(action_name(opts)));
2015 return 0;
2018 enum todo_item_flags {
2019 TODO_EDIT_MERGE_MSG = 1
2022 struct todo_item {
2023 enum todo_command command;
2024 struct commit *commit;
2025 unsigned int flags;
2026 const char *arg;
2027 int arg_len;
2028 size_t offset_in_buf;
2031 struct todo_list {
2032 struct strbuf buf;
2033 struct todo_item *items;
2034 int nr, alloc, current;
2035 int done_nr, total_nr;
2036 struct stat_data stat;
2039 #define TODO_LIST_INIT { STRBUF_INIT }
2041 static void todo_list_release(struct todo_list *todo_list)
2043 strbuf_release(&todo_list->buf);
2044 FREE_AND_NULL(todo_list->items);
2045 todo_list->nr = todo_list->alloc = 0;
2048 static struct todo_item *append_new_todo(struct todo_list *todo_list)
2050 ALLOC_GROW(todo_list->items, todo_list->nr + 1, todo_list->alloc);
2051 return todo_list->items + todo_list->nr++;
2054 static int parse_insn_line(struct repository *r, struct todo_item *item,
2055 const char *bol, char *eol)
2057 struct object_id commit_oid;
2058 char *end_of_object_name;
2059 int i, saved, status, padding;
2061 item->flags = 0;
2063 /* left-trim */
2064 bol += strspn(bol, " \t");
2066 if (bol == eol || *bol == '\r' || *bol == comment_line_char) {
2067 item->command = TODO_COMMENT;
2068 item->commit = NULL;
2069 item->arg = bol;
2070 item->arg_len = eol - bol;
2071 return 0;
2074 for (i = 0; i < TODO_COMMENT; i++)
2075 if (skip_prefix(bol, todo_command_info[i].str, &bol)) {
2076 item->command = i;
2077 break;
2078 } else if ((bol + 1 == eol || bol[1] == ' ') &&
2079 *bol == todo_command_info[i].c) {
2080 bol++;
2081 item->command = i;
2082 break;
2084 if (i >= TODO_COMMENT)
2085 return -1;
2087 /* Eat up extra spaces/ tabs before object name */
2088 padding = strspn(bol, " \t");
2089 bol += padding;
2091 if (item->command == TODO_NOOP || item->command == TODO_BREAK) {
2092 if (bol != eol)
2093 return error(_("%s does not accept arguments: '%s'"),
2094 command_to_string(item->command), bol);
2095 item->commit = NULL;
2096 item->arg = bol;
2097 item->arg_len = eol - bol;
2098 return 0;
2101 if (!padding)
2102 return error(_("missing arguments for %s"),
2103 command_to_string(item->command));
2105 if (item->command == TODO_EXEC || item->command == TODO_LABEL ||
2106 item->command == TODO_RESET) {
2107 item->commit = NULL;
2108 item->arg = bol;
2109 item->arg_len = (int)(eol - bol);
2110 return 0;
2113 if (item->command == TODO_MERGE) {
2114 if (skip_prefix(bol, "-C", &bol))
2115 bol += strspn(bol, " \t");
2116 else if (skip_prefix(bol, "-c", &bol)) {
2117 bol += strspn(bol, " \t");
2118 item->flags |= TODO_EDIT_MERGE_MSG;
2119 } else {
2120 item->flags |= TODO_EDIT_MERGE_MSG;
2121 item->commit = NULL;
2122 item->arg = bol;
2123 item->arg_len = (int)(eol - bol);
2124 return 0;
2128 end_of_object_name = (char *) bol + strcspn(bol, " \t\n");
2129 saved = *end_of_object_name;
2130 *end_of_object_name = '\0';
2131 status = get_oid(bol, &commit_oid);
2132 *end_of_object_name = saved;
2134 item->arg = end_of_object_name + strspn(end_of_object_name, " \t");
2135 item->arg_len = (int)(eol - item->arg);
2137 if (status < 0)
2138 return -1;
2140 item->commit = lookup_commit_reference(r, &commit_oid);
2141 return !item->commit;
2144 static int parse_insn_buffer(struct repository *r, char *buf,
2145 struct todo_list *todo_list)
2147 struct todo_item *item;
2148 char *p = buf, *next_p;
2149 int i, res = 0, fixup_okay = file_exists(rebase_path_done());
2151 for (i = 1; *p; i++, p = next_p) {
2152 char *eol = strchrnul(p, '\n');
2154 next_p = *eol ? eol + 1 /* skip LF */ : eol;
2156 if (p != eol && eol[-1] == '\r')
2157 eol--; /* strip Carriage Return */
2159 item = append_new_todo(todo_list);
2160 item->offset_in_buf = p - todo_list->buf.buf;
2161 if (parse_insn_line(r, item, p, eol)) {
2162 res = error(_("invalid line %d: %.*s"),
2163 i, (int)(eol - p), p);
2164 item->command = TODO_NOOP;
2167 if (fixup_okay)
2168 ; /* do nothing */
2169 else if (is_fixup(item->command))
2170 return error(_("cannot '%s' without a previous commit"),
2171 command_to_string(item->command));
2172 else if (!is_noop(item->command))
2173 fixup_okay = 1;
2176 return res;
2179 static int count_commands(struct todo_list *todo_list)
2181 int count = 0, i;
2183 for (i = 0; i < todo_list->nr; i++)
2184 if (todo_list->items[i].command != TODO_COMMENT)
2185 count++;
2187 return count;
2190 static int get_item_line_offset(struct todo_list *todo_list, int index)
2192 return index < todo_list->nr ?
2193 todo_list->items[index].offset_in_buf : todo_list->buf.len;
2196 static const char *get_item_line(struct todo_list *todo_list, int index)
2198 return todo_list->buf.buf + get_item_line_offset(todo_list, index);
2201 static int get_item_line_length(struct todo_list *todo_list, int index)
2203 return get_item_line_offset(todo_list, index + 1)
2204 - get_item_line_offset(todo_list, index);
2207 static ssize_t strbuf_read_file_or_whine(struct strbuf *sb, const char *path)
2209 int fd;
2210 ssize_t len;
2212 fd = open(path, O_RDONLY);
2213 if (fd < 0)
2214 return error_errno(_("could not open '%s'"), path);
2215 len = strbuf_read(sb, fd, 0);
2216 close(fd);
2217 if (len < 0)
2218 return error(_("could not read '%s'."), path);
2219 return len;
2222 static int read_populate_todo(struct repository *r,
2223 struct todo_list *todo_list,
2224 struct replay_opts *opts)
2226 struct stat st;
2227 const char *todo_file = get_todo_path(opts);
2228 int res;
2230 strbuf_reset(&todo_list->buf);
2231 if (strbuf_read_file_or_whine(&todo_list->buf, todo_file) < 0)
2232 return -1;
2234 res = stat(todo_file, &st);
2235 if (res)
2236 return error(_("could not stat '%s'"), todo_file);
2237 fill_stat_data(&todo_list->stat, &st);
2239 res = parse_insn_buffer(r, todo_list->buf.buf, todo_list);
2240 if (res) {
2241 if (is_rebase_i(opts))
2242 return error(_("please fix this using "
2243 "'git rebase --edit-todo'."));
2244 return error(_("unusable instruction sheet: '%s'"), todo_file);
2247 if (!todo_list->nr &&
2248 (!is_rebase_i(opts) || !file_exists(rebase_path_done())))
2249 return error(_("no commits parsed."));
2251 if (!is_rebase_i(opts)) {
2252 enum todo_command valid =
2253 opts->action == REPLAY_PICK ? TODO_PICK : TODO_REVERT;
2254 int i;
2256 for (i = 0; i < todo_list->nr; i++)
2257 if (valid == todo_list->items[i].command)
2258 continue;
2259 else if (valid == TODO_PICK)
2260 return error(_("cannot cherry-pick during a revert."));
2261 else
2262 return error(_("cannot revert during a cherry-pick."));
2265 if (is_rebase_i(opts)) {
2266 struct todo_list done = TODO_LIST_INIT;
2267 FILE *f = fopen_or_warn(rebase_path_msgtotal(), "w");
2269 if (strbuf_read_file(&done.buf, rebase_path_done(), 0) > 0 &&
2270 !parse_insn_buffer(r, done.buf.buf, &done))
2271 todo_list->done_nr = count_commands(&done);
2272 else
2273 todo_list->done_nr = 0;
2275 todo_list->total_nr = todo_list->done_nr
2276 + count_commands(todo_list);
2277 todo_list_release(&done);
2279 if (f) {
2280 fprintf(f, "%d\n", todo_list->total_nr);
2281 fclose(f);
2285 return 0;
2288 static int git_config_string_dup(char **dest,
2289 const char *var, const char *value)
2291 if (!value)
2292 return config_error_nonbool(var);
2293 free(*dest);
2294 *dest = xstrdup(value);
2295 return 0;
2298 static int populate_opts_cb(const char *key, const char *value, void *data)
2300 struct replay_opts *opts = data;
2301 int error_flag = 1;
2303 if (!value)
2304 error_flag = 0;
2305 else if (!strcmp(key, "options.no-commit"))
2306 opts->no_commit = git_config_bool_or_int(key, value, &error_flag);
2307 else if (!strcmp(key, "options.edit"))
2308 opts->edit = git_config_bool_or_int(key, value, &error_flag);
2309 else if (!strcmp(key, "options.signoff"))
2310 opts->signoff = git_config_bool_or_int(key, value, &error_flag);
2311 else if (!strcmp(key, "options.record-origin"))
2312 opts->record_origin = git_config_bool_or_int(key, value, &error_flag);
2313 else if (!strcmp(key, "options.allow-ff"))
2314 opts->allow_ff = git_config_bool_or_int(key, value, &error_flag);
2315 else if (!strcmp(key, "options.mainline"))
2316 opts->mainline = git_config_int(key, value);
2317 else if (!strcmp(key, "options.strategy"))
2318 git_config_string_dup(&opts->strategy, key, value);
2319 else if (!strcmp(key, "options.gpg-sign"))
2320 git_config_string_dup(&opts->gpg_sign, key, value);
2321 else if (!strcmp(key, "options.strategy-option")) {
2322 ALLOC_GROW(opts->xopts, opts->xopts_nr + 1, opts->xopts_alloc);
2323 opts->xopts[opts->xopts_nr++] = xstrdup(value);
2324 } else if (!strcmp(key, "options.allow-rerere-auto"))
2325 opts->allow_rerere_auto =
2326 git_config_bool_or_int(key, value, &error_flag) ?
2327 RERERE_AUTOUPDATE : RERERE_NOAUTOUPDATE;
2328 else
2329 return error(_("invalid key: %s"), key);
2331 if (!error_flag)
2332 return error(_("invalid value for %s: %s"), key, value);
2334 return 0;
2337 void parse_strategy_opts(struct replay_opts *opts, char *raw_opts)
2339 int i;
2340 char *strategy_opts_string = raw_opts;
2342 if (*strategy_opts_string == ' ')
2343 strategy_opts_string++;
2345 opts->xopts_nr = split_cmdline(strategy_opts_string,
2346 (const char ***)&opts->xopts);
2347 for (i = 0; i < opts->xopts_nr; i++) {
2348 const char *arg = opts->xopts[i];
2350 skip_prefix(arg, "--", &arg);
2351 opts->xopts[i] = xstrdup(arg);
2355 static void read_strategy_opts(struct replay_opts *opts, struct strbuf *buf)
2357 strbuf_reset(buf);
2358 if (!read_oneliner(buf, rebase_path_strategy(), 0))
2359 return;
2360 opts->strategy = strbuf_detach(buf, NULL);
2361 if (!read_oneliner(buf, rebase_path_strategy_opts(), 0))
2362 return;
2364 parse_strategy_opts(opts, buf->buf);
2367 static int read_populate_opts(struct replay_opts *opts)
2369 if (is_rebase_i(opts)) {
2370 struct strbuf buf = STRBUF_INIT;
2372 if (read_oneliner(&buf, rebase_path_gpg_sign_opt(), 1)) {
2373 if (!starts_with(buf.buf, "-S"))
2374 strbuf_reset(&buf);
2375 else {
2376 free(opts->gpg_sign);
2377 opts->gpg_sign = xstrdup(buf.buf + 2);
2379 strbuf_reset(&buf);
2382 if (read_oneliner(&buf, rebase_path_allow_rerere_autoupdate(), 1)) {
2383 if (!strcmp(buf.buf, "--rerere-autoupdate"))
2384 opts->allow_rerere_auto = RERERE_AUTOUPDATE;
2385 else if (!strcmp(buf.buf, "--no-rerere-autoupdate"))
2386 opts->allow_rerere_auto = RERERE_NOAUTOUPDATE;
2387 strbuf_reset(&buf);
2390 if (file_exists(rebase_path_verbose()))
2391 opts->verbose = 1;
2393 if (file_exists(rebase_path_signoff())) {
2394 opts->allow_ff = 0;
2395 opts->signoff = 1;
2398 if (file_exists(rebase_path_reschedule_failed_exec()))
2399 opts->reschedule_failed_exec = 1;
2401 read_strategy_opts(opts, &buf);
2402 strbuf_release(&buf);
2404 if (read_oneliner(&opts->current_fixups,
2405 rebase_path_current_fixups(), 1)) {
2406 const char *p = opts->current_fixups.buf;
2407 opts->current_fixup_count = 1;
2408 while ((p = strchr(p, '\n'))) {
2409 opts->current_fixup_count++;
2410 p++;
2414 if (read_oneliner(&buf, rebase_path_squash_onto(), 0)) {
2415 if (get_oid_hex(buf.buf, &opts->squash_onto) < 0)
2416 return error(_("unusable squash-onto"));
2417 opts->have_squash_onto = 1;
2420 return 0;
2423 if (!file_exists(git_path_opts_file()))
2424 return 0;
2426 * The function git_parse_source(), called from git_config_from_file(),
2427 * may die() in case of a syntactically incorrect file. We do not care
2428 * about this case, though, because we wrote that file ourselves, so we
2429 * are pretty certain that it is syntactically correct.
2431 if (git_config_from_file(populate_opts_cb, git_path_opts_file(), opts) < 0)
2432 return error(_("malformed options sheet: '%s'"),
2433 git_path_opts_file());
2434 return 0;
2437 static void write_strategy_opts(struct replay_opts *opts)
2439 int i;
2440 struct strbuf buf = STRBUF_INIT;
2442 for (i = 0; i < opts->xopts_nr; ++i)
2443 strbuf_addf(&buf, " --%s", opts->xopts[i]);
2445 write_file(rebase_path_strategy_opts(), "%s\n", buf.buf);
2446 strbuf_release(&buf);
2449 int write_basic_state(struct replay_opts *opts, const char *head_name,
2450 const char *onto, const char *orig_head)
2452 const char *quiet = getenv("GIT_QUIET");
2454 if (head_name)
2455 write_file(rebase_path_head_name(), "%s\n", head_name);
2456 if (onto)
2457 write_file(rebase_path_onto(), "%s\n", onto);
2458 if (orig_head)
2459 write_file(rebase_path_orig_head(), "%s\n", orig_head);
2461 if (quiet)
2462 write_file(rebase_path_quiet(), "%s\n", quiet);
2463 else
2464 write_file(rebase_path_quiet(), "\n");
2466 if (opts->verbose)
2467 write_file(rebase_path_verbose(), "%s", "");
2468 if (opts->strategy)
2469 write_file(rebase_path_strategy(), "%s\n", opts->strategy);
2470 if (opts->xopts_nr > 0)
2471 write_strategy_opts(opts);
2473 if (opts->allow_rerere_auto == RERERE_AUTOUPDATE)
2474 write_file(rebase_path_allow_rerere_autoupdate(), "--rerere-autoupdate\n");
2475 else if (opts->allow_rerere_auto == RERERE_NOAUTOUPDATE)
2476 write_file(rebase_path_allow_rerere_autoupdate(), "--no-rerere-autoupdate\n");
2478 if (opts->gpg_sign)
2479 write_file(rebase_path_gpg_sign_opt(), "-S%s\n", opts->gpg_sign);
2480 if (opts->signoff)
2481 write_file(rebase_path_signoff(), "--signoff\n");
2482 if (opts->reschedule_failed_exec)
2483 write_file(rebase_path_reschedule_failed_exec(), "%s", "");
2485 return 0;
2488 static int walk_revs_populate_todo(struct todo_list *todo_list,
2489 struct replay_opts *opts)
2491 enum todo_command command = opts->action == REPLAY_PICK ?
2492 TODO_PICK : TODO_REVERT;
2493 const char *command_string = todo_command_info[command].str;
2494 struct commit *commit;
2496 if (prepare_revs(opts))
2497 return -1;
2499 while ((commit = get_revision(opts->revs))) {
2500 struct todo_item *item = append_new_todo(todo_list);
2501 const char *commit_buffer = get_commit_buffer(commit, NULL);
2502 const char *subject;
2503 int subject_len;
2505 item->command = command;
2506 item->commit = commit;
2507 item->arg = NULL;
2508 item->arg_len = 0;
2509 item->offset_in_buf = todo_list->buf.len;
2510 subject_len = find_commit_subject(commit_buffer, &subject);
2511 strbuf_addf(&todo_list->buf, "%s %s %.*s\n", command_string,
2512 short_commit_name(commit), subject_len, subject);
2513 unuse_commit_buffer(commit, commit_buffer);
2516 if (!todo_list->nr)
2517 return error(_("empty commit set passed"));
2519 return 0;
2522 static int create_seq_dir(void)
2524 if (file_exists(git_path_seq_dir())) {
2525 error(_("a cherry-pick or revert is already in progress"));
2526 advise(_("try \"git cherry-pick (--continue | --quit | --abort)\""));
2527 return -1;
2528 } else if (mkdir(git_path_seq_dir(), 0777) < 0)
2529 return error_errno(_("could not create sequencer directory '%s'"),
2530 git_path_seq_dir());
2531 return 0;
2534 static int save_head(const char *head)
2536 struct lock_file head_lock = LOCK_INIT;
2537 struct strbuf buf = STRBUF_INIT;
2538 int fd;
2539 ssize_t written;
2541 fd = hold_lock_file_for_update(&head_lock, git_path_head_file(), 0);
2542 if (fd < 0)
2543 return error_errno(_("could not lock HEAD"));
2544 strbuf_addf(&buf, "%s\n", head);
2545 written = write_in_full(fd, buf.buf, buf.len);
2546 strbuf_release(&buf);
2547 if (written < 0) {
2548 error_errno(_("could not write to '%s'"), git_path_head_file());
2549 rollback_lock_file(&head_lock);
2550 return -1;
2552 if (commit_lock_file(&head_lock) < 0)
2553 return error(_("failed to finalize '%s'"), git_path_head_file());
2554 return 0;
2557 static int rollback_is_safe(void)
2559 struct strbuf sb = STRBUF_INIT;
2560 struct object_id expected_head, actual_head;
2562 if (strbuf_read_file(&sb, git_path_abort_safety_file(), 0) >= 0) {
2563 strbuf_trim(&sb);
2564 if (get_oid_hex(sb.buf, &expected_head)) {
2565 strbuf_release(&sb);
2566 die(_("could not parse %s"), git_path_abort_safety_file());
2568 strbuf_release(&sb);
2570 else if (errno == ENOENT)
2571 oidclr(&expected_head);
2572 else
2573 die_errno(_("could not read '%s'"), git_path_abort_safety_file());
2575 if (get_oid("HEAD", &actual_head))
2576 oidclr(&actual_head);
2578 return oideq(&actual_head, &expected_head);
2581 static int reset_for_rollback(const struct object_id *oid)
2583 const char *argv[4]; /* reset --merge <arg> + NULL */
2585 argv[0] = "reset";
2586 argv[1] = "--merge";
2587 argv[2] = oid_to_hex(oid);
2588 argv[3] = NULL;
2589 return run_command_v_opt(argv, RUN_GIT_CMD);
2592 static int rollback_single_pick(struct repository *r)
2594 struct object_id head_oid;
2596 if (!file_exists(git_path_cherry_pick_head(r)) &&
2597 !file_exists(git_path_revert_head(r)))
2598 return error(_("no cherry-pick or revert in progress"));
2599 if (read_ref_full("HEAD", 0, &head_oid, NULL))
2600 return error(_("cannot resolve HEAD"));
2601 if (is_null_oid(&head_oid))
2602 return error(_("cannot abort from a branch yet to be born"));
2603 return reset_for_rollback(&head_oid);
2606 int sequencer_rollback(struct repository *r, struct replay_opts *opts)
2608 FILE *f;
2609 struct object_id oid;
2610 struct strbuf buf = STRBUF_INIT;
2611 const char *p;
2613 f = fopen(git_path_head_file(), "r");
2614 if (!f && errno == ENOENT) {
2616 * There is no multiple-cherry-pick in progress.
2617 * If CHERRY_PICK_HEAD or REVERT_HEAD indicates
2618 * a single-cherry-pick in progress, abort that.
2620 return rollback_single_pick(r);
2622 if (!f)
2623 return error_errno(_("cannot open '%s'"), git_path_head_file());
2624 if (strbuf_getline_lf(&buf, f)) {
2625 error(_("cannot read '%s': %s"), git_path_head_file(),
2626 ferror(f) ? strerror(errno) : _("unexpected end of file"));
2627 fclose(f);
2628 goto fail;
2630 fclose(f);
2631 if (parse_oid_hex(buf.buf, &oid, &p) || *p != '\0') {
2632 error(_("stored pre-cherry-pick HEAD file '%s' is corrupt"),
2633 git_path_head_file());
2634 goto fail;
2636 if (is_null_oid(&oid)) {
2637 error(_("cannot abort from a branch yet to be born"));
2638 goto fail;
2641 if (!rollback_is_safe()) {
2642 /* Do not error, just do not rollback */
2643 warning(_("You seem to have moved HEAD. "
2644 "Not rewinding, check your HEAD!"));
2645 } else
2646 if (reset_for_rollback(&oid))
2647 goto fail;
2648 strbuf_release(&buf);
2649 return sequencer_remove_state(opts);
2650 fail:
2651 strbuf_release(&buf);
2652 return -1;
2655 static int save_todo(struct todo_list *todo_list, struct replay_opts *opts)
2657 struct lock_file todo_lock = LOCK_INIT;
2658 const char *todo_path = get_todo_path(opts);
2659 int next = todo_list->current, offset, fd;
2662 * rebase -i writes "git-rebase-todo" without the currently executing
2663 * command, appending it to "done" instead.
2665 if (is_rebase_i(opts))
2666 next++;
2668 fd = hold_lock_file_for_update(&todo_lock, todo_path, 0);
2669 if (fd < 0)
2670 return error_errno(_("could not lock '%s'"), todo_path);
2671 offset = get_item_line_offset(todo_list, next);
2672 if (write_in_full(fd, todo_list->buf.buf + offset,
2673 todo_list->buf.len - offset) < 0)
2674 return error_errno(_("could not write to '%s'"), todo_path);
2675 if (commit_lock_file(&todo_lock) < 0)
2676 return error(_("failed to finalize '%s'"), todo_path);
2678 if (is_rebase_i(opts) && next > 0) {
2679 const char *done = rebase_path_done();
2680 int fd = open(done, O_CREAT | O_WRONLY | O_APPEND, 0666);
2681 int ret = 0;
2683 if (fd < 0)
2684 return 0;
2685 if (write_in_full(fd, get_item_line(todo_list, next - 1),
2686 get_item_line_length(todo_list, next - 1))
2687 < 0)
2688 ret = error_errno(_("could not write to '%s'"), done);
2689 if (close(fd) < 0)
2690 ret = error_errno(_("failed to finalize '%s'"), done);
2691 return ret;
2693 return 0;
2696 static int save_opts(struct replay_opts *opts)
2698 const char *opts_file = git_path_opts_file();
2699 int res = 0;
2701 if (opts->no_commit)
2702 res |= git_config_set_in_file_gently(opts_file, "options.no-commit", "true");
2703 if (opts->edit)
2704 res |= git_config_set_in_file_gently(opts_file, "options.edit", "true");
2705 if (opts->signoff)
2706 res |= git_config_set_in_file_gently(opts_file, "options.signoff", "true");
2707 if (opts->record_origin)
2708 res |= git_config_set_in_file_gently(opts_file, "options.record-origin", "true");
2709 if (opts->allow_ff)
2710 res |= git_config_set_in_file_gently(opts_file, "options.allow-ff", "true");
2711 if (opts->mainline) {
2712 struct strbuf buf = STRBUF_INIT;
2713 strbuf_addf(&buf, "%d", opts->mainline);
2714 res |= git_config_set_in_file_gently(opts_file, "options.mainline", buf.buf);
2715 strbuf_release(&buf);
2717 if (opts->strategy)
2718 res |= git_config_set_in_file_gently(opts_file, "options.strategy", opts->strategy);
2719 if (opts->gpg_sign)
2720 res |= git_config_set_in_file_gently(opts_file, "options.gpg-sign", opts->gpg_sign);
2721 if (opts->xopts) {
2722 int i;
2723 for (i = 0; i < opts->xopts_nr; i++)
2724 res |= git_config_set_multivar_in_file_gently(opts_file,
2725 "options.strategy-option",
2726 opts->xopts[i], "^$", 0);
2728 if (opts->allow_rerere_auto)
2729 res |= git_config_set_in_file_gently(opts_file, "options.allow-rerere-auto",
2730 opts->allow_rerere_auto == RERERE_AUTOUPDATE ?
2731 "true" : "false");
2732 return res;
2735 static int make_patch(struct repository *r,
2736 struct commit *commit,
2737 struct replay_opts *opts)
2739 struct strbuf buf = STRBUF_INIT;
2740 struct rev_info log_tree_opt;
2741 const char *subject, *p;
2742 int res = 0;
2744 p = short_commit_name(commit);
2745 if (write_message(p, strlen(p), rebase_path_stopped_sha(), 1) < 0)
2746 return -1;
2747 if (update_ref("rebase", "REBASE_HEAD", &commit->object.oid,
2748 NULL, REF_NO_DEREF, UPDATE_REFS_MSG_ON_ERR))
2749 res |= error(_("could not update %s"), "REBASE_HEAD");
2751 strbuf_addf(&buf, "%s/patch", get_dir(opts));
2752 memset(&log_tree_opt, 0, sizeof(log_tree_opt));
2753 repo_init_revisions(r, &log_tree_opt, NULL);
2754 log_tree_opt.abbrev = 0;
2755 log_tree_opt.diff = 1;
2756 log_tree_opt.diffopt.output_format = DIFF_FORMAT_PATCH;
2757 log_tree_opt.disable_stdin = 1;
2758 log_tree_opt.no_commit_id = 1;
2759 log_tree_opt.diffopt.file = fopen(buf.buf, "w");
2760 log_tree_opt.diffopt.use_color = GIT_COLOR_NEVER;
2761 if (!log_tree_opt.diffopt.file)
2762 res |= error_errno(_("could not open '%s'"), buf.buf);
2763 else {
2764 res |= log_tree_commit(&log_tree_opt, commit);
2765 fclose(log_tree_opt.diffopt.file);
2767 strbuf_reset(&buf);
2769 strbuf_addf(&buf, "%s/message", get_dir(opts));
2770 if (!file_exists(buf.buf)) {
2771 const char *commit_buffer = get_commit_buffer(commit, NULL);
2772 find_commit_subject(commit_buffer, &subject);
2773 res |= write_message(subject, strlen(subject), buf.buf, 1);
2774 unuse_commit_buffer(commit, commit_buffer);
2776 strbuf_release(&buf);
2778 return res;
2781 static int intend_to_amend(void)
2783 struct object_id head;
2784 char *p;
2786 if (get_oid("HEAD", &head))
2787 return error(_("cannot read HEAD"));
2789 p = oid_to_hex(&head);
2790 return write_message(p, strlen(p), rebase_path_amend(), 1);
2793 static int error_with_patch(struct repository *r,
2794 struct commit *commit,
2795 const char *subject, int subject_len,
2796 struct replay_opts *opts,
2797 int exit_code, int to_amend)
2799 if (commit) {
2800 if (make_patch(r, commit, opts))
2801 return -1;
2802 } else if (copy_file(rebase_path_message(),
2803 git_path_merge_msg(r), 0666))
2804 return error(_("unable to copy '%s' to '%s'"),
2805 git_path_merge_msg(r), rebase_path_message());
2807 if (to_amend) {
2808 if (intend_to_amend())
2809 return -1;
2811 fprintf(stderr,
2812 _("You can amend the commit now, with\n"
2813 "\n"
2814 " git commit --amend %s\n"
2815 "\n"
2816 "Once you are satisfied with your changes, run\n"
2817 "\n"
2818 " git rebase --continue\n"),
2819 gpg_sign_opt_quoted(opts));
2820 } else if (exit_code) {
2821 if (commit)
2822 fprintf_ln(stderr, _("Could not apply %s... %.*s"),
2823 short_commit_name(commit), subject_len, subject);
2824 else
2826 * We don't have the hash of the parent so
2827 * just print the line from the todo file.
2829 fprintf_ln(stderr, _("Could not merge %.*s"),
2830 subject_len, subject);
2833 return exit_code;
2836 static int error_failed_squash(struct repository *r,
2837 struct commit *commit,
2838 struct replay_opts *opts,
2839 int subject_len,
2840 const char *subject)
2842 if (copy_file(rebase_path_message(), rebase_path_squash_msg(), 0666))
2843 return error(_("could not copy '%s' to '%s'"),
2844 rebase_path_squash_msg(), rebase_path_message());
2845 unlink(git_path_merge_msg(r));
2846 if (copy_file(git_path_merge_msg(r), rebase_path_message(), 0666))
2847 return error(_("could not copy '%s' to '%s'"),
2848 rebase_path_message(),
2849 git_path_merge_msg(r));
2850 return error_with_patch(r, commit, subject, subject_len, opts, 1, 0);
2853 static int do_exec(struct repository *r, const char *command_line)
2855 struct argv_array child_env = ARGV_ARRAY_INIT;
2856 const char *child_argv[] = { NULL, NULL };
2857 int dirty, status;
2859 fprintf(stderr, "Executing: %s\n", command_line);
2860 child_argv[0] = command_line;
2861 argv_array_pushf(&child_env, "GIT_DIR=%s", absolute_path(get_git_dir()));
2862 argv_array_pushf(&child_env, "GIT_WORK_TREE=%s",
2863 absolute_path(get_git_work_tree()));
2864 status = run_command_v_opt_cd_env(child_argv, RUN_USING_SHELL, NULL,
2865 child_env.argv);
2867 /* force re-reading of the cache */
2868 if (discard_index(r->index) < 0 || read_index(r->index) < 0)
2869 return error(_("could not read index"));
2871 dirty = require_clean_work_tree(r, "rebase", NULL, 1, 1);
2873 if (status) {
2874 warning(_("execution failed: %s\n%s"
2875 "You can fix the problem, and then run\n"
2876 "\n"
2877 " git rebase --continue\n"
2878 "\n"),
2879 command_line,
2880 dirty ? N_("and made changes to the index and/or the "
2881 "working tree\n") : "");
2882 if (status == 127)
2883 /* command not found */
2884 status = 1;
2885 } else if (dirty) {
2886 warning(_("execution succeeded: %s\nbut "
2887 "left changes to the index and/or the working tree\n"
2888 "Commit or stash your changes, and then run\n"
2889 "\n"
2890 " git rebase --continue\n"
2891 "\n"), command_line);
2892 status = 1;
2895 argv_array_clear(&child_env);
2897 return status;
2900 static int safe_append(const char *filename, const char *fmt, ...)
2902 va_list ap;
2903 struct lock_file lock = LOCK_INIT;
2904 int fd = hold_lock_file_for_update(&lock, filename,
2905 LOCK_REPORT_ON_ERROR);
2906 struct strbuf buf = STRBUF_INIT;
2908 if (fd < 0)
2909 return -1;
2911 if (strbuf_read_file(&buf, filename, 0) < 0 && errno != ENOENT) {
2912 error_errno(_("could not read '%s'"), filename);
2913 rollback_lock_file(&lock);
2914 return -1;
2916 strbuf_complete(&buf, '\n');
2917 va_start(ap, fmt);
2918 strbuf_vaddf(&buf, fmt, ap);
2919 va_end(ap);
2921 if (write_in_full(fd, buf.buf, buf.len) < 0) {
2922 error_errno(_("could not write to '%s'"), filename);
2923 strbuf_release(&buf);
2924 rollback_lock_file(&lock);
2925 return -1;
2927 if (commit_lock_file(&lock) < 0) {
2928 strbuf_release(&buf);
2929 rollback_lock_file(&lock);
2930 return error(_("failed to finalize '%s'"), filename);
2933 strbuf_release(&buf);
2934 return 0;
2937 static int do_label(struct repository *r, const char *name, int len)
2939 struct ref_store *refs = get_main_ref_store(r);
2940 struct ref_transaction *transaction;
2941 struct strbuf ref_name = STRBUF_INIT, err = STRBUF_INIT;
2942 struct strbuf msg = STRBUF_INIT;
2943 int ret = 0;
2944 struct object_id head_oid;
2946 if (len == 1 && *name == '#')
2947 return error(_("illegal label name: '%.*s'"), len, name);
2949 strbuf_addf(&ref_name, "refs/rewritten/%.*s", len, name);
2950 strbuf_addf(&msg, "rebase -i (label) '%.*s'", len, name);
2952 transaction = ref_store_transaction_begin(refs, &err);
2953 if (!transaction) {
2954 error("%s", err.buf);
2955 ret = -1;
2956 } else if (get_oid("HEAD", &head_oid)) {
2957 error(_("could not read HEAD"));
2958 ret = -1;
2959 } else if (ref_transaction_update(transaction, ref_name.buf, &head_oid,
2960 NULL, 0, msg.buf, &err) < 0 ||
2961 ref_transaction_commit(transaction, &err)) {
2962 error("%s", err.buf);
2963 ret = -1;
2965 ref_transaction_free(transaction);
2966 strbuf_release(&err);
2967 strbuf_release(&msg);
2969 if (!ret)
2970 ret = safe_append(rebase_path_refs_to_delete(),
2971 "%s\n", ref_name.buf);
2972 strbuf_release(&ref_name);
2974 return ret;
2977 static const char *reflog_message(struct replay_opts *opts,
2978 const char *sub_action, const char *fmt, ...);
2980 static int do_reset(struct repository *r,
2981 const char *name, int len,
2982 struct replay_opts *opts)
2984 struct strbuf ref_name = STRBUF_INIT;
2985 struct object_id oid;
2986 struct lock_file lock = LOCK_INIT;
2987 struct tree_desc desc;
2988 struct tree *tree;
2989 struct unpack_trees_options unpack_tree_opts;
2990 int ret = 0;
2992 if (hold_locked_index(&lock, LOCK_REPORT_ON_ERROR) < 0)
2993 return -1;
2995 if (len == 10 && !strncmp("[new root]", name, len)) {
2996 if (!opts->have_squash_onto) {
2997 const char *hex;
2998 if (commit_tree("", 0, the_hash_algo->empty_tree,
2999 NULL, &opts->squash_onto,
3000 NULL, NULL))
3001 return error(_("writing fake root commit"));
3002 opts->have_squash_onto = 1;
3003 hex = oid_to_hex(&opts->squash_onto);
3004 if (write_message(hex, strlen(hex),
3005 rebase_path_squash_onto(), 0))
3006 return error(_("writing squash-onto"));
3008 oidcpy(&oid, &opts->squash_onto);
3009 } else {
3010 int i;
3012 /* Determine the length of the label */
3013 for (i = 0; i < len; i++)
3014 if (isspace(name[i]))
3015 break;
3016 len = i;
3018 strbuf_addf(&ref_name, "refs/rewritten/%.*s", len, name);
3019 if (get_oid(ref_name.buf, &oid) &&
3020 get_oid(ref_name.buf + strlen("refs/rewritten/"), &oid)) {
3021 error(_("could not read '%s'"), ref_name.buf);
3022 rollback_lock_file(&lock);
3023 strbuf_release(&ref_name);
3024 return -1;
3028 memset(&unpack_tree_opts, 0, sizeof(unpack_tree_opts));
3029 setup_unpack_trees_porcelain(&unpack_tree_opts, "reset");
3030 unpack_tree_opts.head_idx = 1;
3031 unpack_tree_opts.src_index = r->index;
3032 unpack_tree_opts.dst_index = r->index;
3033 unpack_tree_opts.fn = oneway_merge;
3034 unpack_tree_opts.merge = 1;
3035 unpack_tree_opts.update = 1;
3037 if (read_index_unmerged(r->index)) {
3038 rollback_lock_file(&lock);
3039 strbuf_release(&ref_name);
3040 return error_resolve_conflict(_(action_name(opts)));
3043 if (!fill_tree_descriptor(&desc, &oid)) {
3044 error(_("failed to find tree of %s"), oid_to_hex(&oid));
3045 rollback_lock_file(&lock);
3046 free((void *)desc.buffer);
3047 strbuf_release(&ref_name);
3048 return -1;
3051 if (unpack_trees(1, &desc, &unpack_tree_opts)) {
3052 rollback_lock_file(&lock);
3053 free((void *)desc.buffer);
3054 strbuf_release(&ref_name);
3055 return -1;
3058 tree = parse_tree_indirect(&oid);
3059 prime_cache_tree(r, r->index, tree);
3061 if (write_locked_index(r->index, &lock, COMMIT_LOCK) < 0)
3062 ret = error(_("could not write index"));
3063 free((void *)desc.buffer);
3065 if (!ret)
3066 ret = update_ref(reflog_message(opts, "reset", "'%.*s'",
3067 len, name), "HEAD", &oid,
3068 NULL, 0, UPDATE_REFS_MSG_ON_ERR);
3070 strbuf_release(&ref_name);
3071 return ret;
3074 static struct commit *lookup_label(const char *label, int len,
3075 struct strbuf *buf)
3077 struct commit *commit;
3079 strbuf_reset(buf);
3080 strbuf_addf(buf, "refs/rewritten/%.*s", len, label);
3081 commit = lookup_commit_reference_by_name(buf->buf);
3082 if (!commit) {
3083 /* fall back to non-rewritten ref or commit */
3084 strbuf_splice(buf, 0, strlen("refs/rewritten/"), "", 0);
3085 commit = lookup_commit_reference_by_name(buf->buf);
3088 if (!commit)
3089 error(_("could not resolve '%s'"), buf->buf);
3091 return commit;
3094 static int do_merge(struct repository *r,
3095 struct commit *commit,
3096 const char *arg, int arg_len,
3097 int flags, struct replay_opts *opts)
3099 int run_commit_flags = (flags & TODO_EDIT_MERGE_MSG) ?
3100 EDIT_MSG | VERIFY_MSG : 0;
3101 struct strbuf ref_name = STRBUF_INIT;
3102 struct commit *head_commit, *merge_commit, *i;
3103 struct commit_list *bases, *j, *reversed = NULL;
3104 struct commit_list *to_merge = NULL, **tail = &to_merge;
3105 struct merge_options o;
3106 int merge_arg_len, oneline_offset, can_fast_forward, ret, k;
3107 static struct lock_file lock;
3108 const char *p;
3110 if (hold_locked_index(&lock, LOCK_REPORT_ON_ERROR) < 0) {
3111 ret = -1;
3112 goto leave_merge;
3115 head_commit = lookup_commit_reference_by_name("HEAD");
3116 if (!head_commit) {
3117 ret = error(_("cannot merge without a current revision"));
3118 goto leave_merge;
3122 * For octopus merges, the arg starts with the list of revisions to be
3123 * merged. The list is optionally followed by '#' and the oneline.
3125 merge_arg_len = oneline_offset = arg_len;
3126 for (p = arg; p - arg < arg_len; p += strspn(p, " \t\n")) {
3127 if (!*p)
3128 break;
3129 if (*p == '#' && (!p[1] || isspace(p[1]))) {
3130 p += 1 + strspn(p + 1, " \t\n");
3131 oneline_offset = p - arg;
3132 break;
3134 k = strcspn(p, " \t\n");
3135 if (!k)
3136 continue;
3137 merge_commit = lookup_label(p, k, &ref_name);
3138 if (!merge_commit) {
3139 ret = error(_("unable to parse '%.*s'"), k, p);
3140 goto leave_merge;
3142 tail = &commit_list_insert(merge_commit, tail)->next;
3143 p += k;
3144 merge_arg_len = p - arg;
3147 if (!to_merge) {
3148 ret = error(_("nothing to merge: '%.*s'"), arg_len, arg);
3149 goto leave_merge;
3152 if (opts->have_squash_onto &&
3153 oideq(&head_commit->object.oid, &opts->squash_onto)) {
3155 * When the user tells us to "merge" something into a
3156 * "[new root]", let's simply fast-forward to the merge head.
3158 rollback_lock_file(&lock);
3159 if (to_merge->next)
3160 ret = error(_("octopus merge cannot be executed on "
3161 "top of a [new root]"));
3162 else
3163 ret = fast_forward_to(r, &to_merge->item->object.oid,
3164 &head_commit->object.oid, 0,
3165 opts);
3166 goto leave_merge;
3169 if (commit) {
3170 const char *message = get_commit_buffer(commit, NULL);
3171 const char *body;
3172 int len;
3174 if (!message) {
3175 ret = error(_("could not get commit message of '%s'"),
3176 oid_to_hex(&commit->object.oid));
3177 goto leave_merge;
3179 write_author_script(message);
3180 find_commit_subject(message, &body);
3181 len = strlen(body);
3182 ret = write_message(body, len, git_path_merge_msg(r), 0);
3183 unuse_commit_buffer(commit, message);
3184 if (ret) {
3185 error_errno(_("could not write '%s'"),
3186 git_path_merge_msg(r));
3187 goto leave_merge;
3189 } else {
3190 struct strbuf buf = STRBUF_INIT;
3191 int len;
3193 strbuf_addf(&buf, "author %s", git_author_info(0));
3194 write_author_script(buf.buf);
3195 strbuf_reset(&buf);
3197 if (oneline_offset < arg_len) {
3198 p = arg + oneline_offset;
3199 len = arg_len - oneline_offset;
3200 } else {
3201 strbuf_addf(&buf, "Merge %s '%.*s'",
3202 to_merge->next ? "branches" : "branch",
3203 merge_arg_len, arg);
3204 p = buf.buf;
3205 len = buf.len;
3208 ret = write_message(p, len, git_path_merge_msg(r), 0);
3209 strbuf_release(&buf);
3210 if (ret) {
3211 error_errno(_("could not write '%s'"),
3212 git_path_merge_msg(r));
3213 goto leave_merge;
3218 * If HEAD is not identical to the first parent of the original merge
3219 * commit, we cannot fast-forward.
3221 can_fast_forward = opts->allow_ff && commit && commit->parents &&
3222 oideq(&commit->parents->item->object.oid,
3223 &head_commit->object.oid);
3226 * If any merge head is different from the original one, we cannot
3227 * fast-forward.
3229 if (can_fast_forward) {
3230 struct commit_list *p = commit->parents->next;
3232 for (j = to_merge; j && p; j = j->next, p = p->next)
3233 if (!oideq(&j->item->object.oid,
3234 &p->item->object.oid)) {
3235 can_fast_forward = 0;
3236 break;
3239 * If the number of merge heads differs from the original merge
3240 * commit, we cannot fast-forward.
3242 if (j || p)
3243 can_fast_forward = 0;
3246 if (can_fast_forward) {
3247 rollback_lock_file(&lock);
3248 ret = fast_forward_to(r, &commit->object.oid,
3249 &head_commit->object.oid, 0, opts);
3250 goto leave_merge;
3253 if (to_merge->next) {
3254 /* Octopus merge */
3255 struct child_process cmd = CHILD_PROCESS_INIT;
3257 if (read_env_script(&cmd.env_array)) {
3258 const char *gpg_opt = gpg_sign_opt_quoted(opts);
3260 ret = error(_(staged_changes_advice), gpg_opt, gpg_opt);
3261 goto leave_merge;
3264 cmd.git_cmd = 1;
3265 argv_array_push(&cmd.args, "merge");
3266 argv_array_push(&cmd.args, "-s");
3267 argv_array_push(&cmd.args, "octopus");
3268 argv_array_push(&cmd.args, "--no-edit");
3269 argv_array_push(&cmd.args, "--no-ff");
3270 argv_array_push(&cmd.args, "--no-log");
3271 argv_array_push(&cmd.args, "--no-stat");
3272 argv_array_push(&cmd.args, "-F");
3273 argv_array_push(&cmd.args, git_path_merge_msg(r));
3274 if (opts->gpg_sign)
3275 argv_array_push(&cmd.args, opts->gpg_sign);
3277 /* Add the tips to be merged */
3278 for (j = to_merge; j; j = j->next)
3279 argv_array_push(&cmd.args,
3280 oid_to_hex(&j->item->object.oid));
3282 strbuf_release(&ref_name);
3283 unlink(git_path_cherry_pick_head(r));
3284 rollback_lock_file(&lock);
3286 rollback_lock_file(&lock);
3287 ret = run_command(&cmd);
3289 /* force re-reading of the cache */
3290 if (!ret && (discard_index(r->index) < 0 ||
3291 read_index(r->index) < 0))
3292 ret = error(_("could not read index"));
3293 goto leave_merge;
3296 merge_commit = to_merge->item;
3297 bases = get_merge_bases(head_commit, merge_commit);
3298 if (bases && oideq(&merge_commit->object.oid,
3299 &bases->item->object.oid)) {
3300 ret = 0;
3301 /* skip merging an ancestor of HEAD */
3302 goto leave_merge;
3305 write_message(oid_to_hex(&merge_commit->object.oid), GIT_SHA1_HEXSZ,
3306 git_path_merge_head(r), 0);
3307 write_message("no-ff", 5, git_path_merge_mode(r), 0);
3309 for (j = bases; j; j = j->next)
3310 commit_list_insert(j->item, &reversed);
3311 free_commit_list(bases);
3313 read_index(r->index);
3314 init_merge_options(&o);
3315 o.branch1 = "HEAD";
3316 o.branch2 = ref_name.buf;
3317 o.buffer_output = 2;
3319 ret = merge_recursive(&o, head_commit, merge_commit, reversed, &i);
3320 if (ret <= 0)
3321 fputs(o.obuf.buf, stdout);
3322 strbuf_release(&o.obuf);
3323 if (ret < 0) {
3324 error(_("could not even attempt to merge '%.*s'"),
3325 merge_arg_len, arg);
3326 goto leave_merge;
3329 * The return value of merge_recursive() is 1 on clean, and 0 on
3330 * unclean merge.
3332 * Let's reverse that, so that do_merge() returns 0 upon success and
3333 * 1 upon failed merge (keeping the return value -1 for the cases where
3334 * we will want to reschedule the `merge` command).
3336 ret = !ret;
3338 if (r->index->cache_changed &&
3339 write_locked_index(r->index, &lock, COMMIT_LOCK)) {
3340 ret = error(_("merge: Unable to write new index file"));
3341 goto leave_merge;
3344 rollback_lock_file(&lock);
3345 if (ret)
3346 repo_rerere(r, opts->allow_rerere_auto);
3347 else
3349 * In case of problems, we now want to return a positive
3350 * value (a negative one would indicate that the `merge`
3351 * command needs to be rescheduled).
3353 ret = !!run_git_commit(r, git_path_merge_msg(r), opts,
3354 run_commit_flags);
3356 leave_merge:
3357 strbuf_release(&ref_name);
3358 rollback_lock_file(&lock);
3359 free_commit_list(to_merge);
3360 return ret;
3363 static int is_final_fixup(struct todo_list *todo_list)
3365 int i = todo_list->current;
3367 if (!is_fixup(todo_list->items[i].command))
3368 return 0;
3370 while (++i < todo_list->nr)
3371 if (is_fixup(todo_list->items[i].command))
3372 return 0;
3373 else if (!is_noop(todo_list->items[i].command))
3374 break;
3375 return 1;
3378 static enum todo_command peek_command(struct todo_list *todo_list, int offset)
3380 int i;
3382 for (i = todo_list->current + offset; i < todo_list->nr; i++)
3383 if (!is_noop(todo_list->items[i].command))
3384 return todo_list->items[i].command;
3386 return -1;
3389 static int apply_autostash(struct replay_opts *opts)
3391 struct strbuf stash_sha1 = STRBUF_INIT;
3392 struct child_process child = CHILD_PROCESS_INIT;
3393 int ret = 0;
3395 if (!read_oneliner(&stash_sha1, rebase_path_autostash(), 1)) {
3396 strbuf_release(&stash_sha1);
3397 return 0;
3399 strbuf_trim(&stash_sha1);
3401 child.git_cmd = 1;
3402 child.no_stdout = 1;
3403 child.no_stderr = 1;
3404 argv_array_push(&child.args, "stash");
3405 argv_array_push(&child.args, "apply");
3406 argv_array_push(&child.args, stash_sha1.buf);
3407 if (!run_command(&child))
3408 fprintf(stderr, _("Applied autostash.\n"));
3409 else {
3410 struct child_process store = CHILD_PROCESS_INIT;
3412 store.git_cmd = 1;
3413 argv_array_push(&store.args, "stash");
3414 argv_array_push(&store.args, "store");
3415 argv_array_push(&store.args, "-m");
3416 argv_array_push(&store.args, "autostash");
3417 argv_array_push(&store.args, "-q");
3418 argv_array_push(&store.args, stash_sha1.buf);
3419 if (run_command(&store))
3420 ret = error(_("cannot store %s"), stash_sha1.buf);
3421 else
3422 fprintf(stderr,
3423 _("Applying autostash resulted in conflicts.\n"
3424 "Your changes are safe in the stash.\n"
3425 "You can run \"git stash pop\" or"
3426 " \"git stash drop\" at any time.\n"));
3429 strbuf_release(&stash_sha1);
3430 return ret;
3433 static const char *reflog_message(struct replay_opts *opts,
3434 const char *sub_action, const char *fmt, ...)
3436 va_list ap;
3437 static struct strbuf buf = STRBUF_INIT;
3439 va_start(ap, fmt);
3440 strbuf_reset(&buf);
3441 strbuf_addstr(&buf, action_name(opts));
3442 if (sub_action)
3443 strbuf_addf(&buf, " (%s)", sub_action);
3444 if (fmt) {
3445 strbuf_addstr(&buf, ": ");
3446 strbuf_vaddf(&buf, fmt, ap);
3448 va_end(ap);
3450 return buf.buf;
3453 static int run_git_checkout(struct replay_opts *opts, const char *commit,
3454 const char *action)
3456 struct child_process cmd = CHILD_PROCESS_INIT;
3458 cmd.git_cmd = 1;
3460 argv_array_push(&cmd.args, "checkout");
3461 argv_array_push(&cmd.args, commit);
3462 argv_array_pushf(&cmd.env_array, GIT_REFLOG_ACTION "=%s", action);
3464 if (opts->verbose)
3465 return run_command(&cmd);
3466 else
3467 return run_command_silent_on_success(&cmd);
3470 int prepare_branch_to_be_rebased(struct replay_opts *opts, const char *commit)
3472 const char *action;
3474 if (commit && *commit) {
3475 action = reflog_message(opts, "start", "checkout %s", commit);
3476 if (run_git_checkout(opts, commit, action))
3477 return error(_("could not checkout %s"), commit);
3480 return 0;
3483 static int checkout_onto(struct replay_opts *opts,
3484 const char *onto_name, const char *onto,
3485 const char *orig_head)
3487 struct object_id oid;
3488 const char *action = reflog_message(opts, "start", "checkout %s", onto_name);
3490 if (get_oid(orig_head, &oid))
3491 return error(_("%s: not a valid OID"), orig_head);
3493 if (run_git_checkout(opts, onto, action)) {
3494 apply_autostash(opts);
3495 sequencer_remove_state(opts);
3496 return error(_("could not detach HEAD"));
3499 return update_ref(NULL, "ORIG_HEAD", &oid, NULL, 0, UPDATE_REFS_MSG_ON_ERR);
3502 static int stopped_at_head(struct repository *r)
3504 struct object_id head;
3505 struct commit *commit;
3506 struct commit_message message;
3508 if (get_oid("HEAD", &head) ||
3509 !(commit = lookup_commit(r, &head)) ||
3510 parse_commit(commit) || get_message(commit, &message))
3511 fprintf(stderr, _("Stopped at HEAD\n"));
3512 else {
3513 fprintf(stderr, _("Stopped at %s\n"), message.label);
3514 free_message(commit, &message);
3516 return 0;
3520 static const char rescheduled_advice[] =
3521 N_("Could not execute the todo command\n"
3522 "\n"
3523 " %.*s"
3524 "\n"
3525 "It has been rescheduled; To edit the command before continuing, please\n"
3526 "edit the todo list first:\n"
3527 "\n"
3528 " git rebase --edit-todo\n"
3529 " git rebase --continue\n");
3531 static int pick_commits(struct repository *r,
3532 struct todo_list *todo_list,
3533 struct replay_opts *opts)
3535 int res = 0, reschedule = 0;
3537 setenv(GIT_REFLOG_ACTION, action_name(opts), 0);
3538 if (opts->allow_ff)
3539 assert(!(opts->signoff || opts->no_commit ||
3540 opts->record_origin || opts->edit));
3541 if (read_and_refresh_cache(r, opts))
3542 return -1;
3544 while (todo_list->current < todo_list->nr) {
3545 struct todo_item *item = todo_list->items + todo_list->current;
3546 if (save_todo(todo_list, opts))
3547 return -1;
3548 if (is_rebase_i(opts)) {
3549 if (item->command != TODO_COMMENT) {
3550 FILE *f = fopen(rebase_path_msgnum(), "w");
3552 todo_list->done_nr++;
3554 if (f) {
3555 fprintf(f, "%d\n", todo_list->done_nr);
3556 fclose(f);
3558 fprintf(stderr, "Rebasing (%d/%d)%s",
3559 todo_list->done_nr,
3560 todo_list->total_nr,
3561 opts->verbose ? "\n" : "\r");
3563 unlink(rebase_path_message());
3564 unlink(rebase_path_author_script());
3565 unlink(rebase_path_stopped_sha());
3566 unlink(rebase_path_amend());
3567 unlink(git_path_merge_head(the_repository));
3568 delete_ref(NULL, "REBASE_HEAD", NULL, REF_NO_DEREF);
3570 if (item->command == TODO_BREAK)
3571 return stopped_at_head(r);
3573 if (item->command <= TODO_SQUASH) {
3574 if (is_rebase_i(opts))
3575 setenv("GIT_REFLOG_ACTION", reflog_message(opts,
3576 command_to_string(item->command), NULL),
3578 res = do_pick_commit(r, item->command, item->commit,
3579 opts, is_final_fixup(todo_list));
3580 if (is_rebase_i(opts) && res < 0) {
3581 /* Reschedule */
3582 advise(_(rescheduled_advice),
3583 get_item_line_length(todo_list,
3584 todo_list->current),
3585 get_item_line(todo_list,
3586 todo_list->current));
3587 todo_list->current--;
3588 if (save_todo(todo_list, opts))
3589 return -1;
3591 if (item->command == TODO_EDIT) {
3592 struct commit *commit = item->commit;
3593 if (!res)
3594 fprintf(stderr,
3595 _("Stopped at %s... %.*s\n"),
3596 short_commit_name(commit),
3597 item->arg_len, item->arg);
3598 return error_with_patch(r, commit,
3599 item->arg, item->arg_len, opts, res,
3600 !res);
3602 if (is_rebase_i(opts) && !res)
3603 record_in_rewritten(&item->commit->object.oid,
3604 peek_command(todo_list, 1));
3605 if (res && is_fixup(item->command)) {
3606 if (res == 1)
3607 intend_to_amend();
3608 return error_failed_squash(r, item->commit, opts,
3609 item->arg_len, item->arg);
3610 } else if (res && is_rebase_i(opts) && item->commit) {
3611 int to_amend = 0;
3612 struct object_id oid;
3615 * If we are rewording and have either
3616 * fast-forwarded already, or are about to
3617 * create a new root commit, we want to amend,
3618 * otherwise we do not.
3620 if (item->command == TODO_REWORD &&
3621 !get_oid("HEAD", &oid) &&
3622 (oideq(&item->commit->object.oid, &oid) ||
3623 (opts->have_squash_onto &&
3624 oideq(&opts->squash_onto, &oid))))
3625 to_amend = 1;
3627 return res | error_with_patch(r, item->commit,
3628 item->arg, item->arg_len, opts,
3629 res, to_amend);
3631 } else if (item->command == TODO_EXEC) {
3632 char *end_of_arg = (char *)(item->arg + item->arg_len);
3633 int saved = *end_of_arg;
3634 struct stat st;
3636 *end_of_arg = '\0';
3637 res = do_exec(r, item->arg);
3638 *end_of_arg = saved;
3640 /* Reread the todo file if it has changed. */
3641 if (res) {
3642 if (opts->reschedule_failed_exec)
3643 reschedule = 1;
3644 } else if (stat(get_todo_path(opts), &st))
3645 res = error_errno(_("could not stat '%s'"),
3646 get_todo_path(opts));
3647 else if (match_stat_data(&todo_list->stat, &st)) {
3648 todo_list_release(todo_list);
3649 if (read_populate_todo(r, todo_list, opts))
3650 res = -1; /* message was printed */
3651 /* `current` will be incremented below */
3652 todo_list->current = -1;
3654 } else if (item->command == TODO_LABEL) {
3655 if ((res = do_label(r, item->arg, item->arg_len)))
3656 reschedule = 1;
3657 } else if (item->command == TODO_RESET) {
3658 if ((res = do_reset(r, item->arg, item->arg_len, opts)))
3659 reschedule = 1;
3660 } else if (item->command == TODO_MERGE) {
3661 if ((res = do_merge(r, item->commit,
3662 item->arg, item->arg_len,
3663 item->flags, opts)) < 0)
3664 reschedule = 1;
3665 else if (item->commit)
3666 record_in_rewritten(&item->commit->object.oid,
3667 peek_command(todo_list, 1));
3668 if (res > 0)
3669 /* failed with merge conflicts */
3670 return error_with_patch(r, item->commit,
3671 item->arg,
3672 item->arg_len, opts,
3673 res, 0);
3674 } else if (!is_noop(item->command))
3675 return error(_("unknown command %d"), item->command);
3677 if (reschedule) {
3678 advise(_(rescheduled_advice),
3679 get_item_line_length(todo_list,
3680 todo_list->current),
3681 get_item_line(todo_list, todo_list->current));
3682 todo_list->current--;
3683 if (save_todo(todo_list, opts))
3684 return -1;
3685 if (item->commit)
3686 return error_with_patch(r,
3687 item->commit,
3688 item->arg,
3689 item->arg_len, opts,
3690 res, 0);
3693 todo_list->current++;
3694 if (res)
3695 return res;
3698 if (is_rebase_i(opts)) {
3699 struct strbuf head_ref = STRBUF_INIT, buf = STRBUF_INIT;
3700 struct stat st;
3702 /* Stopped in the middle, as planned? */
3703 if (todo_list->current < todo_list->nr)
3704 return 0;
3706 if (read_oneliner(&head_ref, rebase_path_head_name(), 0) &&
3707 starts_with(head_ref.buf, "refs/")) {
3708 const char *msg;
3709 struct object_id head, orig;
3710 int res;
3712 if (get_oid("HEAD", &head)) {
3713 res = error(_("cannot read HEAD"));
3714 cleanup_head_ref:
3715 strbuf_release(&head_ref);
3716 strbuf_release(&buf);
3717 return res;
3719 if (!read_oneliner(&buf, rebase_path_orig_head(), 0) ||
3720 get_oid_hex(buf.buf, &orig)) {
3721 res = error(_("could not read orig-head"));
3722 goto cleanup_head_ref;
3724 strbuf_reset(&buf);
3725 if (!read_oneliner(&buf, rebase_path_onto(), 0)) {
3726 res = error(_("could not read 'onto'"));
3727 goto cleanup_head_ref;
3729 msg = reflog_message(opts, "finish", "%s onto %s",
3730 head_ref.buf, buf.buf);
3731 if (update_ref(msg, head_ref.buf, &head, &orig,
3732 REF_NO_DEREF, UPDATE_REFS_MSG_ON_ERR)) {
3733 res = error(_("could not update %s"),
3734 head_ref.buf);
3735 goto cleanup_head_ref;
3737 msg = reflog_message(opts, "finish", "returning to %s",
3738 head_ref.buf);
3739 if (create_symref("HEAD", head_ref.buf, msg)) {
3740 res = error(_("could not update HEAD to %s"),
3741 head_ref.buf);
3742 goto cleanup_head_ref;
3744 strbuf_reset(&buf);
3747 if (opts->verbose) {
3748 struct rev_info log_tree_opt;
3749 struct object_id orig, head;
3751 memset(&log_tree_opt, 0, sizeof(log_tree_opt));
3752 repo_init_revisions(r, &log_tree_opt, NULL);
3753 log_tree_opt.diff = 1;
3754 log_tree_opt.diffopt.output_format =
3755 DIFF_FORMAT_DIFFSTAT;
3756 log_tree_opt.disable_stdin = 1;
3758 if (read_oneliner(&buf, rebase_path_orig_head(), 0) &&
3759 !get_oid(buf.buf, &orig) &&
3760 !get_oid("HEAD", &head)) {
3761 diff_tree_oid(&orig, &head, "",
3762 &log_tree_opt.diffopt);
3763 log_tree_diff_flush(&log_tree_opt);
3766 flush_rewritten_pending();
3767 if (!stat(rebase_path_rewritten_list(), &st) &&
3768 st.st_size > 0) {
3769 struct child_process child = CHILD_PROCESS_INIT;
3770 const char *post_rewrite_hook =
3771 find_hook("post-rewrite");
3773 child.in = open(rebase_path_rewritten_list(), O_RDONLY);
3774 child.git_cmd = 1;
3775 argv_array_push(&child.args, "notes");
3776 argv_array_push(&child.args, "copy");
3777 argv_array_push(&child.args, "--for-rewrite=rebase");
3778 /* we don't care if this copying failed */
3779 run_command(&child);
3781 if (post_rewrite_hook) {
3782 struct child_process hook = CHILD_PROCESS_INIT;
3784 hook.in = open(rebase_path_rewritten_list(),
3785 O_RDONLY);
3786 hook.stdout_to_stderr = 1;
3787 argv_array_push(&hook.args, post_rewrite_hook);
3788 argv_array_push(&hook.args, "rebase");
3789 /* we don't care if this hook failed */
3790 run_command(&hook);
3793 apply_autostash(opts);
3795 fprintf(stderr, "Successfully rebased and updated %s.\n",
3796 head_ref.buf);
3798 strbuf_release(&buf);
3799 strbuf_release(&head_ref);
3803 * Sequence of picks finished successfully; cleanup by
3804 * removing the .git/sequencer directory
3806 return sequencer_remove_state(opts);
3809 static int continue_single_pick(struct repository *r)
3811 const char *argv[] = { "commit", NULL };
3813 if (!file_exists(git_path_cherry_pick_head(r)) &&
3814 !file_exists(git_path_revert_head(r)))
3815 return error(_("no cherry-pick or revert in progress"));
3816 return run_command_v_opt(argv, RUN_GIT_CMD);
3819 static int commit_staged_changes(struct repository *r,
3820 struct replay_opts *opts,
3821 struct todo_list *todo_list)
3823 unsigned int flags = ALLOW_EMPTY | EDIT_MSG;
3824 unsigned int final_fixup = 0, is_clean;
3826 if (has_unstaged_changes(r, 1))
3827 return error(_("cannot rebase: You have unstaged changes."));
3829 is_clean = !has_uncommitted_changes(r, 0);
3831 if (file_exists(rebase_path_amend())) {
3832 struct strbuf rev = STRBUF_INIT;
3833 struct object_id head, to_amend;
3835 if (get_oid("HEAD", &head))
3836 return error(_("cannot amend non-existing commit"));
3837 if (!read_oneliner(&rev, rebase_path_amend(), 0))
3838 return error(_("invalid file: '%s'"), rebase_path_amend());
3839 if (get_oid_hex(rev.buf, &to_amend))
3840 return error(_("invalid contents: '%s'"),
3841 rebase_path_amend());
3842 if (!is_clean && !oideq(&head, &to_amend))
3843 return error(_("\nYou have uncommitted changes in your "
3844 "working tree. Please, commit them\n"
3845 "first and then run 'git rebase "
3846 "--continue' again."));
3848 * When skipping a failed fixup/squash, we need to edit the
3849 * commit message, the current fixup list and count, and if it
3850 * was the last fixup/squash in the chain, we need to clean up
3851 * the commit message and if there was a squash, let the user
3852 * edit it.
3854 if (!is_clean || !opts->current_fixup_count)
3855 ; /* this is not the final fixup */
3856 else if (!oideq(&head, &to_amend) ||
3857 !file_exists(rebase_path_stopped_sha())) {
3858 /* was a final fixup or squash done manually? */
3859 if (!is_fixup(peek_command(todo_list, 0))) {
3860 unlink(rebase_path_fixup_msg());
3861 unlink(rebase_path_squash_msg());
3862 unlink(rebase_path_current_fixups());
3863 strbuf_reset(&opts->current_fixups);
3864 opts->current_fixup_count = 0;
3866 } else {
3867 /* we are in a fixup/squash chain */
3868 const char *p = opts->current_fixups.buf;
3869 int len = opts->current_fixups.len;
3871 opts->current_fixup_count--;
3872 if (!len)
3873 BUG("Incorrect current_fixups:\n%s", p);
3874 while (len && p[len - 1] != '\n')
3875 len--;
3876 strbuf_setlen(&opts->current_fixups, len);
3877 if (write_message(p, len, rebase_path_current_fixups(),
3878 0) < 0)
3879 return error(_("could not write file: '%s'"),
3880 rebase_path_current_fixups());
3883 * If a fixup/squash in a fixup/squash chain failed, the
3884 * commit message is already correct, no need to commit
3885 * it again.
3887 * Only if it is the final command in the fixup/squash
3888 * chain, and only if the chain is longer than a single
3889 * fixup/squash command (which was just skipped), do we
3890 * actually need to re-commit with a cleaned up commit
3891 * message.
3893 if (opts->current_fixup_count > 0 &&
3894 !is_fixup(peek_command(todo_list, 0))) {
3895 final_fixup = 1;
3897 * If there was not a single "squash" in the
3898 * chain, we only need to clean up the commit
3899 * message, no need to bother the user with
3900 * opening the commit message in the editor.
3902 if (!starts_with(p, "squash ") &&
3903 !strstr(p, "\nsquash "))
3904 flags = (flags & ~EDIT_MSG) | CLEANUP_MSG;
3905 } else if (is_fixup(peek_command(todo_list, 0))) {
3907 * We need to update the squash message to skip
3908 * the latest commit message.
3910 struct commit *commit;
3911 const char *path = rebase_path_squash_msg();
3913 if (parse_head(r, &commit) ||
3914 !(p = get_commit_buffer(commit, NULL)) ||
3915 write_message(p, strlen(p), path, 0)) {
3916 unuse_commit_buffer(commit, p);
3917 return error(_("could not write file: "
3918 "'%s'"), path);
3920 unuse_commit_buffer(commit, p);
3924 strbuf_release(&rev);
3925 flags |= AMEND_MSG;
3928 if (is_clean) {
3929 const char *cherry_pick_head = git_path_cherry_pick_head(r);
3931 if (file_exists(cherry_pick_head) && unlink(cherry_pick_head))
3932 return error(_("could not remove CHERRY_PICK_HEAD"));
3933 if (!final_fixup)
3934 return 0;
3937 if (run_git_commit(r, final_fixup ? NULL : rebase_path_message(),
3938 opts, flags))
3939 return error(_("could not commit staged changes."));
3940 unlink(rebase_path_amend());
3941 unlink(git_path_merge_head(the_repository));
3942 if (final_fixup) {
3943 unlink(rebase_path_fixup_msg());
3944 unlink(rebase_path_squash_msg());
3946 if (opts->current_fixup_count > 0) {
3948 * Whether final fixup or not, we just cleaned up the commit
3949 * message...
3951 unlink(rebase_path_current_fixups());
3952 strbuf_reset(&opts->current_fixups);
3953 opts->current_fixup_count = 0;
3955 return 0;
3958 int sequencer_continue(struct repository *r, struct replay_opts *opts)
3960 struct todo_list todo_list = TODO_LIST_INIT;
3961 int res;
3963 if (read_and_refresh_cache(r, opts))
3964 return -1;
3966 if (read_populate_opts(opts))
3967 return -1;
3968 if (is_rebase_i(opts)) {
3969 if ((res = read_populate_todo(r, &todo_list, opts)))
3970 goto release_todo_list;
3971 if (commit_staged_changes(r, opts, &todo_list))
3972 return -1;
3973 } else if (!file_exists(get_todo_path(opts)))
3974 return continue_single_pick(r);
3975 else if ((res = read_populate_todo(r, &todo_list, opts)))
3976 goto release_todo_list;
3978 if (!is_rebase_i(opts)) {
3979 /* Verify that the conflict has been resolved */
3980 if (file_exists(git_path_cherry_pick_head(r)) ||
3981 file_exists(git_path_revert_head(r))) {
3982 res = continue_single_pick(r);
3983 if (res)
3984 goto release_todo_list;
3986 if (index_differs_from(r, "HEAD", NULL, 0)) {
3987 res = error_dirty_index(r->index, opts);
3988 goto release_todo_list;
3990 todo_list.current++;
3991 } else if (file_exists(rebase_path_stopped_sha())) {
3992 struct strbuf buf = STRBUF_INIT;
3993 struct object_id oid;
3995 if (read_oneliner(&buf, rebase_path_stopped_sha(), 1) &&
3996 !get_oid_committish(buf.buf, &oid))
3997 record_in_rewritten(&oid, peek_command(&todo_list, 0));
3998 strbuf_release(&buf);
4001 res = pick_commits(r, &todo_list, opts);
4002 release_todo_list:
4003 todo_list_release(&todo_list);
4004 return res;
4007 static int single_pick(struct repository *r,
4008 struct commit *cmit,
4009 struct replay_opts *opts)
4011 setenv(GIT_REFLOG_ACTION, action_name(opts), 0);
4012 return do_pick_commit(r, opts->action == REPLAY_PICK ?
4013 TODO_PICK : TODO_REVERT, cmit, opts, 0);
4016 int sequencer_pick_revisions(struct repository *r,
4017 struct replay_opts *opts)
4019 struct todo_list todo_list = TODO_LIST_INIT;
4020 struct object_id oid;
4021 int i, res;
4023 assert(opts->revs);
4024 if (read_and_refresh_cache(r, opts))
4025 return -1;
4027 for (i = 0; i < opts->revs->pending.nr; i++) {
4028 struct object_id oid;
4029 const char *name = opts->revs->pending.objects[i].name;
4031 /* This happens when using --stdin. */
4032 if (!strlen(name))
4033 continue;
4035 if (!get_oid(name, &oid)) {
4036 if (!lookup_commit_reference_gently(r, &oid, 1)) {
4037 enum object_type type = oid_object_info(r,
4038 &oid,
4039 NULL);
4040 return error(_("%s: can't cherry-pick a %s"),
4041 name, type_name(type));
4043 } else
4044 return error(_("%s: bad revision"), name);
4048 * If we were called as "git cherry-pick <commit>", just
4049 * cherry-pick/revert it, set CHERRY_PICK_HEAD /
4050 * REVERT_HEAD, and don't touch the sequencer state.
4051 * This means it is possible to cherry-pick in the middle
4052 * of a cherry-pick sequence.
4054 if (opts->revs->cmdline.nr == 1 &&
4055 opts->revs->cmdline.rev->whence == REV_CMD_REV &&
4056 opts->revs->no_walk &&
4057 !opts->revs->cmdline.rev->flags) {
4058 struct commit *cmit;
4059 if (prepare_revision_walk(opts->revs))
4060 return error(_("revision walk setup failed"));
4061 cmit = get_revision(opts->revs);
4062 if (!cmit)
4063 return error(_("empty commit set passed"));
4064 if (get_revision(opts->revs))
4065 BUG("unexpected extra commit from walk");
4066 return single_pick(r, cmit, opts);
4070 * Start a new cherry-pick/ revert sequence; but
4071 * first, make sure that an existing one isn't in
4072 * progress
4075 if (walk_revs_populate_todo(&todo_list, opts) ||
4076 create_seq_dir() < 0)
4077 return -1;
4078 if (get_oid("HEAD", &oid) && (opts->action == REPLAY_REVERT))
4079 return error(_("can't revert as initial commit"));
4080 if (save_head(oid_to_hex(&oid)))
4081 return -1;
4082 if (save_opts(opts))
4083 return -1;
4084 update_abort_safety_file();
4085 res = pick_commits(r, &todo_list, opts);
4086 todo_list_release(&todo_list);
4087 return res;
4090 void append_signoff(struct strbuf *msgbuf, size_t ignore_footer, unsigned flag)
4092 unsigned no_dup_sob = flag & APPEND_SIGNOFF_DEDUP;
4093 struct strbuf sob = STRBUF_INIT;
4094 int has_footer;
4096 strbuf_addstr(&sob, sign_off_header);
4097 strbuf_addstr(&sob, fmt_name(getenv("GIT_COMMITTER_NAME"),
4098 getenv("GIT_COMMITTER_EMAIL")));
4099 strbuf_addch(&sob, '\n');
4101 if (!ignore_footer)
4102 strbuf_complete_line(msgbuf);
4105 * If the whole message buffer is equal to the sob, pretend that we
4106 * found a conforming footer with a matching sob
4108 if (msgbuf->len - ignore_footer == sob.len &&
4109 !strncmp(msgbuf->buf, sob.buf, sob.len))
4110 has_footer = 3;
4111 else
4112 has_footer = has_conforming_footer(msgbuf, &sob, ignore_footer);
4114 if (!has_footer) {
4115 const char *append_newlines = NULL;
4116 size_t len = msgbuf->len - ignore_footer;
4118 if (!len) {
4120 * The buffer is completely empty. Leave foom for
4121 * the title and body to be filled in by the user.
4123 append_newlines = "\n\n";
4124 } else if (len == 1) {
4126 * Buffer contains a single newline. Add another
4127 * so that we leave room for the title and body.
4129 append_newlines = "\n";
4130 } else if (msgbuf->buf[len - 2] != '\n') {
4132 * Buffer ends with a single newline. Add another
4133 * so that there is an empty line between the message
4134 * body and the sob.
4136 append_newlines = "\n";
4137 } /* else, the buffer already ends with two newlines. */
4139 if (append_newlines)
4140 strbuf_splice(msgbuf, msgbuf->len - ignore_footer, 0,
4141 append_newlines, strlen(append_newlines));
4144 if (has_footer != 3 && (!no_dup_sob || has_footer != 2))
4145 strbuf_splice(msgbuf, msgbuf->len - ignore_footer, 0,
4146 sob.buf, sob.len);
4148 strbuf_release(&sob);
4151 struct labels_entry {
4152 struct hashmap_entry entry;
4153 char label[FLEX_ARRAY];
4156 static int labels_cmp(const void *fndata, const struct labels_entry *a,
4157 const struct labels_entry *b, const void *key)
4159 return key ? strcmp(a->label, key) : strcmp(a->label, b->label);
4162 struct string_entry {
4163 struct oidmap_entry entry;
4164 char string[FLEX_ARRAY];
4167 struct label_state {
4168 struct oidmap commit2label;
4169 struct hashmap labels;
4170 struct strbuf buf;
4173 static const char *label_oid(struct object_id *oid, const char *label,
4174 struct label_state *state)
4176 struct labels_entry *labels_entry;
4177 struct string_entry *string_entry;
4178 struct object_id dummy;
4179 size_t len;
4180 int i;
4182 string_entry = oidmap_get(&state->commit2label, oid);
4183 if (string_entry)
4184 return string_entry->string;
4187 * For "uninteresting" commits, i.e. commits that are not to be
4188 * rebased, and which can therefore not be labeled, we use a unique
4189 * abbreviation of the commit name. This is slightly more complicated
4190 * than calling find_unique_abbrev() because we also need to make
4191 * sure that the abbreviation does not conflict with any other
4192 * label.
4194 * We disallow "interesting" commits to be labeled by a string that
4195 * is a valid full-length hash, to ensure that we always can find an
4196 * abbreviation for any uninteresting commit's names that does not
4197 * clash with any other label.
4199 if (!label) {
4200 char *p;
4202 strbuf_reset(&state->buf);
4203 strbuf_grow(&state->buf, GIT_SHA1_HEXSZ);
4204 label = p = state->buf.buf;
4206 find_unique_abbrev_r(p, oid, default_abbrev);
4209 * We may need to extend the abbreviated hash so that there is
4210 * no conflicting label.
4212 if (hashmap_get_from_hash(&state->labels, strihash(p), p)) {
4213 size_t i = strlen(p) + 1;
4215 oid_to_hex_r(p, oid);
4216 for (; i < GIT_SHA1_HEXSZ; i++) {
4217 char save = p[i];
4218 p[i] = '\0';
4219 if (!hashmap_get_from_hash(&state->labels,
4220 strihash(p), p))
4221 break;
4222 p[i] = save;
4225 } else if (((len = strlen(label)) == the_hash_algo->hexsz &&
4226 !get_oid_hex(label, &dummy)) ||
4227 (len == 1 && *label == '#') ||
4228 hashmap_get_from_hash(&state->labels,
4229 strihash(label), label)) {
4231 * If the label already exists, or if the label is a valid full
4232 * OID, or the label is a '#' (which we use as a separator
4233 * between merge heads and oneline), we append a dash and a
4234 * number to make it unique.
4236 struct strbuf *buf = &state->buf;
4238 strbuf_reset(buf);
4239 strbuf_add(buf, label, len);
4241 for (i = 2; ; i++) {
4242 strbuf_setlen(buf, len);
4243 strbuf_addf(buf, "-%d", i);
4244 if (!hashmap_get_from_hash(&state->labels,
4245 strihash(buf->buf),
4246 buf->buf))
4247 break;
4250 label = buf->buf;
4253 FLEX_ALLOC_STR(labels_entry, label, label);
4254 hashmap_entry_init(labels_entry, strihash(label));
4255 hashmap_add(&state->labels, labels_entry);
4257 FLEX_ALLOC_STR(string_entry, string, label);
4258 oidcpy(&string_entry->entry.oid, oid);
4259 oidmap_put(&state->commit2label, string_entry);
4261 return string_entry->string;
4264 static int make_script_with_merges(struct pretty_print_context *pp,
4265 struct rev_info *revs, FILE *out,
4266 unsigned flags)
4268 int keep_empty = flags & TODO_LIST_KEEP_EMPTY;
4269 int rebase_cousins = flags & TODO_LIST_REBASE_COUSINS;
4270 struct strbuf buf = STRBUF_INIT, oneline = STRBUF_INIT;
4271 struct strbuf label = STRBUF_INIT;
4272 struct commit_list *commits = NULL, **tail = &commits, *iter;
4273 struct commit_list *tips = NULL, **tips_tail = &tips;
4274 struct commit *commit;
4275 struct oidmap commit2todo = OIDMAP_INIT;
4276 struct string_entry *entry;
4277 struct oidset interesting = OIDSET_INIT, child_seen = OIDSET_INIT,
4278 shown = OIDSET_INIT;
4279 struct label_state state = { OIDMAP_INIT, { NULL }, STRBUF_INIT };
4281 int abbr = flags & TODO_LIST_ABBREVIATE_CMDS;
4282 const char *cmd_pick = abbr ? "p" : "pick",
4283 *cmd_label = abbr ? "l" : "label",
4284 *cmd_reset = abbr ? "t" : "reset",
4285 *cmd_merge = abbr ? "m" : "merge";
4287 oidmap_init(&commit2todo, 0);
4288 oidmap_init(&state.commit2label, 0);
4289 hashmap_init(&state.labels, (hashmap_cmp_fn) labels_cmp, NULL, 0);
4290 strbuf_init(&state.buf, 32);
4292 if (revs->cmdline.nr && (revs->cmdline.rev[0].flags & BOTTOM)) {
4293 struct object_id *oid = &revs->cmdline.rev[0].item->oid;
4294 FLEX_ALLOC_STR(entry, string, "onto");
4295 oidcpy(&entry->entry.oid, oid);
4296 oidmap_put(&state.commit2label, entry);
4300 * First phase:
4301 * - get onelines for all commits
4302 * - gather all branch tips (i.e. 2nd or later parents of merges)
4303 * - label all branch tips
4305 while ((commit = get_revision(revs))) {
4306 struct commit_list *to_merge;
4307 const char *p1, *p2;
4308 struct object_id *oid;
4309 int is_empty;
4311 tail = &commit_list_insert(commit, tail)->next;
4312 oidset_insert(&interesting, &commit->object.oid);
4314 is_empty = is_original_commit_empty(commit);
4315 if (!is_empty && (commit->object.flags & PATCHSAME))
4316 continue;
4318 strbuf_reset(&oneline);
4319 pretty_print_commit(pp, commit, &oneline);
4321 to_merge = commit->parents ? commit->parents->next : NULL;
4322 if (!to_merge) {
4323 /* non-merge commit: easy case */
4324 strbuf_reset(&buf);
4325 if (!keep_empty && is_empty)
4326 strbuf_addf(&buf, "%c ", comment_line_char);
4327 strbuf_addf(&buf, "%s %s %s", cmd_pick,
4328 oid_to_hex(&commit->object.oid),
4329 oneline.buf);
4331 FLEX_ALLOC_STR(entry, string, buf.buf);
4332 oidcpy(&entry->entry.oid, &commit->object.oid);
4333 oidmap_put(&commit2todo, entry);
4335 continue;
4338 /* Create a label */
4339 strbuf_reset(&label);
4340 if (skip_prefix(oneline.buf, "Merge ", &p1) &&
4341 (p1 = strchr(p1, '\'')) &&
4342 (p2 = strchr(++p1, '\'')))
4343 strbuf_add(&label, p1, p2 - p1);
4344 else if (skip_prefix(oneline.buf, "Merge pull request ",
4345 &p1) &&
4346 (p1 = strstr(p1, " from ")))
4347 strbuf_addstr(&label, p1 + strlen(" from "));
4348 else
4349 strbuf_addbuf(&label, &oneline);
4351 for (p1 = label.buf; *p1; p1++)
4352 if (isspace(*p1))
4353 *(char *)p1 = '-';
4355 strbuf_reset(&buf);
4356 strbuf_addf(&buf, "%s -C %s",
4357 cmd_merge, oid_to_hex(&commit->object.oid));
4359 /* label the tips of merged branches */
4360 for (; to_merge; to_merge = to_merge->next) {
4361 oid = &to_merge->item->object.oid;
4362 strbuf_addch(&buf, ' ');
4364 if (!oidset_contains(&interesting, oid)) {
4365 strbuf_addstr(&buf, label_oid(oid, NULL,
4366 &state));
4367 continue;
4370 tips_tail = &commit_list_insert(to_merge->item,
4371 tips_tail)->next;
4373 strbuf_addstr(&buf, label_oid(oid, label.buf, &state));
4375 strbuf_addf(&buf, " # %s", oneline.buf);
4377 FLEX_ALLOC_STR(entry, string, buf.buf);
4378 oidcpy(&entry->entry.oid, &commit->object.oid);
4379 oidmap_put(&commit2todo, entry);
4383 * Second phase:
4384 * - label branch points
4385 * - add HEAD to the branch tips
4387 for (iter = commits; iter; iter = iter->next) {
4388 struct commit_list *parent = iter->item->parents;
4389 for (; parent; parent = parent->next) {
4390 struct object_id *oid = &parent->item->object.oid;
4391 if (!oidset_contains(&interesting, oid))
4392 continue;
4393 if (oidset_insert(&child_seen, oid))
4394 label_oid(oid, "branch-point", &state);
4397 /* Add HEAD as implict "tip of branch" */
4398 if (!iter->next)
4399 tips_tail = &commit_list_insert(iter->item,
4400 tips_tail)->next;
4404 * Third phase: output the todo list. This is a bit tricky, as we
4405 * want to avoid jumping back and forth between revisions. To
4406 * accomplish that goal, we walk backwards from the branch tips,
4407 * gathering commits not yet shown, reversing the list on the fly,
4408 * then outputting that list (labeling revisions as needed).
4410 fprintf(out, "%s onto\n", cmd_label);
4411 for (iter = tips; iter; iter = iter->next) {
4412 struct commit_list *list = NULL, *iter2;
4414 commit = iter->item;
4415 if (oidset_contains(&shown, &commit->object.oid))
4416 continue;
4417 entry = oidmap_get(&state.commit2label, &commit->object.oid);
4419 if (entry)
4420 fprintf(out, "\n%c Branch %s\n", comment_line_char, entry->string);
4421 else
4422 fprintf(out, "\n");
4424 while (oidset_contains(&interesting, &commit->object.oid) &&
4425 !oidset_contains(&shown, &commit->object.oid)) {
4426 commit_list_insert(commit, &list);
4427 if (!commit->parents) {
4428 commit = NULL;
4429 break;
4431 commit = commit->parents->item;
4434 if (!commit)
4435 fprintf(out, "%s %s\n", cmd_reset,
4436 rebase_cousins ? "onto" : "[new root]");
4437 else {
4438 const char *to = NULL;
4440 entry = oidmap_get(&state.commit2label,
4441 &commit->object.oid);
4442 if (entry)
4443 to = entry->string;
4444 else if (!rebase_cousins)
4445 to = label_oid(&commit->object.oid, NULL,
4446 &state);
4448 if (!to || !strcmp(to, "onto"))
4449 fprintf(out, "%s onto\n", cmd_reset);
4450 else {
4451 strbuf_reset(&oneline);
4452 pretty_print_commit(pp, commit, &oneline);
4453 fprintf(out, "%s %s # %s\n",
4454 cmd_reset, to, oneline.buf);
4458 for (iter2 = list; iter2; iter2 = iter2->next) {
4459 struct object_id *oid = &iter2->item->object.oid;
4460 entry = oidmap_get(&commit2todo, oid);
4461 /* only show if not already upstream */
4462 if (entry)
4463 fprintf(out, "%s\n", entry->string);
4464 entry = oidmap_get(&state.commit2label, oid);
4465 if (entry)
4466 fprintf(out, "%s %s\n",
4467 cmd_label, entry->string);
4468 oidset_insert(&shown, oid);
4471 free_commit_list(list);
4474 free_commit_list(commits);
4475 free_commit_list(tips);
4477 strbuf_release(&label);
4478 strbuf_release(&oneline);
4479 strbuf_release(&buf);
4481 oidmap_free(&commit2todo, 1);
4482 oidmap_free(&state.commit2label, 1);
4483 hashmap_free(&state.labels, 1);
4484 strbuf_release(&state.buf);
4486 return 0;
4489 int sequencer_make_script(struct repository *r, FILE *out,
4490 int argc, const char **argv,
4491 unsigned flags)
4493 char *format = NULL;
4494 struct pretty_print_context pp = {0};
4495 struct strbuf buf = STRBUF_INIT;
4496 struct rev_info revs;
4497 struct commit *commit;
4498 int keep_empty = flags & TODO_LIST_KEEP_EMPTY;
4499 const char *insn = flags & TODO_LIST_ABBREVIATE_CMDS ? "p" : "pick";
4500 int rebase_merges = flags & TODO_LIST_REBASE_MERGES;
4502 repo_init_revisions(r, &revs, NULL);
4503 revs.verbose_header = 1;
4504 if (!rebase_merges)
4505 revs.max_parents = 1;
4506 revs.cherry_mark = 1;
4507 revs.limited = 1;
4508 revs.reverse = 1;
4509 revs.right_only = 1;
4510 revs.sort_order = REV_SORT_IN_GRAPH_ORDER;
4511 revs.topo_order = 1;
4513 revs.pretty_given = 1;
4514 git_config_get_string("rebase.instructionFormat", &format);
4515 if (!format || !*format) {
4516 free(format);
4517 format = xstrdup("%s");
4519 get_commit_format(format, &revs);
4520 free(format);
4521 pp.fmt = revs.commit_format;
4522 pp.output_encoding = get_log_output_encoding();
4524 if (setup_revisions(argc, argv, &revs, NULL) > 1)
4525 return error(_("make_script: unhandled options"));
4527 if (prepare_revision_walk(&revs) < 0)
4528 return error(_("make_script: error preparing revisions"));
4530 if (rebase_merges)
4531 return make_script_with_merges(&pp, &revs, out, flags);
4533 while ((commit = get_revision(&revs))) {
4534 int is_empty = is_original_commit_empty(commit);
4536 if (!is_empty && (commit->object.flags & PATCHSAME))
4537 continue;
4538 strbuf_reset(&buf);
4539 if (!keep_empty && is_empty)
4540 strbuf_addf(&buf, "%c ", comment_line_char);
4541 strbuf_addf(&buf, "%s %s ", insn,
4542 oid_to_hex(&commit->object.oid));
4543 pretty_print_commit(&pp, commit, &buf);
4544 strbuf_addch(&buf, '\n');
4545 fputs(buf.buf, out);
4547 strbuf_release(&buf);
4548 return 0;
4552 * Add commands after pick and (series of) squash/fixup commands
4553 * in the todo list.
4555 int sequencer_add_exec_commands(struct repository *r,
4556 const char *commands)
4558 const char *todo_file = rebase_path_todo();
4559 struct todo_list todo_list = TODO_LIST_INIT;
4560 struct strbuf *buf = &todo_list.buf;
4561 size_t offset = 0, commands_len = strlen(commands);
4562 int i, insert;
4564 if (strbuf_read_file(&todo_list.buf, todo_file, 0) < 0)
4565 return error(_("could not read '%s'."), todo_file);
4567 if (parse_insn_buffer(r, todo_list.buf.buf, &todo_list)) {
4568 todo_list_release(&todo_list);
4569 return error(_("unusable todo list: '%s'"), todo_file);
4573 * Insert <commands> after every pick. Here, fixup/squash chains
4574 * are considered part of the pick, so we insert the commands *after*
4575 * those chains if there are any.
4577 insert = -1;
4578 for (i = 0; i < todo_list.nr; i++) {
4579 enum todo_command command = todo_list.items[i].command;
4581 if (insert >= 0) {
4582 /* skip fixup/squash chains */
4583 if (command == TODO_COMMENT)
4584 continue;
4585 else if (is_fixup(command)) {
4586 insert = i + 1;
4587 continue;
4589 strbuf_insert(buf,
4590 todo_list.items[insert].offset_in_buf +
4591 offset, commands, commands_len);
4592 offset += commands_len;
4593 insert = -1;
4596 if (command == TODO_PICK || command == TODO_MERGE)
4597 insert = i + 1;
4600 /* insert or append final <commands> */
4601 if (insert >= 0 && insert < todo_list.nr)
4602 strbuf_insert(buf, todo_list.items[insert].offset_in_buf +
4603 offset, commands, commands_len);
4604 else if (insert >= 0 || !offset)
4605 strbuf_add(buf, commands, commands_len);
4607 i = write_message(buf->buf, buf->len, todo_file, 0);
4608 todo_list_release(&todo_list);
4609 return i;
4612 int transform_todos(struct repository *r, unsigned flags)
4614 const char *todo_file = rebase_path_todo();
4615 struct todo_list todo_list = TODO_LIST_INIT;
4616 struct strbuf buf = STRBUF_INIT;
4617 struct todo_item *item;
4618 int i;
4620 if (strbuf_read_file(&todo_list.buf, todo_file, 0) < 0)
4621 return error(_("could not read '%s'."), todo_file);
4623 if (parse_insn_buffer(r, todo_list.buf.buf, &todo_list)) {
4624 todo_list_release(&todo_list);
4625 return error(_("unusable todo list: '%s'"), todo_file);
4628 for (item = todo_list.items, i = 0; i < todo_list.nr; i++, item++) {
4629 /* if the item is not a command write it and continue */
4630 if (item->command >= TODO_COMMENT) {
4631 strbuf_addf(&buf, "%.*s\n", item->arg_len, item->arg);
4632 continue;
4635 /* add command to the buffer */
4636 if (flags & TODO_LIST_ABBREVIATE_CMDS)
4637 strbuf_addch(&buf, command_to_char(item->command));
4638 else
4639 strbuf_addstr(&buf, command_to_string(item->command));
4641 /* add commit id */
4642 if (item->commit) {
4643 const char *oid = flags & TODO_LIST_SHORTEN_IDS ?
4644 short_commit_name(item->commit) :
4645 oid_to_hex(&item->commit->object.oid);
4647 if (item->command == TODO_MERGE) {
4648 if (item->flags & TODO_EDIT_MERGE_MSG)
4649 strbuf_addstr(&buf, " -c");
4650 else
4651 strbuf_addstr(&buf, " -C");
4654 strbuf_addf(&buf, " %s", oid);
4657 /* add all the rest */
4658 if (!item->arg_len)
4659 strbuf_addch(&buf, '\n');
4660 else
4661 strbuf_addf(&buf, " %.*s\n", item->arg_len, item->arg);
4664 i = write_message(buf.buf, buf.len, todo_file, 0);
4665 todo_list_release(&todo_list);
4666 return i;
4669 enum missing_commit_check_level get_missing_commit_check_level(void)
4671 const char *value;
4673 if (git_config_get_value("rebase.missingcommitscheck", &value) ||
4674 !strcasecmp("ignore", value))
4675 return MISSING_COMMIT_CHECK_IGNORE;
4676 if (!strcasecmp("warn", value))
4677 return MISSING_COMMIT_CHECK_WARN;
4678 if (!strcasecmp("error", value))
4679 return MISSING_COMMIT_CHECK_ERROR;
4680 warning(_("unrecognized setting %s for option "
4681 "rebase.missingCommitsCheck. Ignoring."), value);
4682 return MISSING_COMMIT_CHECK_IGNORE;
4685 define_commit_slab(commit_seen, unsigned char);
4687 * Check if the user dropped some commits by mistake
4688 * Behaviour determined by rebase.missingCommitsCheck.
4689 * Check if there is an unrecognized command or a
4690 * bad SHA-1 in a command.
4692 int check_todo_list(struct repository *r)
4694 enum missing_commit_check_level check_level = get_missing_commit_check_level();
4695 struct strbuf todo_file = STRBUF_INIT;
4696 struct todo_list todo_list = TODO_LIST_INIT;
4697 struct strbuf missing = STRBUF_INIT;
4698 int advise_to_edit_todo = 0, res = 0, i;
4699 struct commit_seen commit_seen;
4701 init_commit_seen(&commit_seen);
4703 strbuf_addstr(&todo_file, rebase_path_todo());
4704 if (strbuf_read_file_or_whine(&todo_list.buf, todo_file.buf) < 0) {
4705 res = -1;
4706 goto leave_check;
4708 advise_to_edit_todo = res =
4709 parse_insn_buffer(r, todo_list.buf.buf, &todo_list);
4711 if (res || check_level == MISSING_COMMIT_CHECK_IGNORE)
4712 goto leave_check;
4714 /* Mark the commits in git-rebase-todo as seen */
4715 for (i = 0; i < todo_list.nr; i++) {
4716 struct commit *commit = todo_list.items[i].commit;
4717 if (commit)
4718 *commit_seen_at(&commit_seen, commit) = 1;
4721 todo_list_release(&todo_list);
4722 strbuf_addstr(&todo_file, ".backup");
4723 if (strbuf_read_file_or_whine(&todo_list.buf, todo_file.buf) < 0) {
4724 res = -1;
4725 goto leave_check;
4727 strbuf_release(&todo_file);
4728 res = !!parse_insn_buffer(r, todo_list.buf.buf, &todo_list);
4730 /* Find commits in git-rebase-todo.backup yet unseen */
4731 for (i = todo_list.nr - 1; i >= 0; i--) {
4732 struct todo_item *item = todo_list.items + i;
4733 struct commit *commit = item->commit;
4734 if (commit && !*commit_seen_at(&commit_seen, commit)) {
4735 strbuf_addf(&missing, " - %s %.*s\n",
4736 short_commit_name(commit),
4737 item->arg_len, item->arg);
4738 *commit_seen_at(&commit_seen, commit) = 1;
4742 /* Warn about missing commits */
4743 if (!missing.len)
4744 goto leave_check;
4746 if (check_level == MISSING_COMMIT_CHECK_ERROR)
4747 advise_to_edit_todo = res = 1;
4749 fprintf(stderr,
4750 _("Warning: some commits may have been dropped accidentally.\n"
4751 "Dropped commits (newer to older):\n"));
4753 /* Make the list user-friendly and display */
4754 fputs(missing.buf, stderr);
4755 strbuf_release(&missing);
4757 fprintf(stderr, _("To avoid this message, use \"drop\" to "
4758 "explicitly remove a commit.\n\n"
4759 "Use 'git config rebase.missingCommitsCheck' to change "
4760 "the level of warnings.\n"
4761 "The possible behaviours are: ignore, warn, error.\n\n"));
4763 leave_check:
4764 clear_commit_seen(&commit_seen);
4765 strbuf_release(&todo_file);
4766 todo_list_release(&todo_list);
4768 if (advise_to_edit_todo)
4769 fprintf(stderr,
4770 _("You can fix this with 'git rebase --edit-todo' "
4771 "and then run 'git rebase --continue'.\n"
4772 "Or you can abort the rebase with 'git rebase"
4773 " --abort'.\n"));
4775 return res;
4778 static int rewrite_file(const char *path, const char *buf, size_t len)
4780 int rc = 0;
4781 int fd = open(path, O_WRONLY | O_TRUNC);
4782 if (fd < 0)
4783 return error_errno(_("could not open '%s' for writing"), path);
4784 if (write_in_full(fd, buf, len) < 0)
4785 rc = error_errno(_("could not write to '%s'"), path);
4786 if (close(fd) && !rc)
4787 rc = error_errno(_("could not close '%s'"), path);
4788 return rc;
4791 /* skip picking commits whose parents are unchanged */
4792 static int skip_unnecessary_picks(struct repository *r, struct object_id *output_oid)
4794 const char *todo_file = rebase_path_todo();
4795 struct strbuf buf = STRBUF_INIT;
4796 struct todo_list todo_list = TODO_LIST_INIT;
4797 struct object_id *parent_oid;
4798 int fd, i;
4800 if (!read_oneliner(&buf, rebase_path_onto(), 0))
4801 return error(_("could not read 'onto'"));
4802 if (get_oid(buf.buf, output_oid)) {
4803 strbuf_release(&buf);
4804 return error(_("need a HEAD to fixup"));
4806 strbuf_release(&buf);
4808 if (strbuf_read_file_or_whine(&todo_list.buf, todo_file) < 0)
4809 return -1;
4810 if (parse_insn_buffer(r, todo_list.buf.buf, &todo_list) < 0) {
4811 todo_list_release(&todo_list);
4812 return -1;
4815 for (i = 0; i < todo_list.nr; i++) {
4816 struct todo_item *item = todo_list.items + i;
4818 if (item->command >= TODO_NOOP)
4819 continue;
4820 if (item->command != TODO_PICK)
4821 break;
4822 if (parse_commit(item->commit)) {
4823 todo_list_release(&todo_list);
4824 return error(_("could not parse commit '%s'"),
4825 oid_to_hex(&item->commit->object.oid));
4827 if (!item->commit->parents)
4828 break; /* root commit */
4829 if (item->commit->parents->next)
4830 break; /* merge commit */
4831 parent_oid = &item->commit->parents->item->object.oid;
4832 if (!oideq(parent_oid, output_oid))
4833 break;
4834 oidcpy(output_oid, &item->commit->object.oid);
4836 if (i > 0) {
4837 int offset = get_item_line_offset(&todo_list, i);
4838 const char *done_path = rebase_path_done();
4840 fd = open(done_path, O_CREAT | O_WRONLY | O_APPEND, 0666);
4841 if (fd < 0) {
4842 error_errno(_("could not open '%s' for writing"),
4843 done_path);
4844 todo_list_release(&todo_list);
4845 return -1;
4847 if (write_in_full(fd, todo_list.buf.buf, offset) < 0) {
4848 error_errno(_("could not write to '%s'"), done_path);
4849 todo_list_release(&todo_list);
4850 close(fd);
4851 return -1;
4853 close(fd);
4855 if (rewrite_file(rebase_path_todo(), todo_list.buf.buf + offset,
4856 todo_list.buf.len - offset) < 0) {
4857 todo_list_release(&todo_list);
4858 return -1;
4861 todo_list.current = i;
4862 if (is_fixup(peek_command(&todo_list, 0)))
4863 record_in_rewritten(output_oid, peek_command(&todo_list, 0));
4866 todo_list_release(&todo_list);
4868 return 0;
4871 int complete_action(struct repository *r, struct replay_opts *opts, unsigned flags,
4872 const char *shortrevisions, const char *onto_name,
4873 const char *onto, const char *orig_head, const char *cmd,
4874 unsigned autosquash)
4876 const char *shortonto, *todo_file = rebase_path_todo();
4877 struct todo_list todo_list = TODO_LIST_INIT;
4878 struct strbuf *buf = &(todo_list.buf);
4879 struct object_id oid;
4880 struct stat st;
4882 get_oid(onto, &oid);
4883 shortonto = find_unique_abbrev(&oid, DEFAULT_ABBREV);
4885 if (!lstat(todo_file, &st) && st.st_size == 0 &&
4886 write_message("noop\n", 5, todo_file, 0))
4887 return -1;
4889 if (autosquash && rearrange_squash(r))
4890 return -1;
4892 if (cmd && *cmd)
4893 sequencer_add_exec_commands(r, cmd);
4895 if (strbuf_read_file(buf, todo_file, 0) < 0)
4896 return error_errno(_("could not read '%s'."), todo_file);
4898 if (parse_insn_buffer(r, buf->buf, &todo_list)) {
4899 todo_list_release(&todo_list);
4900 return error(_("unusable todo list: '%s'"), todo_file);
4903 if (count_commands(&todo_list) == 0) {
4904 apply_autostash(opts);
4905 sequencer_remove_state(opts);
4906 todo_list_release(&todo_list);
4908 return error(_("nothing to do"));
4911 strbuf_addch(buf, '\n');
4912 strbuf_commented_addf(buf, Q_("Rebase %s onto %s (%d command)",
4913 "Rebase %s onto %s (%d commands)",
4914 count_commands(&todo_list)),
4915 shortrevisions, shortonto, count_commands(&todo_list));
4916 append_todo_help(0, flags & TODO_LIST_KEEP_EMPTY, buf);
4918 if (write_message(buf->buf, buf->len, todo_file, 0)) {
4919 todo_list_release(&todo_list);
4920 return -1;
4923 if (copy_file(rebase_path_todo_backup(), todo_file, 0666))
4924 return error(_("could not copy '%s' to '%s'."), todo_file,
4925 rebase_path_todo_backup());
4927 if (transform_todos(r, flags | TODO_LIST_SHORTEN_IDS))
4928 return error(_("could not transform the todo list"));
4930 strbuf_reset(buf);
4932 if (launch_sequence_editor(todo_file, buf, NULL)) {
4933 apply_autostash(opts);
4934 sequencer_remove_state(opts);
4935 todo_list_release(&todo_list);
4937 return -1;
4940 strbuf_stripspace(buf, 1);
4941 if (buf->len == 0) {
4942 apply_autostash(opts);
4943 sequencer_remove_state(opts);
4944 todo_list_release(&todo_list);
4946 return error(_("nothing to do"));
4949 todo_list_release(&todo_list);
4951 if (check_todo_list(r)) {
4952 checkout_onto(opts, onto_name, onto, orig_head);
4953 return -1;
4956 if (transform_todos(r, flags & ~(TODO_LIST_SHORTEN_IDS)))
4957 return error(_("could not transform the todo list"));
4959 if (opts->allow_ff && skip_unnecessary_picks(r, &oid))
4960 return error(_("could not skip unnecessary pick commands"));
4962 if (checkout_onto(opts, onto_name, oid_to_hex(&oid), orig_head))
4963 return -1;
4965 if (require_clean_work_tree(r, "rebase", "", 1, 1))
4966 return -1;
4968 return sequencer_continue(r, opts);
4971 struct subject2item_entry {
4972 struct hashmap_entry entry;
4973 int i;
4974 char subject[FLEX_ARRAY];
4977 static int subject2item_cmp(const void *fndata,
4978 const struct subject2item_entry *a,
4979 const struct subject2item_entry *b, const void *key)
4981 return key ? strcmp(a->subject, key) : strcmp(a->subject, b->subject);
4984 define_commit_slab(commit_todo_item, struct todo_item *);
4987 * Rearrange the todo list that has both "pick commit-id msg" and "pick
4988 * commit-id fixup!/squash! msg" in it so that the latter is put immediately
4989 * after the former, and change "pick" to "fixup"/"squash".
4991 * Note that if the config has specified a custom instruction format, each log
4992 * message will have to be retrieved from the commit (as the oneline in the
4993 * script cannot be trusted) in order to normalize the autosquash arrangement.
4995 int rearrange_squash(struct repository *r)
4997 const char *todo_file = rebase_path_todo();
4998 struct todo_list todo_list = TODO_LIST_INIT;
4999 struct hashmap subject2item;
5000 int res = 0, rearranged = 0, *next, *tail, i;
5001 char **subjects;
5002 struct commit_todo_item commit_todo;
5004 if (strbuf_read_file_or_whine(&todo_list.buf, todo_file) < 0)
5005 return -1;
5006 if (parse_insn_buffer(r, todo_list.buf.buf, &todo_list) < 0) {
5007 todo_list_release(&todo_list);
5008 return -1;
5011 init_commit_todo_item(&commit_todo);
5013 * The hashmap maps onelines to the respective todo list index.
5015 * If any items need to be rearranged, the next[i] value will indicate
5016 * which item was moved directly after the i'th.
5018 * In that case, last[i] will indicate the index of the latest item to
5019 * be moved to appear after the i'th.
5021 hashmap_init(&subject2item, (hashmap_cmp_fn) subject2item_cmp,
5022 NULL, todo_list.nr);
5023 ALLOC_ARRAY(next, todo_list.nr);
5024 ALLOC_ARRAY(tail, todo_list.nr);
5025 ALLOC_ARRAY(subjects, todo_list.nr);
5026 for (i = 0; i < todo_list.nr; i++) {
5027 struct strbuf buf = STRBUF_INIT;
5028 struct todo_item *item = todo_list.items + i;
5029 const char *commit_buffer, *subject, *p;
5030 size_t subject_len;
5031 int i2 = -1;
5032 struct subject2item_entry *entry;
5034 next[i] = tail[i] = -1;
5035 if (!item->commit || item->command == TODO_DROP) {
5036 subjects[i] = NULL;
5037 continue;
5040 if (is_fixup(item->command)) {
5041 todo_list_release(&todo_list);
5042 clear_commit_todo_item(&commit_todo);
5043 return error(_("the script was already rearranged."));
5046 *commit_todo_item_at(&commit_todo, item->commit) = item;
5048 parse_commit(item->commit);
5049 commit_buffer = get_commit_buffer(item->commit, NULL);
5050 find_commit_subject(commit_buffer, &subject);
5051 format_subject(&buf, subject, " ");
5052 subject = subjects[i] = strbuf_detach(&buf, &subject_len);
5053 unuse_commit_buffer(item->commit, commit_buffer);
5054 if ((skip_prefix(subject, "fixup! ", &p) ||
5055 skip_prefix(subject, "squash! ", &p))) {
5056 struct commit *commit2;
5058 for (;;) {
5059 while (isspace(*p))
5060 p++;
5061 if (!skip_prefix(p, "fixup! ", &p) &&
5062 !skip_prefix(p, "squash! ", &p))
5063 break;
5066 if ((entry = hashmap_get_from_hash(&subject2item,
5067 strhash(p), p)))
5068 /* found by title */
5069 i2 = entry->i;
5070 else if (!strchr(p, ' ') &&
5071 (commit2 =
5072 lookup_commit_reference_by_name(p)) &&
5073 *commit_todo_item_at(&commit_todo, commit2))
5074 /* found by commit name */
5075 i2 = *commit_todo_item_at(&commit_todo, commit2)
5076 - todo_list.items;
5077 else {
5078 /* copy can be a prefix of the commit subject */
5079 for (i2 = 0; i2 < i; i2++)
5080 if (subjects[i2] &&
5081 starts_with(subjects[i2], p))
5082 break;
5083 if (i2 == i)
5084 i2 = -1;
5087 if (i2 >= 0) {
5088 rearranged = 1;
5089 todo_list.items[i].command =
5090 starts_with(subject, "fixup!") ?
5091 TODO_FIXUP : TODO_SQUASH;
5092 if (next[i2] < 0)
5093 next[i2] = i;
5094 else
5095 next[tail[i2]] = i;
5096 tail[i2] = i;
5097 } else if (!hashmap_get_from_hash(&subject2item,
5098 strhash(subject), subject)) {
5099 FLEX_ALLOC_MEM(entry, subject, subject, subject_len);
5100 entry->i = i;
5101 hashmap_entry_init(entry, strhash(entry->subject));
5102 hashmap_put(&subject2item, entry);
5106 if (rearranged) {
5107 struct strbuf buf = STRBUF_INIT;
5109 for (i = 0; i < todo_list.nr; i++) {
5110 enum todo_command command = todo_list.items[i].command;
5111 int cur = i;
5114 * Initially, all commands are 'pick's. If it is a
5115 * fixup or a squash now, we have rearranged it.
5117 if (is_fixup(command))
5118 continue;
5120 while (cur >= 0) {
5121 const char *bol =
5122 get_item_line(&todo_list, cur);
5123 const char *eol =
5124 get_item_line(&todo_list, cur + 1);
5126 /* replace 'pick', by 'fixup' or 'squash' */
5127 command = todo_list.items[cur].command;
5128 if (is_fixup(command)) {
5129 strbuf_addstr(&buf,
5130 todo_command_info[command].str);
5131 bol += strcspn(bol, " \t");
5134 strbuf_add(&buf, bol, eol - bol);
5136 cur = next[cur];
5140 res = rewrite_file(todo_file, buf.buf, buf.len);
5141 strbuf_release(&buf);
5144 free(next);
5145 free(tail);
5146 for (i = 0; i < todo_list.nr; i++)
5147 free(subjects[i]);
5148 free(subjects);
5149 hashmap_free(&subject2item, 1);
5150 todo_list_release(&todo_list);
5152 clear_commit_todo_item(&commit_todo);
5153 return res;