9 #include "run-command.h"
12 #include "cache-tree.h"
16 #include "merge-recursive.h"
18 #include "argv-array.h"
22 #include "wt-status.h"
24 #include "notes-utils.h"
26 #include "unpack-trees.h"
32 #define GIT_REFLOG_ACTION "GIT_REFLOG_ACTION"
34 const char sign_off_header
[] = "Signed-off-by: ";
35 static const char cherry_picked_prefix
[] = "(cherry picked from commit ";
37 GIT_PATH_FUNC(git_path_commit_editmsg
, "COMMIT_EDITMSG")
39 GIT_PATH_FUNC(git_path_seq_dir
, "sequencer")
41 static GIT_PATH_FUNC(git_path_todo_file
, "sequencer/todo")
42 static GIT_PATH_FUNC(git_path_opts_file
, "sequencer/opts")
43 static GIT_PATH_FUNC(git_path_head_file
, "sequencer/head")
44 static GIT_PATH_FUNC(git_path_abort_safety_file
, "sequencer/abort-safety")
46 static GIT_PATH_FUNC(rebase_path
, "rebase-merge")
48 * The file containing rebase commands, comments, and empty lines.
49 * This file is created by "git rebase -i" then edited by the user. As
50 * the lines are processed, they are removed from the front of this
51 * file and written to the tail of 'done'.
53 static GIT_PATH_FUNC(rebase_path_todo
, "rebase-merge/git-rebase-todo")
55 * The rebase command lines that have already been processed. A line
56 * is moved here when it is first handled, before any associated user
59 static GIT_PATH_FUNC(rebase_path_done
, "rebase-merge/done")
61 * The file to keep track of how many commands were already processed (e.g.
64 static GIT_PATH_FUNC(rebase_path_msgnum
, "rebase-merge/msgnum");
66 * The file to keep track of how many commands are to be processed in total
67 * (e.g. for the prompt).
69 static GIT_PATH_FUNC(rebase_path_msgtotal
, "rebase-merge/end");
71 * The commit message that is planned to be used for any changes that
72 * need to be committed following a user interaction.
74 static GIT_PATH_FUNC(rebase_path_message
, "rebase-merge/message")
76 * The file into which is accumulated the suggested commit message for
77 * squash/fixup commands. When the first of a series of squash/fixups
78 * is seen, the file is created and the commit message from the
79 * previous commit and from the first squash/fixup commit are written
80 * to it. The commit message for each subsequent squash/fixup commit
81 * is appended to the file as it is processed.
83 static GIT_PATH_FUNC(rebase_path_squash_msg
, "rebase-merge/message-squash")
85 * If the current series of squash/fixups has not yet included a squash
86 * command, then this file exists and holds the commit message of the
87 * original "pick" commit. (If the series ends without a "squash"
88 * command, then this can be used as the commit message of the combined
89 * commit without opening the editor.)
91 static GIT_PATH_FUNC(rebase_path_fixup_msg
, "rebase-merge/message-fixup")
93 * This file contains the list fixup/squash commands that have been
94 * accumulated into message-fixup or message-squash so far.
96 static GIT_PATH_FUNC(rebase_path_current_fixups
, "rebase-merge/current-fixups")
98 * A script to set the GIT_AUTHOR_NAME, GIT_AUTHOR_EMAIL, and
99 * GIT_AUTHOR_DATE that will be used for the commit that is currently
102 static GIT_PATH_FUNC(rebase_path_author_script
, "rebase-merge/author-script")
104 * When an "edit" rebase command is being processed, the SHA1 of the
105 * commit to be edited is recorded in this file. When "git rebase
106 * --continue" is executed, if there are any staged changes then they
107 * will be amended to the HEAD commit, but only provided the HEAD
108 * commit is still the commit to be edited. When any other rebase
109 * command is processed, this file is deleted.
111 static GIT_PATH_FUNC(rebase_path_amend
, "rebase-merge/amend")
113 * When we stop at a given patch via the "edit" command, this file contains
114 * the abbreviated commit name of the corresponding patch.
116 static GIT_PATH_FUNC(rebase_path_stopped_sha
, "rebase-merge/stopped-sha")
118 * For the post-rewrite hook, we make a list of rewritten commits and
119 * their new sha1s. The rewritten-pending list keeps the sha1s of
120 * commits that have been processed, but not committed yet,
121 * e.g. because they are waiting for a 'squash' command.
123 static GIT_PATH_FUNC(rebase_path_rewritten_list
, "rebase-merge/rewritten-list")
124 static GIT_PATH_FUNC(rebase_path_rewritten_pending
,
125 "rebase-merge/rewritten-pending")
128 * The path of the file containig the OID of the "squash onto" commit, i.e.
129 * the dummy commit used for `reset [new root]`.
131 static GIT_PATH_FUNC(rebase_path_squash_onto
, "rebase-merge/squash-onto")
134 * The path of the file listing refs that need to be deleted after the rebase
135 * finishes. This is used by the `label` command to record the need for cleanup.
137 static GIT_PATH_FUNC(rebase_path_refs_to_delete
, "rebase-merge/refs-to-delete")
140 * The following files are written by git-rebase just after parsing the
141 * command-line (and are only consumed, not modified, by the sequencer).
143 static GIT_PATH_FUNC(rebase_path_gpg_sign_opt
, "rebase-merge/gpg_sign_opt")
144 static GIT_PATH_FUNC(rebase_path_orig_head
, "rebase-merge/orig-head")
145 static GIT_PATH_FUNC(rebase_path_verbose
, "rebase-merge/verbose")
146 static GIT_PATH_FUNC(rebase_path_signoff
, "rebase-merge/signoff")
147 static GIT_PATH_FUNC(rebase_path_head_name
, "rebase-merge/head-name")
148 static GIT_PATH_FUNC(rebase_path_onto
, "rebase-merge/onto")
149 static GIT_PATH_FUNC(rebase_path_autostash
, "rebase-merge/autostash")
150 static GIT_PATH_FUNC(rebase_path_strategy
, "rebase-merge/strategy")
151 static GIT_PATH_FUNC(rebase_path_strategy_opts
, "rebase-merge/strategy_opts")
152 static GIT_PATH_FUNC(rebase_path_allow_rerere_autoupdate
, "rebase-merge/allow_rerere_autoupdate")
154 static int git_sequencer_config(const char *k
, const char *v
, void *cb
)
156 struct replay_opts
*opts
= cb
;
159 if (!strcmp(k
, "commit.cleanup")) {
162 status
= git_config_string(&s
, k
, v
);
166 if (!strcmp(s
, "verbatim"))
167 opts
->default_msg_cleanup
= COMMIT_MSG_CLEANUP_NONE
;
168 else if (!strcmp(s
, "whitespace"))
169 opts
->default_msg_cleanup
= COMMIT_MSG_CLEANUP_SPACE
;
170 else if (!strcmp(s
, "strip"))
171 opts
->default_msg_cleanup
= COMMIT_MSG_CLEANUP_ALL
;
172 else if (!strcmp(s
, "scissors"))
173 opts
->default_msg_cleanup
= COMMIT_MSG_CLEANUP_SPACE
;
175 warning(_("invalid commit message cleanup mode '%s'"),
181 if (!strcmp(k
, "commit.gpgsign")) {
182 opts
->gpg_sign
= git_config_bool(k
, v
) ? xstrdup("") : NULL
;
186 status
= git_gpg_config(k
, v
, NULL
);
190 return git_diff_basic_config(k
, v
, NULL
);
193 void sequencer_init_config(struct replay_opts
*opts
)
195 opts
->default_msg_cleanup
= COMMIT_MSG_CLEANUP_NONE
;
196 git_config(git_sequencer_config
, opts
);
199 static inline int is_rebase_i(const struct replay_opts
*opts
)
201 return opts
->action
== REPLAY_INTERACTIVE_REBASE
;
204 static const char *get_dir(const struct replay_opts
*opts
)
206 if (is_rebase_i(opts
))
207 return rebase_path();
208 return git_path_seq_dir();
211 static const char *get_todo_path(const struct replay_opts
*opts
)
213 if (is_rebase_i(opts
))
214 return rebase_path_todo();
215 return git_path_todo_file();
219 * Returns 0 for non-conforming footer
220 * Returns 1 for conforming footer
221 * Returns 2 when sob exists within conforming footer
222 * Returns 3 when sob exists within conforming footer as last entry
224 static int has_conforming_footer(struct strbuf
*sb
, struct strbuf
*sob
,
227 struct trailer_info info
;
229 int found_sob
= 0, found_sob_last
= 0;
231 trailer_info_get(&info
, sb
->buf
);
233 if (info
.trailer_start
== info
.trailer_end
)
236 for (i
= 0; i
< info
.trailer_nr
; i
++)
237 if (sob
&& !strncmp(info
.trailers
[i
], sob
->buf
, sob
->len
)) {
239 if (i
== info
.trailer_nr
- 1)
243 trailer_info_release(&info
);
252 static const char *gpg_sign_opt_quoted(struct replay_opts
*opts
)
254 static struct strbuf buf
= STRBUF_INIT
;
258 sq_quotef(&buf
, "-S%s", opts
->gpg_sign
);
262 int sequencer_remove_state(struct replay_opts
*opts
)
264 struct strbuf buf
= STRBUF_INIT
;
267 if (is_rebase_i(opts
) &&
268 strbuf_read_file(&buf
, rebase_path_refs_to_delete(), 0) > 0) {
271 char *eol
= strchr(p
, '\n');
274 if (delete_ref("(rebase -i) cleanup", p
, NULL
, 0) < 0)
275 warning(_("could not delete '%s'"), p
);
282 free(opts
->gpg_sign
);
283 free(opts
->strategy
);
284 for (i
= 0; i
< opts
->xopts_nr
; i
++)
285 free(opts
->xopts
[i
]);
287 strbuf_release(&opts
->current_fixups
);
290 strbuf_addstr(&buf
, get_dir(opts
));
291 remove_dir_recursively(&buf
, 0);
292 strbuf_release(&buf
);
297 static const char *action_name(const struct replay_opts
*opts
)
299 switch (opts
->action
) {
303 return N_("cherry-pick");
304 case REPLAY_INTERACTIVE_REBASE
:
305 return N_("rebase -i");
307 die(_("Unknown action: %d"), opts
->action
);
310 struct commit_message
{
317 static const char *short_commit_name(struct commit
*commit
)
319 return find_unique_abbrev(&commit
->object
.oid
, DEFAULT_ABBREV
);
322 static int get_message(struct commit
*commit
, struct commit_message
*out
)
324 const char *abbrev
, *subject
;
327 out
->message
= logmsg_reencode(commit
, NULL
, get_commit_output_encoding());
328 abbrev
= short_commit_name(commit
);
330 subject_len
= find_commit_subject(out
->message
, &subject
);
332 out
->subject
= xmemdupz(subject
, subject_len
);
333 out
->label
= xstrfmt("%s... %s", abbrev
, out
->subject
);
334 out
->parent_label
= xstrfmt("parent of %s", out
->label
);
339 static void free_message(struct commit
*commit
, struct commit_message
*msg
)
341 free(msg
->parent_label
);
344 unuse_commit_buffer(commit
, msg
->message
);
347 static void print_advice(int show_hint
, struct replay_opts
*opts
)
349 char *msg
= getenv("GIT_CHERRY_PICK_HELP");
352 fprintf(stderr
, "%s\n", msg
);
354 * A conflict has occurred but the porcelain
355 * (typically rebase --interactive) wants to take care
356 * of the commit itself so remove CHERRY_PICK_HEAD
358 unlink(git_path_cherry_pick_head());
364 advise(_("after resolving the conflicts, mark the corrected paths\n"
365 "with 'git add <paths>' or 'git rm <paths>'"));
367 advise(_("after resolving the conflicts, mark the corrected paths\n"
368 "with 'git add <paths>' or 'git rm <paths>'\n"
369 "and commit the result with 'git commit'"));
373 static int write_message(const void *buf
, size_t len
, const char *filename
,
376 struct lock_file msg_file
= LOCK_INIT
;
378 int msg_fd
= hold_lock_file_for_update(&msg_file
, filename
, 0);
380 return error_errno(_("could not lock '%s'"), filename
);
381 if (write_in_full(msg_fd
, buf
, len
) < 0) {
382 error_errno(_("could not write to '%s'"), filename
);
383 rollback_lock_file(&msg_file
);
386 if (append_eol
&& write(msg_fd
, "\n", 1) < 0) {
387 error_errno(_("could not write eol to '%s'"), filename
);
388 rollback_lock_file(&msg_file
);
391 if (commit_lock_file(&msg_file
) < 0)
392 return error(_("failed to finalize '%s'"), filename
);
398 * Reads a file that was presumably written by a shell script, i.e. with an
399 * end-of-line marker that needs to be stripped.
401 * Note that only the last end-of-line marker is stripped, consistent with the
402 * behavior of "$(cat path)" in a shell script.
404 * Returns 1 if the file was read, 0 if it could not be read or does not exist.
406 static int read_oneliner(struct strbuf
*buf
,
407 const char *path
, int skip_if_empty
)
409 int orig_len
= buf
->len
;
411 if (!file_exists(path
))
414 if (strbuf_read_file(buf
, path
, 0) < 0) {
415 warning_errno(_("could not read '%s'"), path
);
419 if (buf
->len
> orig_len
&& buf
->buf
[buf
->len
- 1] == '\n') {
420 if (--buf
->len
> orig_len
&& buf
->buf
[buf
->len
- 1] == '\r')
422 buf
->buf
[buf
->len
] = '\0';
425 if (skip_if_empty
&& buf
->len
== orig_len
)
431 static struct tree
*empty_tree(void)
433 return lookup_tree(the_hash_algo
->empty_tree
);
436 static int error_dirty_index(struct replay_opts
*opts
)
438 if (read_cache_unmerged())
439 return error_resolve_conflict(_(action_name(opts
)));
441 error(_("your local changes would be overwritten by %s."),
442 _(action_name(opts
)));
444 if (advice_commit_before_merge
)
445 advise(_("commit your changes or stash them to proceed."));
449 static void update_abort_safety_file(void)
451 struct object_id head
;
453 /* Do nothing on a single-pick */
454 if (!file_exists(git_path_seq_dir()))
457 if (!get_oid("HEAD", &head
))
458 write_file(git_path_abort_safety_file(), "%s", oid_to_hex(&head
));
460 write_file(git_path_abort_safety_file(), "%s", "");
463 static int fast_forward_to(const struct object_id
*to
, const struct object_id
*from
,
464 int unborn
, struct replay_opts
*opts
)
466 struct ref_transaction
*transaction
;
467 struct strbuf sb
= STRBUF_INIT
;
468 struct strbuf err
= STRBUF_INIT
;
471 if (checkout_fast_forward(from
, to
, 1))
472 return -1; /* the callee should have complained already */
474 strbuf_addf(&sb
, _("%s: fast-forward"), _(action_name(opts
)));
476 transaction
= ref_transaction_begin(&err
);
478 ref_transaction_update(transaction
, "HEAD",
479 to
, unborn
&& !is_rebase_i(opts
) ?
482 ref_transaction_commit(transaction
, &err
)) {
483 ref_transaction_free(transaction
);
484 error("%s", err
.buf
);
486 strbuf_release(&err
);
491 strbuf_release(&err
);
492 ref_transaction_free(transaction
);
493 update_abort_safety_file();
497 void append_conflicts_hint(struct strbuf
*msgbuf
)
501 strbuf_addch(msgbuf
, '\n');
502 strbuf_commented_addf(msgbuf
, "Conflicts:\n");
503 for (i
= 0; i
< active_nr
;) {
504 const struct cache_entry
*ce
= active_cache
[i
++];
506 strbuf_commented_addf(msgbuf
, "\t%s\n", ce
->name
);
507 while (i
< active_nr
&& !strcmp(ce
->name
,
508 active_cache
[i
]->name
))
514 static int do_recursive_merge(struct commit
*base
, struct commit
*next
,
515 const char *base_label
, const char *next_label
,
516 struct object_id
*head
, struct strbuf
*msgbuf
,
517 struct replay_opts
*opts
)
519 struct merge_options o
;
520 struct tree
*result
, *next_tree
, *base_tree
, *head_tree
;
523 struct lock_file index_lock
= LOCK_INIT
;
525 if (hold_locked_index(&index_lock
, LOCK_REPORT_ON_ERROR
) < 0)
530 init_merge_options(&o
);
531 o
.ancestor
= base
? base_label
: "(empty tree)";
533 o
.branch2
= next
? next_label
: "(empty tree)";
534 if (is_rebase_i(opts
))
536 o
.show_rename_progress
= 1;
538 head_tree
= parse_tree_indirect(head
);
539 next_tree
= next
? get_commit_tree(next
) : empty_tree();
540 base_tree
= base
? get_commit_tree(base
) : empty_tree();
542 for (xopt
= opts
->xopts
; xopt
!= opts
->xopts
+ opts
->xopts_nr
; xopt
++)
543 parse_merge_opt(&o
, *xopt
);
545 clean
= merge_trees(&o
,
547 next_tree
, base_tree
, &result
);
548 if (is_rebase_i(opts
) && clean
<= 0)
549 fputs(o
.obuf
.buf
, stdout
);
550 strbuf_release(&o
.obuf
);
551 diff_warn_rename_limit("merge.renamelimit", o
.needed_rename_limit
, 0);
553 rollback_lock_file(&index_lock
);
557 if (write_locked_index(&the_index
, &index_lock
,
558 COMMIT_LOCK
| SKIP_IF_UNCHANGED
))
560 * TRANSLATORS: %s will be "revert", "cherry-pick" or
563 return error(_("%s: Unable to write new index file"),
564 _(action_name(opts
)));
567 append_conflicts_hint(msgbuf
);
572 static struct object_id
*get_cache_tree_oid(void)
574 if (!active_cache_tree
)
575 active_cache_tree
= cache_tree();
577 if (!cache_tree_fully_valid(active_cache_tree
))
578 if (cache_tree_update(&the_index
, 0)) {
579 error(_("unable to update cache tree"));
583 return &active_cache_tree
->oid
;
586 static int is_index_unchanged(void)
588 struct object_id head_oid
, *cache_tree_oid
;
589 struct commit
*head_commit
;
591 if (!resolve_ref_unsafe("HEAD", RESOLVE_REF_READING
, &head_oid
, NULL
))
592 return error(_("could not resolve HEAD commit"));
594 head_commit
= lookup_commit(&head_oid
);
597 * If head_commit is NULL, check_commit, called from
598 * lookup_commit, would have indicated that head_commit is not
599 * a commit object already. parse_commit() will return failure
600 * without further complaints in such a case. Otherwise, if
601 * the commit is invalid, parse_commit() will complain. So
602 * there is nothing for us to say here. Just return failure.
604 if (parse_commit(head_commit
))
607 if (!(cache_tree_oid
= get_cache_tree_oid()))
610 return !oidcmp(cache_tree_oid
, get_commit_tree_oid(head_commit
));
613 static int write_author_script(const char *message
)
615 struct strbuf buf
= STRBUF_INIT
;
620 if (!*message
|| starts_with(message
, "\n")) {
622 /* Missing 'author' line? */
623 unlink(rebase_path_author_script());
625 } else if (skip_prefix(message
, "author ", &message
))
627 else if ((eol
= strchr(message
, '\n')))
632 strbuf_addstr(&buf
, "GIT_AUTHOR_NAME='");
633 while (*message
&& *message
!= '\n' && *message
!= '\r')
634 if (skip_prefix(message
, " <", &message
))
636 else if (*message
!= '\'')
637 strbuf_addch(&buf
, *(message
++));
639 strbuf_addf(&buf
, "'\\\\%c'", *(message
++));
640 strbuf_addstr(&buf
, "'\nGIT_AUTHOR_EMAIL='");
641 while (*message
&& *message
!= '\n' && *message
!= '\r')
642 if (skip_prefix(message
, "> ", &message
))
644 else if (*message
!= '\'')
645 strbuf_addch(&buf
, *(message
++));
647 strbuf_addf(&buf
, "'\\\\%c'", *(message
++));
648 strbuf_addstr(&buf
, "'\nGIT_AUTHOR_DATE='@");
649 while (*message
&& *message
!= '\n' && *message
!= '\r')
650 if (*message
!= '\'')
651 strbuf_addch(&buf
, *(message
++));
653 strbuf_addf(&buf
, "'\\\\%c'", *(message
++));
654 strbuf_addch(&buf
, '\'');
655 res
= write_message(buf
.buf
, buf
.len
, rebase_path_author_script(), 1);
656 strbuf_release(&buf
);
661 * Read a list of environment variable assignments (such as the author-script
662 * file) into an environment block. Returns -1 on error, 0 otherwise.
664 static int read_env_script(struct argv_array
*env
)
666 struct strbuf script
= STRBUF_INIT
;
670 if (strbuf_read_file(&script
, rebase_path_author_script(), 256) <= 0)
673 for (p
= script
.buf
; *p
; p
++)
674 if (skip_prefix(p
, "'\\\\''", (const char **)&p2
))
675 strbuf_splice(&script
, p
- script
.buf
, p2
- p
, "'", 1);
677 strbuf_splice(&script
, p
-- - script
.buf
, 1, "", 0);
678 else if (*p
== '\n') {
683 for (i
= 0, p
= script
.buf
; i
< count
; i
++) {
684 argv_array_push(env
, p
);
691 static char *get_author(const char *message
)
696 a
= find_commit_header(message
, "author", &len
);
698 return xmemdupz(a
, len
);
703 /* Read author-script and return an ident line (author <email> timestamp) */
704 static const char *read_author_ident(struct strbuf
*buf
)
706 const char *keys
[] = {
707 "GIT_AUTHOR_NAME=", "GIT_AUTHOR_EMAIL=", "GIT_AUTHOR_DATE="
709 struct strbuf out
= STRBUF_INIT
;
714 if (strbuf_read_file(buf
, rebase_path_author_script(), 256) <= 0)
717 /* dequote values and construct ident line in-place */
718 for (in
= buf
->buf
; i
< 3 && in
- buf
->buf
< buf
->len
; i
++) {
719 if (!skip_prefix(in
, keys
[i
], (const char **)&in
)) {
720 warning("could not parse '%s' (looking for '%s'",
721 rebase_path_author_script(), keys
[i
]);
725 eol
= strchrnul(in
, '\n');
727 if (!sq_dequote(in
)) {
728 warning(_("bad quoting on %s value in '%s'"),
729 keys
[i
], rebase_path_author_script());
737 warning("could not parse '%s' (looking for '%s')",
738 rebase_path_author_script(), keys
[i
]);
742 strbuf_addstr(&out
, fmt_ident(val
[0], val
[1], val
[2], 0));
743 strbuf_swap(buf
, &out
);
744 strbuf_release(&out
);
748 static const char staged_changes_advice
[] =
749 N_("you have staged changes in your working tree\n"
750 "If these changes are meant to be squashed into the previous commit, run:\n"
752 " git commit --amend %s\n"
754 "If they are meant to go into a new commit, run:\n"
758 "In both cases, once you're done, continue with:\n"
760 " git rebase --continue\n");
762 #define ALLOW_EMPTY (1<<0)
763 #define EDIT_MSG (1<<1)
764 #define AMEND_MSG (1<<2)
765 #define CLEANUP_MSG (1<<3)
766 #define VERIFY_MSG (1<<4)
767 #define CREATE_ROOT_COMMIT (1<<5)
770 * If we are cherry-pick, and if the merge did not result in
771 * hand-editing, we will hit this commit and inherit the original
772 * author date and name.
774 * If we are revert, or if our cherry-pick results in a hand merge,
775 * we had better say that the current user is responsible for that.
777 * An exception is when run_git_commit() is called during an
778 * interactive rebase: in that case, we will want to retain the
781 static int run_git_commit(const char *defmsg
, struct replay_opts
*opts
,
784 struct child_process cmd
= CHILD_PROCESS_INIT
;
787 if ((flags
& CREATE_ROOT_COMMIT
) && !(flags
& AMEND_MSG
)) {
788 struct strbuf msg
= STRBUF_INIT
, script
= STRBUF_INIT
;
789 const char *author
= is_rebase_i(opts
) ?
790 read_author_ident(&script
) : NULL
;
791 struct object_id root_commit
, *cache_tree_oid
;
795 BUG("root commit without message");
797 if (!(cache_tree_oid
= get_cache_tree_oid()))
801 res
= strbuf_read_file(&msg
, defmsg
, 0);
804 res
= error_errno(_("could not read '%s'"), defmsg
);
806 res
= commit_tree(msg
.buf
, msg
.len
, cache_tree_oid
,
807 NULL
, &root_commit
, author
,
810 strbuf_release(&msg
);
811 strbuf_release(&script
);
813 update_ref(NULL
, "CHERRY_PICK_HEAD", &root_commit
, NULL
,
814 REF_NO_DEREF
, UPDATE_REFS_MSG_ON_ERR
);
815 res
= update_ref(NULL
, "HEAD", &root_commit
, NULL
, 0,
816 UPDATE_REFS_MSG_ON_ERR
);
818 return res
< 0 ? error(_("writing root commit")) : 0;
823 if (is_rebase_i(opts
)) {
824 if (!(flags
& EDIT_MSG
)) {
825 cmd
.stdout_to_stderr
= 1;
829 if (read_env_script(&cmd
.env_array
)) {
830 const char *gpg_opt
= gpg_sign_opt_quoted(opts
);
832 return error(_(staged_changes_advice
),
837 argv_array_push(&cmd
.args
, "commit");
839 if (!(flags
& VERIFY_MSG
))
840 argv_array_push(&cmd
.args
, "-n");
841 if ((flags
& AMEND_MSG
))
842 argv_array_push(&cmd
.args
, "--amend");
844 argv_array_pushf(&cmd
.args
, "-S%s", opts
->gpg_sign
);
846 argv_array_pushl(&cmd
.args
, "-F", defmsg
, NULL
);
847 else if (!(flags
& EDIT_MSG
))
848 argv_array_pushl(&cmd
.args
, "-C", "HEAD", NULL
);
849 if ((flags
& CLEANUP_MSG
))
850 argv_array_push(&cmd
.args
, "--cleanup=strip");
851 if ((flags
& EDIT_MSG
))
852 argv_array_push(&cmd
.args
, "-e");
853 else if (!(flags
& CLEANUP_MSG
) &&
854 !opts
->signoff
&& !opts
->record_origin
&&
855 git_config_get_value("commit.cleanup", &value
))
856 argv_array_push(&cmd
.args
, "--cleanup=verbatim");
858 if ((flags
& ALLOW_EMPTY
))
859 argv_array_push(&cmd
.args
, "--allow-empty");
861 if (opts
->allow_empty_message
)
862 argv_array_push(&cmd
.args
, "--allow-empty-message");
865 /* hide stderr on success */
866 struct strbuf buf
= STRBUF_INIT
;
867 int rc
= pipe_command(&cmd
,
869 /* stdout is already redirected */
873 fputs(buf
.buf
, stderr
);
874 strbuf_release(&buf
);
878 return run_command(&cmd
);
881 static int rest_is_empty(const struct strbuf
*sb
, int start
)
886 /* Check if the rest is just whitespace and Signed-off-by's. */
887 for (i
= start
; i
< sb
->len
; i
++) {
888 nl
= memchr(sb
->buf
+ i
, '\n', sb
->len
- i
);
894 if (strlen(sign_off_header
) <= eol
- i
&&
895 starts_with(sb
->buf
+ i
, sign_off_header
)) {
900 if (!isspace(sb
->buf
[i
++]))
908 * Find out if the message in the strbuf contains only whitespace and
909 * Signed-off-by lines.
911 int message_is_empty(const struct strbuf
*sb
,
912 enum commit_msg_cleanup_mode cleanup_mode
)
914 if (cleanup_mode
== COMMIT_MSG_CLEANUP_NONE
&& sb
->len
)
916 return rest_is_empty(sb
, 0);
920 * See if the user edited the message in the editor or left what
921 * was in the template intact
923 int template_untouched(const struct strbuf
*sb
, const char *template_file
,
924 enum commit_msg_cleanup_mode cleanup_mode
)
926 struct strbuf tmpl
= STRBUF_INIT
;
929 if (cleanup_mode
== COMMIT_MSG_CLEANUP_NONE
&& sb
->len
)
932 if (!template_file
|| strbuf_read_file(&tmpl
, template_file
, 0) <= 0)
935 strbuf_stripspace(&tmpl
, cleanup_mode
== COMMIT_MSG_CLEANUP_ALL
);
936 if (!skip_prefix(sb
->buf
, tmpl
.buf
, &start
))
938 strbuf_release(&tmpl
);
939 return rest_is_empty(sb
, start
- sb
->buf
);
942 int update_head_with_reflog(const struct commit
*old_head
,
943 const struct object_id
*new_head
,
944 const char *action
, const struct strbuf
*msg
,
947 struct ref_transaction
*transaction
;
948 struct strbuf sb
= STRBUF_INIT
;
953 strbuf_addstr(&sb
, action
);
954 strbuf_addstr(&sb
, ": ");
957 nl
= strchr(msg
->buf
, '\n');
959 strbuf_add(&sb
, msg
->buf
, nl
+ 1 - msg
->buf
);
961 strbuf_addbuf(&sb
, msg
);
962 strbuf_addch(&sb
, '\n');
965 transaction
= ref_transaction_begin(err
);
967 ref_transaction_update(transaction
, "HEAD", new_head
,
968 old_head
? &old_head
->object
.oid
: &null_oid
,
970 ref_transaction_commit(transaction
, err
)) {
973 ref_transaction_free(transaction
);
979 static int run_rewrite_hook(const struct object_id
*oldoid
,
980 const struct object_id
*newoid
)
982 struct child_process proc
= CHILD_PROCESS_INIT
;
985 struct strbuf sb
= STRBUF_INIT
;
987 argv
[0] = find_hook("post-rewrite");
996 proc
.stdout_to_stderr
= 1;
998 code
= start_command(&proc
);
1001 strbuf_addf(&sb
, "%s %s\n", oid_to_hex(oldoid
), oid_to_hex(newoid
));
1002 sigchain_push(SIGPIPE
, SIG_IGN
);
1003 write_in_full(proc
.in
, sb
.buf
, sb
.len
);
1005 strbuf_release(&sb
);
1006 sigchain_pop(SIGPIPE
);
1007 return finish_command(&proc
);
1010 void commit_post_rewrite(const struct commit
*old_head
,
1011 const struct object_id
*new_head
)
1013 struct notes_rewrite_cfg
*cfg
;
1015 cfg
= init_copy_notes_for_rewrite("amend");
1017 /* we are amending, so old_head is not NULL */
1018 copy_note_for_rewrite(cfg
, &old_head
->object
.oid
, new_head
);
1019 finish_copy_notes_for_rewrite(cfg
, "Notes added by 'git commit --amend'");
1021 run_rewrite_hook(&old_head
->object
.oid
, new_head
);
1024 static int run_prepare_commit_msg_hook(struct strbuf
*msg
, const char *commit
)
1026 struct argv_array hook_env
= ARGV_ARRAY_INIT
;
1030 name
= git_path_commit_editmsg();
1031 if (write_message(msg
->buf
, msg
->len
, name
, 0))
1034 argv_array_pushf(&hook_env
, "GIT_INDEX_FILE=%s", get_index_file());
1035 argv_array_push(&hook_env
, "GIT_EDITOR=:");
1037 ret
= run_hook_le(hook_env
.argv
, "prepare-commit-msg", name
,
1038 "commit", commit
, NULL
);
1040 ret
= run_hook_le(hook_env
.argv
, "prepare-commit-msg", name
,
1043 ret
= error(_("'prepare-commit-msg' hook failed"));
1044 argv_array_clear(&hook_env
);
1049 static const char implicit_ident_advice_noconfig
[] =
1050 N_("Your name and email address were configured automatically based\n"
1051 "on your username and hostname. Please check that they are accurate.\n"
1052 "You can suppress this message by setting them explicitly. Run the\n"
1053 "following command and follow the instructions in your editor to edit\n"
1054 "your configuration file:\n"
1056 " git config --global --edit\n"
1058 "After doing this, you may fix the identity used for this commit with:\n"
1060 " git commit --amend --reset-author\n");
1062 static const char implicit_ident_advice_config
[] =
1063 N_("Your name and email address were configured automatically based\n"
1064 "on your username and hostname. Please check that they are accurate.\n"
1065 "You can suppress this message by setting them explicitly:\n"
1067 " git config --global user.name \"Your Name\"\n"
1068 " git config --global user.email you@example.com\n"
1070 "After doing this, you may fix the identity used for this commit with:\n"
1072 " git commit --amend --reset-author\n");
1074 static const char *implicit_ident_advice(void)
1076 char *user_config
= expand_user_path("~/.gitconfig", 0);
1077 char *xdg_config
= xdg_config_home("config");
1078 int config_exists
= file_exists(user_config
) || file_exists(xdg_config
);
1084 return _(implicit_ident_advice_config
);
1086 return _(implicit_ident_advice_noconfig
);
1090 void print_commit_summary(const char *prefix
, const struct object_id
*oid
,
1093 struct rev_info rev
;
1094 struct commit
*commit
;
1095 struct strbuf format
= STRBUF_INIT
;
1097 struct pretty_print_context pctx
= {0};
1098 struct strbuf author_ident
= STRBUF_INIT
;
1099 struct strbuf committer_ident
= STRBUF_INIT
;
1101 commit
= lookup_commit(oid
);
1103 die(_("couldn't look up newly created commit"));
1104 if (parse_commit(commit
))
1105 die(_("could not parse newly created commit"));
1107 strbuf_addstr(&format
, "format:%h] %s");
1109 format_commit_message(commit
, "%an <%ae>", &author_ident
, &pctx
);
1110 format_commit_message(commit
, "%cn <%ce>", &committer_ident
, &pctx
);
1111 if (strbuf_cmp(&author_ident
, &committer_ident
)) {
1112 strbuf_addstr(&format
, "\n Author: ");
1113 strbuf_addbuf_percentquote(&format
, &author_ident
);
1115 if (flags
& SUMMARY_SHOW_AUTHOR_DATE
) {
1116 struct strbuf date
= STRBUF_INIT
;
1118 format_commit_message(commit
, "%ad", &date
, &pctx
);
1119 strbuf_addstr(&format
, "\n Date: ");
1120 strbuf_addbuf_percentquote(&format
, &date
);
1121 strbuf_release(&date
);
1123 if (!committer_ident_sufficiently_given()) {
1124 strbuf_addstr(&format
, "\n Committer: ");
1125 strbuf_addbuf_percentquote(&format
, &committer_ident
);
1126 if (advice_implicit_identity
) {
1127 strbuf_addch(&format
, '\n');
1128 strbuf_addstr(&format
, implicit_ident_advice());
1131 strbuf_release(&author_ident
);
1132 strbuf_release(&committer_ident
);
1134 init_revisions(&rev
, prefix
);
1135 setup_revisions(0, NULL
, &rev
, NULL
);
1138 rev
.diffopt
.output_format
=
1139 DIFF_FORMAT_SHORTSTAT
| DIFF_FORMAT_SUMMARY
;
1141 rev
.verbose_header
= 1;
1142 rev
.show_root_diff
= 1;
1143 get_commit_format(format
.buf
, &rev
);
1144 rev
.always_show_header
= 0;
1145 rev
.diffopt
.detect_rename
= DIFF_DETECT_RENAME
;
1146 rev
.diffopt
.break_opt
= 0;
1147 diff_setup_done(&rev
.diffopt
);
1149 head
= resolve_ref_unsafe("HEAD", 0, NULL
, NULL
);
1151 die_errno(_("unable to resolve HEAD after creating commit"));
1152 if (!strcmp(head
, "HEAD"))
1153 head
= _("detached HEAD");
1155 skip_prefix(head
, "refs/heads/", &head
);
1156 printf("[%s%s ", head
, (flags
& SUMMARY_INITIAL_COMMIT
) ?
1157 _(" (root-commit)") : "");
1159 if (!log_tree_commit(&rev
, commit
)) {
1160 rev
.always_show_header
= 1;
1161 rev
.use_terminator
= 1;
1162 log_tree_commit(&rev
, commit
);
1165 strbuf_release(&format
);
1168 static int parse_head(struct commit
**head
)
1170 struct commit
*current_head
;
1171 struct object_id oid
;
1173 if (get_oid("HEAD", &oid
)) {
1174 current_head
= NULL
;
1176 current_head
= lookup_commit_reference(&oid
);
1178 return error(_("could not parse HEAD"));
1179 if (oidcmp(&oid
, ¤t_head
->object
.oid
)) {
1180 warning(_("HEAD %s is not a commit!"),
1183 if (parse_commit(current_head
))
1184 return error(_("could not parse HEAD commit"));
1186 *head
= current_head
;
1192 * Try to commit without forking 'git commit'. In some cases we need
1193 * to run 'git commit' to display an error message
1196 * -1 - error unable to commit
1198 * 1 - run 'git commit'
1200 static int try_to_commit(struct strbuf
*msg
, const char *author
,
1201 struct replay_opts
*opts
, unsigned int flags
,
1202 struct object_id
*oid
)
1204 struct object_id tree
;
1205 struct commit
*current_head
;
1206 struct commit_list
*parents
= NULL
;
1207 struct commit_extra_header
*extra
= NULL
;
1208 struct strbuf err
= STRBUF_INIT
;
1209 struct strbuf commit_msg
= STRBUF_INIT
;
1210 char *amend_author
= NULL
;
1211 const char *hook_commit
= NULL
;
1212 enum commit_msg_cleanup_mode cleanup
;
1215 if (parse_head(¤t_head
))
1218 if (flags
& AMEND_MSG
) {
1219 const char *exclude_gpgsig
[] = { "gpgsig", NULL
};
1220 const char *out_enc
= get_commit_output_encoding();
1221 const char *message
= logmsg_reencode(current_head
, NULL
,
1225 const char *orig_message
= NULL
;
1227 find_commit_subject(message
, &orig_message
);
1229 strbuf_addstr(msg
, orig_message
);
1230 hook_commit
= "HEAD";
1232 author
= amend_author
= get_author(message
);
1233 unuse_commit_buffer(current_head
, message
);
1235 res
= error(_("unable to parse commit author"));
1238 parents
= copy_commit_list(current_head
->parents
);
1239 extra
= read_commit_extra_headers(current_head
, exclude_gpgsig
);
1240 } else if (current_head
) {
1241 commit_list_insert(current_head
, &parents
);
1244 if (write_cache_as_tree(&tree
, 0, NULL
)) {
1245 res
= error(_("git write-tree failed to write a tree"));
1249 if (!(flags
& ALLOW_EMPTY
) && !oidcmp(current_head
?
1250 get_commit_tree_oid(current_head
) :
1251 the_hash_algo
->empty_tree
, &tree
)) {
1252 res
= 1; /* run 'git commit' to display error message */
1256 if (find_hook("prepare-commit-msg")) {
1257 res
= run_prepare_commit_msg_hook(msg
, hook_commit
);
1260 if (strbuf_read_file(&commit_msg
, git_path_commit_editmsg(),
1262 res
= error_errno(_("unable to read commit message "
1264 git_path_commit_editmsg());
1270 cleanup
= (flags
& CLEANUP_MSG
) ? COMMIT_MSG_CLEANUP_ALL
:
1271 opts
->default_msg_cleanup
;
1273 if (cleanup
!= COMMIT_MSG_CLEANUP_NONE
)
1274 strbuf_stripspace(msg
, cleanup
== COMMIT_MSG_CLEANUP_ALL
);
1275 if (!opts
->allow_empty_message
&& message_is_empty(msg
, cleanup
)) {
1276 res
= 1; /* run 'git commit' to display error message */
1282 if (commit_tree_extended(msg
->buf
, msg
->len
, &tree
, parents
,
1283 oid
, author
, opts
->gpg_sign
, extra
)) {
1284 res
= error(_("failed to write commit object"));
1288 if (update_head_with_reflog(current_head
, oid
,
1289 getenv("GIT_REFLOG_ACTION"), msg
, &err
)) {
1290 res
= error("%s", err
.buf
);
1294 if (flags
& AMEND_MSG
)
1295 commit_post_rewrite(current_head
, oid
);
1298 free_commit_extra_headers(extra
);
1299 strbuf_release(&err
);
1300 strbuf_release(&commit_msg
);
1306 static int do_commit(const char *msg_file
, const char *author
,
1307 struct replay_opts
*opts
, unsigned int flags
)
1311 if (!(flags
& EDIT_MSG
) && !(flags
& VERIFY_MSG
) &&
1312 !(flags
& CREATE_ROOT_COMMIT
)) {
1313 struct object_id oid
;
1314 struct strbuf sb
= STRBUF_INIT
;
1316 if (msg_file
&& strbuf_read_file(&sb
, msg_file
, 2048) < 0)
1317 return error_errno(_("unable to read commit message "
1321 res
= try_to_commit(msg_file
? &sb
: NULL
, author
, opts
, flags
,
1323 strbuf_release(&sb
);
1325 unlink(git_path_cherry_pick_head());
1326 unlink(git_path_merge_msg());
1327 if (!is_rebase_i(opts
))
1328 print_commit_summary(NULL
, &oid
,
1329 SUMMARY_SHOW_AUTHOR_DATE
);
1334 return run_git_commit(msg_file
, opts
, flags
);
1339 static int is_original_commit_empty(struct commit
*commit
)
1341 const struct object_id
*ptree_oid
;
1343 if (parse_commit(commit
))
1344 return error(_("could not parse commit %s"),
1345 oid_to_hex(&commit
->object
.oid
));
1346 if (commit
->parents
) {
1347 struct commit
*parent
= commit
->parents
->item
;
1348 if (parse_commit(parent
))
1349 return error(_("could not parse parent commit %s"),
1350 oid_to_hex(&parent
->object
.oid
));
1351 ptree_oid
= get_commit_tree_oid(parent
);
1353 ptree_oid
= the_hash_algo
->empty_tree
; /* commit is root */
1356 return !oidcmp(ptree_oid
, get_commit_tree_oid(commit
));
1360 * Do we run "git commit" with "--allow-empty"?
1362 static int allow_empty(struct replay_opts
*opts
, struct commit
*commit
)
1364 int index_unchanged
, empty_commit
;
1369 * (1) we do not allow empty at all and error out.
1371 * (2) we allow ones that were initially empty, but
1372 * forbid the ones that become empty;
1374 * (3) we allow both.
1376 if (!opts
->allow_empty
)
1377 return 0; /* let "git commit" barf as necessary */
1379 index_unchanged
= is_index_unchanged();
1380 if (index_unchanged
< 0)
1381 return index_unchanged
;
1382 if (!index_unchanged
)
1383 return 0; /* we do not have to say --allow-empty */
1385 if (opts
->keep_redundant_commits
)
1388 empty_commit
= is_original_commit_empty(commit
);
1389 if (empty_commit
< 0)
1390 return empty_commit
;
1398 * Note that ordering matters in this enum. Not only must it match the mapping
1399 * below, it is also divided into several sections that matter. When adding
1400 * new commands, make sure you add it in the right section.
1403 /* commands that handle commits */
1410 /* commands that do something else than handling a single commit */
1415 /* commands that do nothing but are counted for reporting progress */
1418 /* comments (not counted for reporting progress) */
1425 } todo_command_info
[] = {
1441 static const char *command_to_string(const enum todo_command command
)
1443 if (command
< TODO_COMMENT
)
1444 return todo_command_info
[command
].str
;
1445 die("Unknown command: %d", command
);
1448 static char command_to_char(const enum todo_command command
)
1450 if (command
< TODO_COMMENT
&& todo_command_info
[command
].c
)
1451 return todo_command_info
[command
].c
;
1452 return comment_line_char
;
1455 static int is_noop(const enum todo_command command
)
1457 return TODO_NOOP
<= command
;
1460 static int is_fixup(enum todo_command command
)
1462 return command
== TODO_FIXUP
|| command
== TODO_SQUASH
;
1465 /* Does this command create a (non-merge) commit? */
1466 static int is_pick_or_similar(enum todo_command command
)
1481 static int update_squash_messages(enum todo_command command
,
1482 struct commit
*commit
, struct replay_opts
*opts
)
1484 struct strbuf buf
= STRBUF_INIT
;
1486 const char *message
, *body
;
1488 if (opts
->current_fixup_count
> 0) {
1489 struct strbuf header
= STRBUF_INIT
;
1492 if (strbuf_read_file(&buf
, rebase_path_squash_msg(), 9) <= 0)
1493 return error(_("could not read '%s'"),
1494 rebase_path_squash_msg());
1496 eol
= buf
.buf
[0] != comment_line_char
?
1497 buf
.buf
: strchrnul(buf
.buf
, '\n');
1499 strbuf_addf(&header
, "%c ", comment_line_char
);
1500 strbuf_addf(&header
, _("This is a combination of %d commits."),
1501 opts
->current_fixup_count
+ 2);
1502 strbuf_splice(&buf
, 0, eol
- buf
.buf
, header
.buf
, header
.len
);
1503 strbuf_release(&header
);
1505 struct object_id head
;
1506 struct commit
*head_commit
;
1507 const char *head_message
, *body
;
1509 if (get_oid("HEAD", &head
))
1510 return error(_("need a HEAD to fixup"));
1511 if (!(head_commit
= lookup_commit_reference(&head
)))
1512 return error(_("could not read HEAD"));
1513 if (!(head_message
= get_commit_buffer(head_commit
, NULL
)))
1514 return error(_("could not read HEAD's commit message"));
1516 find_commit_subject(head_message
, &body
);
1517 if (write_message(body
, strlen(body
),
1518 rebase_path_fixup_msg(), 0)) {
1519 unuse_commit_buffer(head_commit
, head_message
);
1520 return error(_("cannot write '%s'"),
1521 rebase_path_fixup_msg());
1524 strbuf_addf(&buf
, "%c ", comment_line_char
);
1525 strbuf_addf(&buf
, _("This is a combination of %d commits."), 2);
1526 strbuf_addf(&buf
, "\n%c ", comment_line_char
);
1527 strbuf_addstr(&buf
, _("This is the 1st commit message:"));
1528 strbuf_addstr(&buf
, "\n\n");
1529 strbuf_addstr(&buf
, body
);
1531 unuse_commit_buffer(head_commit
, head_message
);
1534 if (!(message
= get_commit_buffer(commit
, NULL
)))
1535 return error(_("could not read commit message of %s"),
1536 oid_to_hex(&commit
->object
.oid
));
1537 find_commit_subject(message
, &body
);
1539 if (command
== TODO_SQUASH
) {
1540 unlink(rebase_path_fixup_msg());
1541 strbuf_addf(&buf
, "\n%c ", comment_line_char
);
1542 strbuf_addf(&buf
, _("This is the commit message #%d:"),
1543 ++opts
->current_fixup_count
);
1544 strbuf_addstr(&buf
, "\n\n");
1545 strbuf_addstr(&buf
, body
);
1546 } else if (command
== TODO_FIXUP
) {
1547 strbuf_addf(&buf
, "\n%c ", comment_line_char
);
1548 strbuf_addf(&buf
, _("The commit message #%d will be skipped:"),
1549 ++opts
->current_fixup_count
);
1550 strbuf_addstr(&buf
, "\n\n");
1551 strbuf_add_commented_lines(&buf
, body
, strlen(body
));
1553 return error(_("unknown command: %d"), command
);
1554 unuse_commit_buffer(commit
, message
);
1556 res
= write_message(buf
.buf
, buf
.len
, rebase_path_squash_msg(), 0);
1557 strbuf_release(&buf
);
1560 strbuf_addf(&opts
->current_fixups
, "%s%s %s",
1561 opts
->current_fixups
.len
? "\n" : "",
1562 command_to_string(command
),
1563 oid_to_hex(&commit
->object
.oid
));
1564 res
= write_message(opts
->current_fixups
.buf
,
1565 opts
->current_fixups
.len
,
1566 rebase_path_current_fixups(), 0);
1572 static void flush_rewritten_pending(void) {
1573 struct strbuf buf
= STRBUF_INIT
;
1574 struct object_id newoid
;
1577 if (strbuf_read_file(&buf
, rebase_path_rewritten_pending(), (GIT_MAX_HEXSZ
+ 1) * 2) > 0 &&
1578 !get_oid("HEAD", &newoid
) &&
1579 (out
= fopen_or_warn(rebase_path_rewritten_list(), "a"))) {
1580 char *bol
= buf
.buf
, *eol
;
1583 eol
= strchrnul(bol
, '\n');
1584 fprintf(out
, "%.*s %s\n", (int)(eol
- bol
),
1585 bol
, oid_to_hex(&newoid
));
1591 unlink(rebase_path_rewritten_pending());
1593 strbuf_release(&buf
);
1596 static void record_in_rewritten(struct object_id
*oid
,
1597 enum todo_command next_command
) {
1598 FILE *out
= fopen_or_warn(rebase_path_rewritten_pending(), "a");
1603 fprintf(out
, "%s\n", oid_to_hex(oid
));
1606 if (!is_fixup(next_command
))
1607 flush_rewritten_pending();
1610 static int do_pick_commit(enum todo_command command
, struct commit
*commit
,
1611 struct replay_opts
*opts
, int final_fixup
)
1613 unsigned int flags
= opts
->edit
? EDIT_MSG
: 0;
1614 const char *msg_file
= opts
->edit
? NULL
: git_path_merge_msg();
1615 struct object_id head
;
1616 struct commit
*base
, *next
, *parent
;
1617 const char *base_label
, *next_label
;
1618 char *author
= NULL
;
1619 struct commit_message msg
= { NULL
, NULL
, NULL
, NULL
};
1620 struct strbuf msgbuf
= STRBUF_INIT
;
1621 int res
, unborn
= 0, allow
;
1623 if (opts
->no_commit
) {
1625 * We do not intend to commit immediately. We just want to
1626 * merge the differences in, so let's compute the tree
1627 * that represents the "current" state for merge-recursive
1630 if (write_cache_as_tree(&head
, 0, NULL
))
1631 return error(_("your index file is unmerged."));
1633 unborn
= get_oid("HEAD", &head
);
1634 /* Do we want to generate a root commit? */
1635 if (is_pick_or_similar(command
) && opts
->have_squash_onto
&&
1636 !oidcmp(&head
, &opts
->squash_onto
)) {
1637 if (is_fixup(command
))
1638 return error(_("cannot fixup root commit"));
1639 flags
|= CREATE_ROOT_COMMIT
;
1642 oidcpy(&head
, the_hash_algo
->empty_tree
);
1643 if (index_differs_from(unborn
? empty_tree_oid_hex() : "HEAD",
1645 return error_dirty_index(opts
);
1649 if (!commit
->parents
)
1651 else if (commit
->parents
->next
) {
1652 /* Reverting or cherry-picking a merge commit */
1654 struct commit_list
*p
;
1656 if (!opts
->mainline
)
1657 return error(_("commit %s is a merge but no -m option was given."),
1658 oid_to_hex(&commit
->object
.oid
));
1660 for (cnt
= 1, p
= commit
->parents
;
1661 cnt
!= opts
->mainline
&& p
;
1664 if (cnt
!= opts
->mainline
|| !p
)
1665 return error(_("commit %s does not have parent %d"),
1666 oid_to_hex(&commit
->object
.oid
), opts
->mainline
);
1668 } else if (0 < opts
->mainline
)
1669 return error(_("mainline was specified but commit %s is not a merge."),
1670 oid_to_hex(&commit
->object
.oid
));
1672 parent
= commit
->parents
->item
;
1674 if (get_message(commit
, &msg
) != 0)
1675 return error(_("cannot get commit message for %s"),
1676 oid_to_hex(&commit
->object
.oid
));
1678 if (opts
->allow_ff
&& !is_fixup(command
) &&
1679 ((parent
&& !oidcmp(&parent
->object
.oid
, &head
)) ||
1680 (!parent
&& unborn
))) {
1681 if (is_rebase_i(opts
))
1682 write_author_script(msg
.message
);
1683 res
= fast_forward_to(&commit
->object
.oid
, &head
, unborn
,
1685 if (res
|| command
!= TODO_REWORD
)
1687 flags
|= EDIT_MSG
| AMEND_MSG
| VERIFY_MSG
;
1689 goto fast_forward_edit
;
1691 if (parent
&& parse_commit(parent
) < 0)
1692 /* TRANSLATORS: The first %s will be a "todo" command like
1693 "revert" or "pick", the second %s a SHA1. */
1694 return error(_("%s: cannot parse parent commit %s"),
1695 command_to_string(command
),
1696 oid_to_hex(&parent
->object
.oid
));
1699 * "commit" is an existing commit. We would want to apply
1700 * the difference it introduces since its first parent "prev"
1701 * on top of the current HEAD if we are cherry-pick. Or the
1702 * reverse of it if we are revert.
1705 if (command
== TODO_REVERT
) {
1707 base_label
= msg
.label
;
1709 next_label
= msg
.parent_label
;
1710 strbuf_addstr(&msgbuf
, "Revert \"");
1711 strbuf_addstr(&msgbuf
, msg
.subject
);
1712 strbuf_addstr(&msgbuf
, "\"\n\nThis reverts commit ");
1713 strbuf_addstr(&msgbuf
, oid_to_hex(&commit
->object
.oid
));
1715 if (commit
->parents
&& commit
->parents
->next
) {
1716 strbuf_addstr(&msgbuf
, ", reversing\nchanges made to ");
1717 strbuf_addstr(&msgbuf
, oid_to_hex(&parent
->object
.oid
));
1719 strbuf_addstr(&msgbuf
, ".\n");
1724 base_label
= msg
.parent_label
;
1726 next_label
= msg
.label
;
1728 /* Append the commit log message to msgbuf. */
1729 if (find_commit_subject(msg
.message
, &p
))
1730 strbuf_addstr(&msgbuf
, p
);
1732 if (opts
->record_origin
) {
1733 strbuf_complete_line(&msgbuf
);
1734 if (!has_conforming_footer(&msgbuf
, NULL
, 0))
1735 strbuf_addch(&msgbuf
, '\n');
1736 strbuf_addstr(&msgbuf
, cherry_picked_prefix
);
1737 strbuf_addstr(&msgbuf
, oid_to_hex(&commit
->object
.oid
));
1738 strbuf_addstr(&msgbuf
, ")\n");
1740 if (!is_fixup(command
))
1741 author
= get_author(msg
.message
);
1744 if (command
== TODO_REWORD
)
1745 flags
|= EDIT_MSG
| VERIFY_MSG
;
1746 else if (is_fixup(command
)) {
1747 if (update_squash_messages(command
, commit
, opts
))
1751 msg_file
= rebase_path_squash_msg();
1752 else if (file_exists(rebase_path_fixup_msg())) {
1753 flags
|= CLEANUP_MSG
;
1754 msg_file
= rebase_path_fixup_msg();
1756 const char *dest
= git_path_squash_msg();
1758 if (copy_file(dest
, rebase_path_squash_msg(), 0666))
1759 return error(_("could not rename '%s' to '%s'"),
1760 rebase_path_squash_msg(), dest
);
1761 unlink(git_path_merge_msg());
1767 if (opts
->signoff
&& !is_fixup(command
))
1768 append_signoff(&msgbuf
, 0, 0);
1770 if (is_rebase_i(opts
) && write_author_script(msg
.message
) < 0)
1772 else if (!opts
->strategy
|| !strcmp(opts
->strategy
, "recursive") || command
== TODO_REVERT
) {
1773 res
= do_recursive_merge(base
, next
, base_label
, next_label
,
1774 &head
, &msgbuf
, opts
);
1777 res
|= write_message(msgbuf
.buf
, msgbuf
.len
,
1778 git_path_merge_msg(), 0);
1780 struct commit_list
*common
= NULL
;
1781 struct commit_list
*remotes
= NULL
;
1783 res
= write_message(msgbuf
.buf
, msgbuf
.len
,
1784 git_path_merge_msg(), 0);
1786 commit_list_insert(base
, &common
);
1787 commit_list_insert(next
, &remotes
);
1788 res
|= try_merge_command(opts
->strategy
,
1789 opts
->xopts_nr
, (const char **)opts
->xopts
,
1790 common
, oid_to_hex(&head
), remotes
);
1791 free_commit_list(common
);
1792 free_commit_list(remotes
);
1794 strbuf_release(&msgbuf
);
1797 * If the merge was clean or if it failed due to conflict, we write
1798 * CHERRY_PICK_HEAD for the subsequent invocation of commit to use.
1799 * However, if the merge did not even start, then we don't want to
1802 if (command
== TODO_PICK
&& !opts
->no_commit
&& (res
== 0 || res
== 1) &&
1803 update_ref(NULL
, "CHERRY_PICK_HEAD", &commit
->object
.oid
, NULL
,
1804 REF_NO_DEREF
, UPDATE_REFS_MSG_ON_ERR
))
1806 if (command
== TODO_REVERT
&& ((opts
->no_commit
&& res
== 0) || res
== 1) &&
1807 update_ref(NULL
, "REVERT_HEAD", &commit
->object
.oid
, NULL
,
1808 REF_NO_DEREF
, UPDATE_REFS_MSG_ON_ERR
))
1812 error(command
== TODO_REVERT
1813 ? _("could not revert %s... %s")
1814 : _("could not apply %s... %s"),
1815 short_commit_name(commit
), msg
.subject
);
1816 print_advice(res
== 1, opts
);
1817 rerere(opts
->allow_rerere_auto
);
1821 allow
= allow_empty(opts
, commit
);
1826 flags
|= ALLOW_EMPTY
;
1827 if (!opts
->no_commit
) {
1829 if (author
|| command
== TODO_REVERT
|| (flags
& AMEND_MSG
))
1830 res
= do_commit(msg_file
, author
, opts
, flags
);
1832 res
= error(_("unable to parse commit author"));
1835 if (!res
&& final_fixup
) {
1836 unlink(rebase_path_fixup_msg());
1837 unlink(rebase_path_squash_msg());
1838 unlink(rebase_path_current_fixups());
1839 strbuf_reset(&opts
->current_fixups
);
1840 opts
->current_fixup_count
= 0;
1844 free_message(commit
, &msg
);
1846 update_abort_safety_file();
1851 static int prepare_revs(struct replay_opts
*opts
)
1854 * picking (but not reverting) ranges (but not individual revisions)
1855 * should be done in reverse
1857 if (opts
->action
== REPLAY_PICK
&& !opts
->revs
->no_walk
)
1858 opts
->revs
->reverse
^= 1;
1860 if (prepare_revision_walk(opts
->revs
))
1861 return error(_("revision walk setup failed"));
1863 if (!opts
->revs
->commits
)
1864 return error(_("empty commit set passed"));
1868 static int read_and_refresh_cache(struct replay_opts
*opts
)
1870 struct lock_file index_lock
= LOCK_INIT
;
1871 int index_fd
= hold_locked_index(&index_lock
, 0);
1872 if (read_index_preload(&the_index
, NULL
) < 0) {
1873 rollback_lock_file(&index_lock
);
1874 return error(_("git %s: failed to read the index"),
1875 _(action_name(opts
)));
1877 refresh_index(&the_index
, REFRESH_QUIET
|REFRESH_UNMERGED
, NULL
, NULL
, NULL
);
1878 if (index_fd
>= 0) {
1879 if (write_locked_index(&the_index
, &index_lock
,
1880 COMMIT_LOCK
| SKIP_IF_UNCHANGED
)) {
1881 return error(_("git %s: failed to refresh the index"),
1882 _(action_name(opts
)));
1888 enum todo_item_flags
{
1889 TODO_EDIT_MERGE_MSG
= 1
1893 enum todo_command command
;
1894 struct commit
*commit
;
1898 size_t offset_in_buf
;
1903 struct todo_item
*items
;
1904 int nr
, alloc
, current
;
1905 int done_nr
, total_nr
;
1906 struct stat_data stat
;
1909 #define TODO_LIST_INIT { STRBUF_INIT }
1911 static void todo_list_release(struct todo_list
*todo_list
)
1913 strbuf_release(&todo_list
->buf
);
1914 FREE_AND_NULL(todo_list
->items
);
1915 todo_list
->nr
= todo_list
->alloc
= 0;
1918 static struct todo_item
*append_new_todo(struct todo_list
*todo_list
)
1920 ALLOC_GROW(todo_list
->items
, todo_list
->nr
+ 1, todo_list
->alloc
);
1921 return todo_list
->items
+ todo_list
->nr
++;
1924 static int parse_insn_line(struct todo_item
*item
, const char *bol
, char *eol
)
1926 struct object_id commit_oid
;
1927 char *end_of_object_name
;
1928 int i
, saved
, status
, padding
;
1933 bol
+= strspn(bol
, " \t");
1935 if (bol
== eol
|| *bol
== '\r' || *bol
== comment_line_char
) {
1936 item
->command
= TODO_COMMENT
;
1937 item
->commit
= NULL
;
1939 item
->arg_len
= eol
- bol
;
1943 for (i
= 0; i
< TODO_COMMENT
; i
++)
1944 if (skip_prefix(bol
, todo_command_info
[i
].str
, &bol
)) {
1947 } else if (bol
[1] == ' ' && *bol
== todo_command_info
[i
].c
) {
1952 if (i
>= TODO_COMMENT
)
1955 /* Eat up extra spaces/ tabs before object name */
1956 padding
= strspn(bol
, " \t");
1959 if (item
->command
== TODO_NOOP
) {
1961 return error(_("%s does not accept arguments: '%s'"),
1962 command_to_string(item
->command
), bol
);
1963 item
->commit
= NULL
;
1965 item
->arg_len
= eol
- bol
;
1970 return error(_("missing arguments for %s"),
1971 command_to_string(item
->command
));
1973 if (item
->command
== TODO_EXEC
|| item
->command
== TODO_LABEL
||
1974 item
->command
== TODO_RESET
) {
1975 item
->commit
= NULL
;
1977 item
->arg_len
= (int)(eol
- bol
);
1981 if (item
->command
== TODO_MERGE
) {
1982 if (skip_prefix(bol
, "-C", &bol
))
1983 bol
+= strspn(bol
, " \t");
1984 else if (skip_prefix(bol
, "-c", &bol
)) {
1985 bol
+= strspn(bol
, " \t");
1986 item
->flags
|= TODO_EDIT_MERGE_MSG
;
1988 item
->flags
|= TODO_EDIT_MERGE_MSG
;
1989 item
->commit
= NULL
;
1991 item
->arg_len
= (int)(eol
- bol
);
1996 end_of_object_name
= (char *) bol
+ strcspn(bol
, " \t\n");
1997 saved
= *end_of_object_name
;
1998 *end_of_object_name
= '\0';
1999 status
= get_oid(bol
, &commit_oid
);
2000 *end_of_object_name
= saved
;
2002 item
->arg
= end_of_object_name
+ strspn(end_of_object_name
, " \t");
2003 item
->arg_len
= (int)(eol
- item
->arg
);
2008 item
->commit
= lookup_commit_reference(&commit_oid
);
2009 return !item
->commit
;
2012 static int parse_insn_buffer(char *buf
, struct todo_list
*todo_list
)
2014 struct todo_item
*item
;
2015 char *p
= buf
, *next_p
;
2016 int i
, res
= 0, fixup_okay
= file_exists(rebase_path_done());
2018 for (i
= 1; *p
; i
++, p
= next_p
) {
2019 char *eol
= strchrnul(p
, '\n');
2021 next_p
= *eol
? eol
+ 1 /* skip LF */ : eol
;
2023 if (p
!= eol
&& eol
[-1] == '\r')
2024 eol
--; /* strip Carriage Return */
2026 item
= append_new_todo(todo_list
);
2027 item
->offset_in_buf
= p
- todo_list
->buf
.buf
;
2028 if (parse_insn_line(item
, p
, eol
)) {
2029 res
= error(_("invalid line %d: %.*s"),
2030 i
, (int)(eol
- p
), p
);
2031 item
->command
= TODO_NOOP
;
2036 else if (is_fixup(item
->command
))
2037 return error(_("cannot '%s' without a previous commit"),
2038 command_to_string(item
->command
));
2039 else if (!is_noop(item
->command
))
2046 static int count_commands(struct todo_list
*todo_list
)
2050 for (i
= 0; i
< todo_list
->nr
; i
++)
2051 if (todo_list
->items
[i
].command
!= TODO_COMMENT
)
2057 static int get_item_line_offset(struct todo_list
*todo_list
, int index
)
2059 return index
< todo_list
->nr
?
2060 todo_list
->items
[index
].offset_in_buf
: todo_list
->buf
.len
;
2063 static const char *get_item_line(struct todo_list
*todo_list
, int index
)
2065 return todo_list
->buf
.buf
+ get_item_line_offset(todo_list
, index
);
2068 static int get_item_line_length(struct todo_list
*todo_list
, int index
)
2070 return get_item_line_offset(todo_list
, index
+ 1)
2071 - get_item_line_offset(todo_list
, index
);
2074 static ssize_t
strbuf_read_file_or_whine(struct strbuf
*sb
, const char *path
)
2079 fd
= open(path
, O_RDONLY
);
2081 return error_errno(_("could not open '%s'"), path
);
2082 len
= strbuf_read(sb
, fd
, 0);
2085 return error(_("could not read '%s'."), path
);
2089 static int read_populate_todo(struct todo_list
*todo_list
,
2090 struct replay_opts
*opts
)
2093 const char *todo_file
= get_todo_path(opts
);
2096 strbuf_reset(&todo_list
->buf
);
2097 if (strbuf_read_file_or_whine(&todo_list
->buf
, todo_file
) < 0)
2100 res
= stat(todo_file
, &st
);
2102 return error(_("could not stat '%s'"), todo_file
);
2103 fill_stat_data(&todo_list
->stat
, &st
);
2105 res
= parse_insn_buffer(todo_list
->buf
.buf
, todo_list
);
2107 if (is_rebase_i(opts
))
2108 return error(_("please fix this using "
2109 "'git rebase --edit-todo'."));
2110 return error(_("unusable instruction sheet: '%s'"), todo_file
);
2113 if (!todo_list
->nr
&&
2114 (!is_rebase_i(opts
) || !file_exists(rebase_path_done())))
2115 return error(_("no commits parsed."));
2117 if (!is_rebase_i(opts
)) {
2118 enum todo_command valid
=
2119 opts
->action
== REPLAY_PICK
? TODO_PICK
: TODO_REVERT
;
2122 for (i
= 0; i
< todo_list
->nr
; i
++)
2123 if (valid
== todo_list
->items
[i
].command
)
2125 else if (valid
== TODO_PICK
)
2126 return error(_("cannot cherry-pick during a revert."));
2128 return error(_("cannot revert during a cherry-pick."));
2131 if (is_rebase_i(opts
)) {
2132 struct todo_list done
= TODO_LIST_INIT
;
2133 FILE *f
= fopen_or_warn(rebase_path_msgtotal(), "w");
2135 if (strbuf_read_file(&done
.buf
, rebase_path_done(), 0) > 0 &&
2136 !parse_insn_buffer(done
.buf
.buf
, &done
))
2137 todo_list
->done_nr
= count_commands(&done
);
2139 todo_list
->done_nr
= 0;
2141 todo_list
->total_nr
= todo_list
->done_nr
2142 + count_commands(todo_list
);
2143 todo_list_release(&done
);
2146 fprintf(f
, "%d\n", todo_list
->total_nr
);
2154 static int git_config_string_dup(char **dest
,
2155 const char *var
, const char *value
)
2158 return config_error_nonbool(var
);
2160 *dest
= xstrdup(value
);
2164 static int populate_opts_cb(const char *key
, const char *value
, void *data
)
2166 struct replay_opts
*opts
= data
;
2171 else if (!strcmp(key
, "options.no-commit"))
2172 opts
->no_commit
= git_config_bool_or_int(key
, value
, &error_flag
);
2173 else if (!strcmp(key
, "options.edit"))
2174 opts
->edit
= git_config_bool_or_int(key
, value
, &error_flag
);
2175 else if (!strcmp(key
, "options.signoff"))
2176 opts
->signoff
= git_config_bool_or_int(key
, value
, &error_flag
);
2177 else if (!strcmp(key
, "options.record-origin"))
2178 opts
->record_origin
= git_config_bool_or_int(key
, value
, &error_flag
);
2179 else if (!strcmp(key
, "options.allow-ff"))
2180 opts
->allow_ff
= git_config_bool_or_int(key
, value
, &error_flag
);
2181 else if (!strcmp(key
, "options.mainline"))
2182 opts
->mainline
= git_config_int(key
, value
);
2183 else if (!strcmp(key
, "options.strategy"))
2184 git_config_string_dup(&opts
->strategy
, key
, value
);
2185 else if (!strcmp(key
, "options.gpg-sign"))
2186 git_config_string_dup(&opts
->gpg_sign
, key
, value
);
2187 else if (!strcmp(key
, "options.strategy-option")) {
2188 ALLOC_GROW(opts
->xopts
, opts
->xopts_nr
+ 1, opts
->xopts_alloc
);
2189 opts
->xopts
[opts
->xopts_nr
++] = xstrdup(value
);
2190 } else if (!strcmp(key
, "options.allow-rerere-auto"))
2191 opts
->allow_rerere_auto
=
2192 git_config_bool_or_int(key
, value
, &error_flag
) ?
2193 RERERE_AUTOUPDATE
: RERERE_NOAUTOUPDATE
;
2195 return error(_("invalid key: %s"), key
);
2198 return error(_("invalid value for %s: %s"), key
, value
);
2203 static void read_strategy_opts(struct replay_opts
*opts
, struct strbuf
*buf
)
2208 if (!read_oneliner(buf
, rebase_path_strategy(), 0))
2210 opts
->strategy
= strbuf_detach(buf
, NULL
);
2211 if (!read_oneliner(buf
, rebase_path_strategy_opts(), 0))
2214 opts
->xopts_nr
= split_cmdline(buf
->buf
, (const char ***)&opts
->xopts
);
2215 for (i
= 0; i
< opts
->xopts_nr
; i
++) {
2216 const char *arg
= opts
->xopts
[i
];
2218 skip_prefix(arg
, "--", &arg
);
2219 opts
->xopts
[i
] = xstrdup(arg
);
2223 static int read_populate_opts(struct replay_opts
*opts
)
2225 if (is_rebase_i(opts
)) {
2226 struct strbuf buf
= STRBUF_INIT
;
2228 if (read_oneliner(&buf
, rebase_path_gpg_sign_opt(), 1)) {
2229 if (!starts_with(buf
.buf
, "-S"))
2232 free(opts
->gpg_sign
);
2233 opts
->gpg_sign
= xstrdup(buf
.buf
+ 2);
2238 if (read_oneliner(&buf
, rebase_path_allow_rerere_autoupdate(), 1)) {
2239 if (!strcmp(buf
.buf
, "--rerere-autoupdate"))
2240 opts
->allow_rerere_auto
= RERERE_AUTOUPDATE
;
2241 else if (!strcmp(buf
.buf
, "--no-rerere-autoupdate"))
2242 opts
->allow_rerere_auto
= RERERE_NOAUTOUPDATE
;
2246 if (file_exists(rebase_path_verbose()))
2249 if (file_exists(rebase_path_signoff())) {
2254 read_strategy_opts(opts
, &buf
);
2255 strbuf_release(&buf
);
2257 if (read_oneliner(&opts
->current_fixups
,
2258 rebase_path_current_fixups(), 1)) {
2259 const char *p
= opts
->current_fixups
.buf
;
2260 opts
->current_fixup_count
= 1;
2261 while ((p
= strchr(p
, '\n'))) {
2262 opts
->current_fixup_count
++;
2267 if (read_oneliner(&buf
, rebase_path_squash_onto(), 0)) {
2268 if (get_oid_hex(buf
.buf
, &opts
->squash_onto
) < 0)
2269 return error(_("unusable squash-onto"));
2270 opts
->have_squash_onto
= 1;
2276 if (!file_exists(git_path_opts_file()))
2279 * The function git_parse_source(), called from git_config_from_file(),
2280 * may die() in case of a syntactically incorrect file. We do not care
2281 * about this case, though, because we wrote that file ourselves, so we
2282 * are pretty certain that it is syntactically correct.
2284 if (git_config_from_file(populate_opts_cb
, git_path_opts_file(), opts
) < 0)
2285 return error(_("malformed options sheet: '%s'"),
2286 git_path_opts_file());
2290 static int walk_revs_populate_todo(struct todo_list
*todo_list
,
2291 struct replay_opts
*opts
)
2293 enum todo_command command
= opts
->action
== REPLAY_PICK
?
2294 TODO_PICK
: TODO_REVERT
;
2295 const char *command_string
= todo_command_info
[command
].str
;
2296 struct commit
*commit
;
2298 if (prepare_revs(opts
))
2301 while ((commit
= get_revision(opts
->revs
))) {
2302 struct todo_item
*item
= append_new_todo(todo_list
);
2303 const char *commit_buffer
= get_commit_buffer(commit
, NULL
);
2304 const char *subject
;
2307 item
->command
= command
;
2308 item
->commit
= commit
;
2311 item
->offset_in_buf
= todo_list
->buf
.len
;
2312 subject_len
= find_commit_subject(commit_buffer
, &subject
);
2313 strbuf_addf(&todo_list
->buf
, "%s %s %.*s\n", command_string
,
2314 short_commit_name(commit
), subject_len
, subject
);
2315 unuse_commit_buffer(commit
, commit_buffer
);
2320 static int create_seq_dir(void)
2322 if (file_exists(git_path_seq_dir())) {
2323 error(_("a cherry-pick or revert is already in progress"));
2324 advise(_("try \"git cherry-pick (--continue | --quit | --abort)\""));
2326 } else if (mkdir(git_path_seq_dir(), 0777) < 0)
2327 return error_errno(_("could not create sequencer directory '%s'"),
2328 git_path_seq_dir());
2332 static int save_head(const char *head
)
2334 struct lock_file head_lock
= LOCK_INIT
;
2335 struct strbuf buf
= STRBUF_INIT
;
2339 fd
= hold_lock_file_for_update(&head_lock
, git_path_head_file(), 0);
2341 return error_errno(_("could not lock HEAD"));
2342 strbuf_addf(&buf
, "%s\n", head
);
2343 written
= write_in_full(fd
, buf
.buf
, buf
.len
);
2344 strbuf_release(&buf
);
2346 error_errno(_("could not write to '%s'"), git_path_head_file());
2347 rollback_lock_file(&head_lock
);
2350 if (commit_lock_file(&head_lock
) < 0)
2351 return error(_("failed to finalize '%s'"), git_path_head_file());
2355 static int rollback_is_safe(void)
2357 struct strbuf sb
= STRBUF_INIT
;
2358 struct object_id expected_head
, actual_head
;
2360 if (strbuf_read_file(&sb
, git_path_abort_safety_file(), 0) >= 0) {
2362 if (get_oid_hex(sb
.buf
, &expected_head
)) {
2363 strbuf_release(&sb
);
2364 die(_("could not parse %s"), git_path_abort_safety_file());
2366 strbuf_release(&sb
);
2368 else if (errno
== ENOENT
)
2369 oidclr(&expected_head
);
2371 die_errno(_("could not read '%s'"), git_path_abort_safety_file());
2373 if (get_oid("HEAD", &actual_head
))
2374 oidclr(&actual_head
);
2376 return !oidcmp(&actual_head
, &expected_head
);
2379 static int reset_for_rollback(const struct object_id
*oid
)
2381 const char *argv
[4]; /* reset --merge <arg> + NULL */
2384 argv
[1] = "--merge";
2385 argv
[2] = oid_to_hex(oid
);
2387 return run_command_v_opt(argv
, RUN_GIT_CMD
);
2390 static int rollback_single_pick(void)
2392 struct object_id head_oid
;
2394 if (!file_exists(git_path_cherry_pick_head()) &&
2395 !file_exists(git_path_revert_head()))
2396 return error(_("no cherry-pick or revert in progress"));
2397 if (read_ref_full("HEAD", 0, &head_oid
, NULL
))
2398 return error(_("cannot resolve HEAD"));
2399 if (is_null_oid(&head_oid
))
2400 return error(_("cannot abort from a branch yet to be born"));
2401 return reset_for_rollback(&head_oid
);
2404 int sequencer_rollback(struct replay_opts
*opts
)
2407 struct object_id oid
;
2408 struct strbuf buf
= STRBUF_INIT
;
2411 f
= fopen(git_path_head_file(), "r");
2412 if (!f
&& errno
== ENOENT
) {
2414 * There is no multiple-cherry-pick in progress.
2415 * If CHERRY_PICK_HEAD or REVERT_HEAD indicates
2416 * a single-cherry-pick in progress, abort that.
2418 return rollback_single_pick();
2421 return error_errno(_("cannot open '%s'"), git_path_head_file());
2422 if (strbuf_getline_lf(&buf
, f
)) {
2423 error(_("cannot read '%s': %s"), git_path_head_file(),
2424 ferror(f
) ? strerror(errno
) : _("unexpected end of file"));
2429 if (parse_oid_hex(buf
.buf
, &oid
, &p
) || *p
!= '\0') {
2430 error(_("stored pre-cherry-pick HEAD file '%s' is corrupt"),
2431 git_path_head_file());
2434 if (is_null_oid(&oid
)) {
2435 error(_("cannot abort from a branch yet to be born"));
2439 if (!rollback_is_safe()) {
2440 /* Do not error, just do not rollback */
2441 warning(_("You seem to have moved HEAD. "
2442 "Not rewinding, check your HEAD!"));
2444 if (reset_for_rollback(&oid
))
2446 strbuf_release(&buf
);
2447 return sequencer_remove_state(opts
);
2449 strbuf_release(&buf
);
2453 static int save_todo(struct todo_list
*todo_list
, struct replay_opts
*opts
)
2455 struct lock_file todo_lock
= LOCK_INIT
;
2456 const char *todo_path
= get_todo_path(opts
);
2457 int next
= todo_list
->current
, offset
, fd
;
2460 * rebase -i writes "git-rebase-todo" without the currently executing
2461 * command, appending it to "done" instead.
2463 if (is_rebase_i(opts
))
2466 fd
= hold_lock_file_for_update(&todo_lock
, todo_path
, 0);
2468 return error_errno(_("could not lock '%s'"), todo_path
);
2469 offset
= get_item_line_offset(todo_list
, next
);
2470 if (write_in_full(fd
, todo_list
->buf
.buf
+ offset
,
2471 todo_list
->buf
.len
- offset
) < 0)
2472 return error_errno(_("could not write to '%s'"), todo_path
);
2473 if (commit_lock_file(&todo_lock
) < 0)
2474 return error(_("failed to finalize '%s'"), todo_path
);
2476 if (is_rebase_i(opts
) && next
> 0) {
2477 const char *done
= rebase_path_done();
2478 int fd
= open(done
, O_CREAT
| O_WRONLY
| O_APPEND
, 0666);
2483 if (write_in_full(fd
, get_item_line(todo_list
, next
- 1),
2484 get_item_line_length(todo_list
, next
- 1))
2486 ret
= error_errno(_("could not write to '%s'"), done
);
2488 ret
= error_errno(_("failed to finalize '%s'"), done
);
2494 static int save_opts(struct replay_opts
*opts
)
2496 const char *opts_file
= git_path_opts_file();
2499 if (opts
->no_commit
)
2500 res
|= git_config_set_in_file_gently(opts_file
, "options.no-commit", "true");
2502 res
|= git_config_set_in_file_gently(opts_file
, "options.edit", "true");
2504 res
|= git_config_set_in_file_gently(opts_file
, "options.signoff", "true");
2505 if (opts
->record_origin
)
2506 res
|= git_config_set_in_file_gently(opts_file
, "options.record-origin", "true");
2508 res
|= git_config_set_in_file_gently(opts_file
, "options.allow-ff", "true");
2509 if (opts
->mainline
) {
2510 struct strbuf buf
= STRBUF_INIT
;
2511 strbuf_addf(&buf
, "%d", opts
->mainline
);
2512 res
|= git_config_set_in_file_gently(opts_file
, "options.mainline", buf
.buf
);
2513 strbuf_release(&buf
);
2516 res
|= git_config_set_in_file_gently(opts_file
, "options.strategy", opts
->strategy
);
2518 res
|= git_config_set_in_file_gently(opts_file
, "options.gpg-sign", opts
->gpg_sign
);
2521 for (i
= 0; i
< opts
->xopts_nr
; i
++)
2522 res
|= git_config_set_multivar_in_file_gently(opts_file
,
2523 "options.strategy-option",
2524 opts
->xopts
[i
], "^$", 0);
2526 if (opts
->allow_rerere_auto
)
2527 res
|= git_config_set_in_file_gently(opts_file
, "options.allow-rerere-auto",
2528 opts
->allow_rerere_auto
== RERERE_AUTOUPDATE
?
2533 static int make_patch(struct commit
*commit
, struct replay_opts
*opts
)
2535 struct strbuf buf
= STRBUF_INIT
;
2536 struct rev_info log_tree_opt
;
2537 const char *subject
, *p
;
2540 p
= short_commit_name(commit
);
2541 if (write_message(p
, strlen(p
), rebase_path_stopped_sha(), 1) < 0)
2543 if (update_ref("rebase", "REBASE_HEAD", &commit
->object
.oid
,
2544 NULL
, REF_NO_DEREF
, UPDATE_REFS_MSG_ON_ERR
))
2545 res
|= error(_("could not update %s"), "REBASE_HEAD");
2547 strbuf_addf(&buf
, "%s/patch", get_dir(opts
));
2548 memset(&log_tree_opt
, 0, sizeof(log_tree_opt
));
2549 init_revisions(&log_tree_opt
, NULL
);
2550 log_tree_opt
.abbrev
= 0;
2551 log_tree_opt
.diff
= 1;
2552 log_tree_opt
.diffopt
.output_format
= DIFF_FORMAT_PATCH
;
2553 log_tree_opt
.disable_stdin
= 1;
2554 log_tree_opt
.no_commit_id
= 1;
2555 log_tree_opt
.diffopt
.file
= fopen(buf
.buf
, "w");
2556 log_tree_opt
.diffopt
.use_color
= GIT_COLOR_NEVER
;
2557 if (!log_tree_opt
.diffopt
.file
)
2558 res
|= error_errno(_("could not open '%s'"), buf
.buf
);
2560 res
|= log_tree_commit(&log_tree_opt
, commit
);
2561 fclose(log_tree_opt
.diffopt
.file
);
2565 strbuf_addf(&buf
, "%s/message", get_dir(opts
));
2566 if (!file_exists(buf
.buf
)) {
2567 const char *commit_buffer
= get_commit_buffer(commit
, NULL
);
2568 find_commit_subject(commit_buffer
, &subject
);
2569 res
|= write_message(subject
, strlen(subject
), buf
.buf
, 1);
2570 unuse_commit_buffer(commit
, commit_buffer
);
2572 strbuf_release(&buf
);
2577 static int intend_to_amend(void)
2579 struct object_id head
;
2582 if (get_oid("HEAD", &head
))
2583 return error(_("cannot read HEAD"));
2585 p
= oid_to_hex(&head
);
2586 return write_message(p
, strlen(p
), rebase_path_amend(), 1);
2589 static int error_with_patch(struct commit
*commit
,
2590 const char *subject
, int subject_len
,
2591 struct replay_opts
*opts
, int exit_code
, int to_amend
)
2593 if (make_patch(commit
, opts
))
2597 if (intend_to_amend())
2600 fprintf(stderr
, "You can amend the commit now, with\n"
2602 " git commit --amend %s\n"
2604 "Once you are satisfied with your changes, run\n"
2606 " git rebase --continue\n", gpg_sign_opt_quoted(opts
));
2607 } else if (exit_code
)
2608 fprintf(stderr
, "Could not apply %s... %.*s\n",
2609 short_commit_name(commit
), subject_len
, subject
);
2614 static int error_failed_squash(struct commit
*commit
,
2615 struct replay_opts
*opts
, int subject_len
, const char *subject
)
2617 if (copy_file(rebase_path_message(), rebase_path_squash_msg(), 0666))
2618 return error(_("could not copy '%s' to '%s'"),
2619 rebase_path_squash_msg(), rebase_path_message());
2620 unlink(git_path_merge_msg());
2621 if (copy_file(git_path_merge_msg(), rebase_path_message(), 0666))
2622 return error(_("could not copy '%s' to '%s'"),
2623 rebase_path_message(), git_path_merge_msg());
2624 return error_with_patch(commit
, subject
, subject_len
, opts
, 1, 0);
2627 static int do_exec(const char *command_line
)
2629 struct argv_array child_env
= ARGV_ARRAY_INIT
;
2630 const char *child_argv
[] = { NULL
, NULL
};
2633 fprintf(stderr
, "Executing: %s\n", command_line
);
2634 child_argv
[0] = command_line
;
2635 argv_array_pushf(&child_env
, "GIT_DIR=%s", absolute_path(get_git_dir()));
2636 status
= run_command_v_opt_cd_env(child_argv
, RUN_USING_SHELL
, NULL
,
2639 /* force re-reading of the cache */
2640 if (discard_cache() < 0 || read_cache() < 0)
2641 return error(_("could not read index"));
2643 dirty
= require_clean_work_tree("rebase", NULL
, 1, 1);
2646 warning(_("execution failed: %s\n%s"
2647 "You can fix the problem, and then run\n"
2649 " git rebase --continue\n"
2652 dirty
? N_("and made changes to the index and/or the "
2653 "working tree\n") : "");
2655 /* command not found */
2658 warning(_("execution succeeded: %s\nbut "
2659 "left changes to the index and/or the working tree\n"
2660 "Commit or stash your changes, and then run\n"
2662 " git rebase --continue\n"
2663 "\n"), command_line
);
2667 argv_array_clear(&child_env
);
2672 static int safe_append(const char *filename
, const char *fmt
, ...)
2675 struct lock_file lock
= LOCK_INIT
;
2676 int fd
= hold_lock_file_for_update(&lock
, filename
,
2677 LOCK_REPORT_ON_ERROR
);
2678 struct strbuf buf
= STRBUF_INIT
;
2683 if (strbuf_read_file(&buf
, filename
, 0) < 0 && errno
!= ENOENT
) {
2684 error_errno(_("could not read '%s'"), filename
);
2685 rollback_lock_file(&lock
);
2688 strbuf_complete(&buf
, '\n');
2690 strbuf_vaddf(&buf
, fmt
, ap
);
2693 if (write_in_full(fd
, buf
.buf
, buf
.len
) < 0) {
2694 error_errno(_("could not write to '%s'"), filename
);
2695 strbuf_release(&buf
);
2696 rollback_lock_file(&lock
);
2699 if (commit_lock_file(&lock
) < 0) {
2700 strbuf_release(&buf
);
2701 rollback_lock_file(&lock
);
2702 return error(_("failed to finalize '%s'"), filename
);
2705 strbuf_release(&buf
);
2709 static int do_label(const char *name
, int len
)
2711 struct ref_store
*refs
= get_main_ref_store(the_repository
);
2712 struct ref_transaction
*transaction
;
2713 struct strbuf ref_name
= STRBUF_INIT
, err
= STRBUF_INIT
;
2714 struct strbuf msg
= STRBUF_INIT
;
2716 struct object_id head_oid
;
2718 if (len
== 1 && *name
== '#')
2719 return error("Illegal label name: '%.*s'", len
, name
);
2721 strbuf_addf(&ref_name
, "refs/rewritten/%.*s", len
, name
);
2722 strbuf_addf(&msg
, "rebase -i (label) '%.*s'", len
, name
);
2724 transaction
= ref_store_transaction_begin(refs
, &err
);
2726 error("%s", err
.buf
);
2728 } else if (get_oid("HEAD", &head_oid
)) {
2729 error(_("could not read HEAD"));
2731 } else if (ref_transaction_update(transaction
, ref_name
.buf
, &head_oid
,
2732 NULL
, 0, msg
.buf
, &err
) < 0 ||
2733 ref_transaction_commit(transaction
, &err
)) {
2734 error("%s", err
.buf
);
2737 ref_transaction_free(transaction
);
2738 strbuf_release(&err
);
2739 strbuf_release(&msg
);
2742 ret
= safe_append(rebase_path_refs_to_delete(),
2743 "%s\n", ref_name
.buf
);
2744 strbuf_release(&ref_name
);
2749 static const char *reflog_message(struct replay_opts
*opts
,
2750 const char *sub_action
, const char *fmt
, ...);
2752 static int do_reset(const char *name
, int len
, struct replay_opts
*opts
)
2754 struct strbuf ref_name
= STRBUF_INIT
;
2755 struct object_id oid
;
2756 struct lock_file lock
= LOCK_INIT
;
2757 struct tree_desc desc
;
2759 struct unpack_trees_options unpack_tree_opts
;
2762 if (hold_locked_index(&lock
, LOCK_REPORT_ON_ERROR
) < 0)
2765 if (len
== 10 && !strncmp("[new root]", name
, len
)) {
2766 if (!opts
->have_squash_onto
) {
2768 if (commit_tree("", 0, the_hash_algo
->empty_tree
,
2769 NULL
, &opts
->squash_onto
,
2771 return error(_("writing fake root commit"));
2772 opts
->have_squash_onto
= 1;
2773 hex
= oid_to_hex(&opts
->squash_onto
);
2774 if (write_message(hex
, strlen(hex
),
2775 rebase_path_squash_onto(), 0))
2776 return error(_("writing squash-onto"));
2778 oidcpy(&oid
, &opts
->squash_onto
);
2780 /* Determine the length of the label */
2781 for (i
= 0; i
< len
; i
++)
2782 if (isspace(name
[i
]))
2785 strbuf_addf(&ref_name
, "refs/rewritten/%.*s", len
, name
);
2786 if (get_oid(ref_name
.buf
, &oid
) &&
2787 get_oid(ref_name
.buf
+ strlen("refs/rewritten/"), &oid
)) {
2788 error(_("could not read '%s'"), ref_name
.buf
);
2789 rollback_lock_file(&lock
);
2790 strbuf_release(&ref_name
);
2795 memset(&unpack_tree_opts
, 0, sizeof(unpack_tree_opts
));
2796 setup_unpack_trees_porcelain(&unpack_tree_opts
, "reset");
2797 unpack_tree_opts
.head_idx
= 1;
2798 unpack_tree_opts
.src_index
= &the_index
;
2799 unpack_tree_opts
.dst_index
= &the_index
;
2800 unpack_tree_opts
.fn
= oneway_merge
;
2801 unpack_tree_opts
.merge
= 1;
2802 unpack_tree_opts
.update
= 1;
2804 if (read_cache_unmerged()) {
2805 rollback_lock_file(&lock
);
2806 strbuf_release(&ref_name
);
2807 return error_resolve_conflict(_(action_name(opts
)));
2810 if (!fill_tree_descriptor(&desc
, &oid
)) {
2811 error(_("failed to find tree of %s"), oid_to_hex(&oid
));
2812 rollback_lock_file(&lock
);
2813 free((void *)desc
.buffer
);
2814 strbuf_release(&ref_name
);
2818 if (unpack_trees(1, &desc
, &unpack_tree_opts
)) {
2819 rollback_lock_file(&lock
);
2820 free((void *)desc
.buffer
);
2821 strbuf_release(&ref_name
);
2825 tree
= parse_tree_indirect(&oid
);
2826 prime_cache_tree(&the_index
, tree
);
2828 if (write_locked_index(&the_index
, &lock
, COMMIT_LOCK
) < 0)
2829 ret
= error(_("could not write index"));
2830 free((void *)desc
.buffer
);
2833 ret
= update_ref(reflog_message(opts
, "reset", "'%.*s'",
2834 len
, name
), "HEAD", &oid
,
2835 NULL
, 0, UPDATE_REFS_MSG_ON_ERR
);
2837 strbuf_release(&ref_name
);
2841 static int do_merge(struct commit
*commit
, const char *arg
, int arg_len
,
2842 int flags
, struct replay_opts
*opts
)
2844 int run_commit_flags
= (flags
& TODO_EDIT_MERGE_MSG
) ?
2845 EDIT_MSG
| VERIFY_MSG
: 0;
2846 struct strbuf ref_name
= STRBUF_INIT
;
2847 struct commit
*head_commit
, *merge_commit
, *i
;
2848 struct commit_list
*bases
, *j
, *reversed
= NULL
;
2849 struct merge_options o
;
2850 int merge_arg_len
, oneline_offset
, can_fast_forward
, ret
;
2851 static struct lock_file lock
;
2854 if (hold_locked_index(&lock
, LOCK_REPORT_ON_ERROR
) < 0) {
2859 head_commit
= lookup_commit_reference_by_name("HEAD");
2861 ret
= error(_("cannot merge without a current revision"));
2865 oneline_offset
= arg_len
;
2866 merge_arg_len
= strcspn(arg
, " \t\n");
2867 p
= arg
+ merge_arg_len
;
2868 p
+= strspn(p
, " \t\n");
2869 if (*p
== '#' && (!p
[1] || isspace(p
[1]))) {
2870 p
+= 1 + strspn(p
+ 1, " \t\n");
2871 oneline_offset
= p
- arg
;
2872 } else if (p
- arg
< arg_len
)
2873 BUG("octopus merges are not supported yet: '%s'", p
);
2875 strbuf_addf(&ref_name
, "refs/rewritten/%.*s", merge_arg_len
, arg
);
2876 merge_commit
= lookup_commit_reference_by_name(ref_name
.buf
);
2877 if (!merge_commit
) {
2878 /* fall back to non-rewritten ref or commit */
2879 strbuf_splice(&ref_name
, 0, strlen("refs/rewritten/"), "", 0);
2880 merge_commit
= lookup_commit_reference_by_name(ref_name
.buf
);
2883 if (!merge_commit
) {
2884 ret
= error(_("could not resolve '%s'"), ref_name
.buf
);
2888 if (opts
->have_squash_onto
&&
2889 !oidcmp(&head_commit
->object
.oid
, &opts
->squash_onto
)) {
2891 * When the user tells us to "merge" something into a
2892 * "[new root]", let's simply fast-forward to the merge head.
2894 rollback_lock_file(&lock
);
2895 ret
= fast_forward_to(&merge_commit
->object
.oid
,
2896 &head_commit
->object
.oid
, 0, opts
);
2901 const char *message
= get_commit_buffer(commit
, NULL
);
2906 ret
= error(_("could not get commit message of '%s'"),
2907 oid_to_hex(&commit
->object
.oid
));
2910 write_author_script(message
);
2911 find_commit_subject(message
, &body
);
2913 ret
= write_message(body
, len
, git_path_merge_msg(), 0);
2914 unuse_commit_buffer(commit
, message
);
2916 error_errno(_("could not write '%s'"),
2917 git_path_merge_msg());
2921 struct strbuf buf
= STRBUF_INIT
;
2924 strbuf_addf(&buf
, "author %s", git_author_info(0));
2925 write_author_script(buf
.buf
);
2928 if (oneline_offset
< arg_len
) {
2929 p
= arg
+ oneline_offset
;
2930 len
= arg_len
- oneline_offset
;
2932 strbuf_addf(&buf
, "Merge branch '%.*s'",
2933 merge_arg_len
, arg
);
2938 ret
= write_message(p
, len
, git_path_merge_msg(), 0);
2939 strbuf_release(&buf
);
2941 error_errno(_("could not write '%s'"),
2942 git_path_merge_msg());
2948 * If HEAD is not identical to the first parent of the original merge
2949 * commit, we cannot fast-forward.
2951 can_fast_forward
= opts
->allow_ff
&& commit
&& commit
->parents
&&
2952 !oidcmp(&commit
->parents
->item
->object
.oid
,
2953 &head_commit
->object
.oid
);
2956 * If the merge head is different from the original one, we cannot
2959 if (can_fast_forward
) {
2960 struct commit_list
*second_parent
= commit
->parents
->next
;
2962 if (second_parent
&& !second_parent
->next
&&
2963 oidcmp(&merge_commit
->object
.oid
,
2964 &second_parent
->item
->object
.oid
))
2965 can_fast_forward
= 0;
2968 if (can_fast_forward
&& commit
->parents
->next
&&
2969 !commit
->parents
->next
->next
&&
2970 !oidcmp(&commit
->parents
->next
->item
->object
.oid
,
2971 &merge_commit
->object
.oid
)) {
2972 rollback_lock_file(&lock
);
2973 ret
= fast_forward_to(&commit
->object
.oid
,
2974 &head_commit
->object
.oid
, 0, opts
);
2978 write_message(oid_to_hex(&merge_commit
->object
.oid
), GIT_SHA1_HEXSZ
,
2979 git_path_merge_head(), 0);
2980 write_message("no-ff", 5, git_path_merge_mode(), 0);
2982 bases
= get_merge_bases(head_commit
, merge_commit
);
2983 if (bases
&& !oidcmp(&merge_commit
->object
.oid
,
2984 &bases
->item
->object
.oid
)) {
2986 /* skip merging an ancestor of HEAD */
2990 for (j
= bases
; j
; j
= j
->next
)
2991 commit_list_insert(j
->item
, &reversed
);
2992 free_commit_list(bases
);
2995 init_merge_options(&o
);
2997 o
.branch2
= ref_name
.buf
;
2998 o
.buffer_output
= 2;
3000 ret
= merge_recursive(&o
, head_commit
, merge_commit
, reversed
, &i
);
3002 fputs(o
.obuf
.buf
, stdout
);
3003 strbuf_release(&o
.obuf
);
3005 error(_("could not even attempt to merge '%.*s'"),
3006 merge_arg_len
, arg
);
3010 * The return value of merge_recursive() is 1 on clean, and 0 on
3013 * Let's reverse that, so that do_merge() returns 0 upon success and
3014 * 1 upon failed merge (keeping the return value -1 for the cases where
3015 * we will want to reschedule the `merge` command).
3019 if (active_cache_changed
&&
3020 write_locked_index(&the_index
, &lock
, COMMIT_LOCK
)) {
3021 ret
= error(_("merge: Unable to write new index file"));
3025 rollback_lock_file(&lock
);
3027 rerere(opts
->allow_rerere_auto
);
3030 * In case of problems, we now want to return a positive
3031 * value (a negative one would indicate that the `merge`
3032 * command needs to be rescheduled).
3034 ret
= !!run_git_commit(git_path_merge_msg(), opts
,
3038 strbuf_release(&ref_name
);
3039 rollback_lock_file(&lock
);
3043 static int is_final_fixup(struct todo_list
*todo_list
)
3045 int i
= todo_list
->current
;
3047 if (!is_fixup(todo_list
->items
[i
].command
))
3050 while (++i
< todo_list
->nr
)
3051 if (is_fixup(todo_list
->items
[i
].command
))
3053 else if (!is_noop(todo_list
->items
[i
].command
))
3058 static enum todo_command
peek_command(struct todo_list
*todo_list
, int offset
)
3062 for (i
= todo_list
->current
+ offset
; i
< todo_list
->nr
; i
++)
3063 if (!is_noop(todo_list
->items
[i
].command
))
3064 return todo_list
->items
[i
].command
;
3069 static int apply_autostash(struct replay_opts
*opts
)
3071 struct strbuf stash_sha1
= STRBUF_INIT
;
3072 struct child_process child
= CHILD_PROCESS_INIT
;
3075 if (!read_oneliner(&stash_sha1
, rebase_path_autostash(), 1)) {
3076 strbuf_release(&stash_sha1
);
3079 strbuf_trim(&stash_sha1
);
3082 child
.no_stdout
= 1;
3083 child
.no_stderr
= 1;
3084 argv_array_push(&child
.args
, "stash");
3085 argv_array_push(&child
.args
, "apply");
3086 argv_array_push(&child
.args
, stash_sha1
.buf
);
3087 if (!run_command(&child
))
3088 fprintf(stderr
, _("Applied autostash.\n"));
3090 struct child_process store
= CHILD_PROCESS_INIT
;
3093 argv_array_push(&store
.args
, "stash");
3094 argv_array_push(&store
.args
, "store");
3095 argv_array_push(&store
.args
, "-m");
3096 argv_array_push(&store
.args
, "autostash");
3097 argv_array_push(&store
.args
, "-q");
3098 argv_array_push(&store
.args
, stash_sha1
.buf
);
3099 if (run_command(&store
))
3100 ret
= error(_("cannot store %s"), stash_sha1
.buf
);
3103 _("Applying autostash resulted in conflicts.\n"
3104 "Your changes are safe in the stash.\n"
3105 "You can run \"git stash pop\" or"
3106 " \"git stash drop\" at any time.\n"));
3109 strbuf_release(&stash_sha1
);
3113 static const char *reflog_message(struct replay_opts
*opts
,
3114 const char *sub_action
, const char *fmt
, ...)
3117 static struct strbuf buf
= STRBUF_INIT
;
3121 strbuf_addstr(&buf
, action_name(opts
));
3123 strbuf_addf(&buf
, " (%s)", sub_action
);
3125 strbuf_addstr(&buf
, ": ");
3126 strbuf_vaddf(&buf
, fmt
, ap
);
3133 static const char rescheduled_advice
[] =
3134 N_("Could not execute the todo command\n"
3138 "It has been rescheduled; To edit the command before continuing, please\n"
3139 "edit the todo list first:\n"
3141 " git rebase --edit-todo\n"
3142 " git rebase --continue\n");
3144 static int pick_commits(struct todo_list
*todo_list
, struct replay_opts
*opts
)
3146 int res
= 0, reschedule
= 0;
3148 setenv(GIT_REFLOG_ACTION
, action_name(opts
), 0);
3150 assert(!(opts
->signoff
|| opts
->no_commit
||
3151 opts
->record_origin
|| opts
->edit
));
3152 if (read_and_refresh_cache(opts
))
3155 while (todo_list
->current
< todo_list
->nr
) {
3156 struct todo_item
*item
= todo_list
->items
+ todo_list
->current
;
3157 if (save_todo(todo_list
, opts
))
3159 if (is_rebase_i(opts
)) {
3160 if (item
->command
!= TODO_COMMENT
) {
3161 FILE *f
= fopen(rebase_path_msgnum(), "w");
3163 todo_list
->done_nr
++;
3166 fprintf(f
, "%d\n", todo_list
->done_nr
);
3169 fprintf(stderr
, "Rebasing (%d/%d)%s",
3171 todo_list
->total_nr
,
3172 opts
->verbose
? "\n" : "\r");
3174 unlink(rebase_path_message());
3175 unlink(rebase_path_author_script());
3176 unlink(rebase_path_stopped_sha());
3177 unlink(rebase_path_amend());
3178 delete_ref(NULL
, "REBASE_HEAD", NULL
, REF_NO_DEREF
);
3180 if (item
->command
<= TODO_SQUASH
) {
3181 if (is_rebase_i(opts
))
3182 setenv("GIT_REFLOG_ACTION", reflog_message(opts
,
3183 command_to_string(item
->command
), NULL
),
3185 res
= do_pick_commit(item
->command
, item
->commit
,
3186 opts
, is_final_fixup(todo_list
));
3187 if (is_rebase_i(opts
) && res
< 0) {
3189 advise(_(rescheduled_advice
),
3190 get_item_line_length(todo_list
,
3191 todo_list
->current
),
3192 get_item_line(todo_list
,
3193 todo_list
->current
));
3194 todo_list
->current
--;
3195 if (save_todo(todo_list
, opts
))
3198 if (item
->command
== TODO_EDIT
) {
3199 struct commit
*commit
= item
->commit
;
3202 _("Stopped at %s... %.*s\n"),
3203 short_commit_name(commit
),
3204 item
->arg_len
, item
->arg
);
3205 return error_with_patch(commit
,
3206 item
->arg
, item
->arg_len
, opts
, res
,
3209 if (is_rebase_i(opts
) && !res
)
3210 record_in_rewritten(&item
->commit
->object
.oid
,
3211 peek_command(todo_list
, 1));
3212 if (res
&& is_fixup(item
->command
)) {
3215 return error_failed_squash(item
->commit
, opts
,
3216 item
->arg_len
, item
->arg
);
3217 } else if (res
&& is_rebase_i(opts
) && item
->commit
)
3218 return res
| error_with_patch(item
->commit
,
3219 item
->arg
, item
->arg_len
, opts
, res
,
3220 item
->command
== TODO_REWORD
);
3221 } else if (item
->command
== TODO_EXEC
) {
3222 char *end_of_arg
= (char *)(item
->arg
+ item
->arg_len
);
3223 int saved
= *end_of_arg
;
3227 res
= do_exec(item
->arg
);
3228 *end_of_arg
= saved
;
3230 /* Reread the todo file if it has changed. */
3232 ; /* fall through */
3233 else if (stat(get_todo_path(opts
), &st
))
3234 res
= error_errno(_("could not stat '%s'"),
3235 get_todo_path(opts
));
3236 else if (match_stat_data(&todo_list
->stat
, &st
)) {
3237 todo_list_release(todo_list
);
3238 if (read_populate_todo(todo_list
, opts
))
3239 res
= -1; /* message was printed */
3240 /* `current` will be incremented below */
3241 todo_list
->current
= -1;
3243 } else if (item
->command
== TODO_LABEL
) {
3244 if ((res
= do_label(item
->arg
, item
->arg_len
)))
3246 } else if (item
->command
== TODO_RESET
) {
3247 if ((res
= do_reset(item
->arg
, item
->arg_len
, opts
)))
3249 } else if (item
->command
== TODO_MERGE
) {
3250 if ((res
= do_merge(item
->commit
,
3251 item
->arg
, item
->arg_len
,
3252 item
->flags
, opts
)) < 0)
3254 else if (item
->commit
)
3255 record_in_rewritten(&item
->commit
->object
.oid
,
3256 peek_command(todo_list
, 1));
3258 /* failed with merge conflicts */
3259 return error_with_patch(item
->commit
,
3261 item
->arg_len
, opts
,
3263 } else if (!is_noop(item
->command
))
3264 return error(_("unknown command %d"), item
->command
);
3267 advise(_(rescheduled_advice
),
3268 get_item_line_length(todo_list
,
3269 todo_list
->current
),
3270 get_item_line(todo_list
, todo_list
->current
));
3271 todo_list
->current
--;
3272 if (save_todo(todo_list
, opts
))
3275 return error_with_patch(item
->commit
,
3277 item
->arg_len
, opts
,
3281 todo_list
->current
++;
3286 if (is_rebase_i(opts
)) {
3287 struct strbuf head_ref
= STRBUF_INIT
, buf
= STRBUF_INIT
;
3290 /* Stopped in the middle, as planned? */
3291 if (todo_list
->current
< todo_list
->nr
)
3294 if (read_oneliner(&head_ref
, rebase_path_head_name(), 0) &&
3295 starts_with(head_ref
.buf
, "refs/")) {
3297 struct object_id head
, orig
;
3300 if (get_oid("HEAD", &head
)) {
3301 res
= error(_("cannot read HEAD"));
3303 strbuf_release(&head_ref
);
3304 strbuf_release(&buf
);
3307 if (!read_oneliner(&buf
, rebase_path_orig_head(), 0) ||
3308 get_oid_hex(buf
.buf
, &orig
)) {
3309 res
= error(_("could not read orig-head"));
3310 goto cleanup_head_ref
;
3313 if (!read_oneliner(&buf
, rebase_path_onto(), 0)) {
3314 res
= error(_("could not read 'onto'"));
3315 goto cleanup_head_ref
;
3317 msg
= reflog_message(opts
, "finish", "%s onto %s",
3318 head_ref
.buf
, buf
.buf
);
3319 if (update_ref(msg
, head_ref
.buf
, &head
, &orig
,
3320 REF_NO_DEREF
, UPDATE_REFS_MSG_ON_ERR
)) {
3321 res
= error(_("could not update %s"),
3323 goto cleanup_head_ref
;
3325 msg
= reflog_message(opts
, "finish", "returning to %s",
3327 if (create_symref("HEAD", head_ref
.buf
, msg
)) {
3328 res
= error(_("could not update HEAD to %s"),
3330 goto cleanup_head_ref
;
3335 if (opts
->verbose
) {
3336 struct rev_info log_tree_opt
;
3337 struct object_id orig
, head
;
3339 memset(&log_tree_opt
, 0, sizeof(log_tree_opt
));
3340 init_revisions(&log_tree_opt
, NULL
);
3341 log_tree_opt
.diff
= 1;
3342 log_tree_opt
.diffopt
.output_format
=
3343 DIFF_FORMAT_DIFFSTAT
;
3344 log_tree_opt
.disable_stdin
= 1;
3346 if (read_oneliner(&buf
, rebase_path_orig_head(), 0) &&
3347 !get_oid(buf
.buf
, &orig
) &&
3348 !get_oid("HEAD", &head
)) {
3349 diff_tree_oid(&orig
, &head
, "",
3350 &log_tree_opt
.diffopt
);
3351 log_tree_diff_flush(&log_tree_opt
);
3354 flush_rewritten_pending();
3355 if (!stat(rebase_path_rewritten_list(), &st
) &&
3357 struct child_process child
= CHILD_PROCESS_INIT
;
3358 const char *post_rewrite_hook
=
3359 find_hook("post-rewrite");
3361 child
.in
= open(rebase_path_rewritten_list(), O_RDONLY
);
3363 argv_array_push(&child
.args
, "notes");
3364 argv_array_push(&child
.args
, "copy");
3365 argv_array_push(&child
.args
, "--for-rewrite=rebase");
3366 /* we don't care if this copying failed */
3367 run_command(&child
);
3369 if (post_rewrite_hook
) {
3370 struct child_process hook
= CHILD_PROCESS_INIT
;
3372 hook
.in
= open(rebase_path_rewritten_list(),
3374 hook
.stdout_to_stderr
= 1;
3375 argv_array_push(&hook
.args
, post_rewrite_hook
);
3376 argv_array_push(&hook
.args
, "rebase");
3377 /* we don't care if this hook failed */
3381 apply_autostash(opts
);
3383 fprintf(stderr
, "Successfully rebased and updated %s.\n",
3386 strbuf_release(&buf
);
3387 strbuf_release(&head_ref
);
3391 * Sequence of picks finished successfully; cleanup by
3392 * removing the .git/sequencer directory
3394 return sequencer_remove_state(opts
);
3397 static int continue_single_pick(void)
3399 const char *argv
[] = { "commit", NULL
};
3401 if (!file_exists(git_path_cherry_pick_head()) &&
3402 !file_exists(git_path_revert_head()))
3403 return error(_("no cherry-pick or revert in progress"));
3404 return run_command_v_opt(argv
, RUN_GIT_CMD
);
3407 static int commit_staged_changes(struct replay_opts
*opts
,
3408 struct todo_list
*todo_list
)
3410 unsigned int flags
= ALLOW_EMPTY
| EDIT_MSG
;
3411 unsigned int final_fixup
= 0, is_clean
;
3413 if (has_unstaged_changes(1))
3414 return error(_("cannot rebase: You have unstaged changes."));
3416 is_clean
= !has_uncommitted_changes(0);
3418 if (file_exists(rebase_path_amend())) {
3419 struct strbuf rev
= STRBUF_INIT
;
3420 struct object_id head
, to_amend
;
3422 if (get_oid("HEAD", &head
))
3423 return error(_("cannot amend non-existing commit"));
3424 if (!read_oneliner(&rev
, rebase_path_amend(), 0))
3425 return error(_("invalid file: '%s'"), rebase_path_amend());
3426 if (get_oid_hex(rev
.buf
, &to_amend
))
3427 return error(_("invalid contents: '%s'"),
3428 rebase_path_amend());
3429 if (!is_clean
&& oidcmp(&head
, &to_amend
))
3430 return error(_("\nYou have uncommitted changes in your "
3431 "working tree. Please, commit them\n"
3432 "first and then run 'git rebase "
3433 "--continue' again."));
3435 * When skipping a failed fixup/squash, we need to edit the
3436 * commit message, the current fixup list and count, and if it
3437 * was the last fixup/squash in the chain, we need to clean up
3438 * the commit message and if there was a squash, let the user
3441 if (is_clean
&& !oidcmp(&head
, &to_amend
) &&
3442 opts
->current_fixup_count
> 0 &&
3443 file_exists(rebase_path_stopped_sha())) {
3444 const char *p
= opts
->current_fixups
.buf
;
3445 int len
= opts
->current_fixups
.len
;
3447 opts
->current_fixup_count
--;
3449 BUG("Incorrect current_fixups:\n%s", p
);
3450 while (len
&& p
[len
- 1] != '\n')
3452 strbuf_setlen(&opts
->current_fixups
, len
);
3453 if (write_message(p
, len
, rebase_path_current_fixups(),
3455 return error(_("could not write file: '%s'"),
3456 rebase_path_current_fixups());
3459 * If a fixup/squash in a fixup/squash chain failed, the
3460 * commit message is already correct, no need to commit
3463 * Only if it is the final command in the fixup/squash
3464 * chain, and only if the chain is longer than a single
3465 * fixup/squash command (which was just skipped), do we
3466 * actually need to re-commit with a cleaned up commit
3469 if (opts
->current_fixup_count
> 0 &&
3470 !is_fixup(peek_command(todo_list
, 0))) {
3473 * If there was not a single "squash" in the
3474 * chain, we only need to clean up the commit
3475 * message, no need to bother the user with
3476 * opening the commit message in the editor.
3478 if (!starts_with(p
, "squash ") &&
3479 !strstr(p
, "\nsquash "))
3480 flags
= (flags
& ~EDIT_MSG
) | CLEANUP_MSG
;
3481 } else if (is_fixup(peek_command(todo_list
, 0))) {
3483 * We need to update the squash message to skip
3484 * the latest commit message.
3486 struct commit
*commit
;
3487 const char *path
= rebase_path_squash_msg();
3489 if (parse_head(&commit
) ||
3490 !(p
= get_commit_buffer(commit
, NULL
)) ||
3491 write_message(p
, strlen(p
), path
, 0)) {
3492 unuse_commit_buffer(commit
, p
);
3493 return error(_("could not write file: "
3496 unuse_commit_buffer(commit
, p
);
3500 strbuf_release(&rev
);
3505 const char *cherry_pick_head
= git_path_cherry_pick_head();
3507 if (file_exists(cherry_pick_head
) && unlink(cherry_pick_head
))
3508 return error(_("could not remove CHERRY_PICK_HEAD"));
3513 if (run_git_commit(final_fixup
? NULL
: rebase_path_message(),
3515 return error(_("could not commit staged changes."));
3516 unlink(rebase_path_amend());
3518 unlink(rebase_path_fixup_msg());
3519 unlink(rebase_path_squash_msg());
3521 if (opts
->current_fixup_count
> 0) {
3523 * Whether final fixup or not, we just cleaned up the commit
3526 unlink(rebase_path_current_fixups());
3527 strbuf_reset(&opts
->current_fixups
);
3528 opts
->current_fixup_count
= 0;
3533 int sequencer_continue(struct replay_opts
*opts
)
3535 struct todo_list todo_list
= TODO_LIST_INIT
;
3538 if (read_and_refresh_cache(opts
))
3541 if (read_populate_opts(opts
))
3543 if (is_rebase_i(opts
)) {
3544 if ((res
= read_populate_todo(&todo_list
, opts
)))
3545 goto release_todo_list
;
3546 if (commit_staged_changes(opts
, &todo_list
))
3548 } else if (!file_exists(get_todo_path(opts
)))
3549 return continue_single_pick();
3550 else if ((res
= read_populate_todo(&todo_list
, opts
)))
3551 goto release_todo_list
;
3553 if (!is_rebase_i(opts
)) {
3554 /* Verify that the conflict has been resolved */
3555 if (file_exists(git_path_cherry_pick_head()) ||
3556 file_exists(git_path_revert_head())) {
3557 res
= continue_single_pick();
3559 goto release_todo_list
;
3561 if (index_differs_from("HEAD", NULL
, 0)) {
3562 res
= error_dirty_index(opts
);
3563 goto release_todo_list
;
3565 todo_list
.current
++;
3566 } else if (file_exists(rebase_path_stopped_sha())) {
3567 struct strbuf buf
= STRBUF_INIT
;
3568 struct object_id oid
;
3570 if (read_oneliner(&buf
, rebase_path_stopped_sha(), 1) &&
3571 !get_oid_committish(buf
.buf
, &oid
))
3572 record_in_rewritten(&oid
, peek_command(&todo_list
, 0));
3573 strbuf_release(&buf
);
3576 res
= pick_commits(&todo_list
, opts
);
3578 todo_list_release(&todo_list
);
3582 static int single_pick(struct commit
*cmit
, struct replay_opts
*opts
)
3584 setenv(GIT_REFLOG_ACTION
, action_name(opts
), 0);
3585 return do_pick_commit(opts
->action
== REPLAY_PICK
?
3586 TODO_PICK
: TODO_REVERT
, cmit
, opts
, 0);
3589 int sequencer_pick_revisions(struct replay_opts
*opts
)
3591 struct todo_list todo_list
= TODO_LIST_INIT
;
3592 struct object_id oid
;
3596 if (read_and_refresh_cache(opts
))
3599 for (i
= 0; i
< opts
->revs
->pending
.nr
; i
++) {
3600 struct object_id oid
;
3601 const char *name
= opts
->revs
->pending
.objects
[i
].name
;
3603 /* This happens when using --stdin. */
3607 if (!get_oid(name
, &oid
)) {
3608 if (!lookup_commit_reference_gently(&oid
, 1)) {
3609 enum object_type type
= oid_object_info(the_repository
,
3612 return error(_("%s: can't cherry-pick a %s"),
3613 name
, type_name(type
));
3616 return error(_("%s: bad revision"), name
);
3620 * If we were called as "git cherry-pick <commit>", just
3621 * cherry-pick/revert it, set CHERRY_PICK_HEAD /
3622 * REVERT_HEAD, and don't touch the sequencer state.
3623 * This means it is possible to cherry-pick in the middle
3624 * of a cherry-pick sequence.
3626 if (opts
->revs
->cmdline
.nr
== 1 &&
3627 opts
->revs
->cmdline
.rev
->whence
== REV_CMD_REV
&&
3628 opts
->revs
->no_walk
&&
3629 !opts
->revs
->cmdline
.rev
->flags
) {
3630 struct commit
*cmit
;
3631 if (prepare_revision_walk(opts
->revs
))
3632 return error(_("revision walk setup failed"));
3633 cmit
= get_revision(opts
->revs
);
3634 if (!cmit
|| get_revision(opts
->revs
))
3635 return error("BUG: expected exactly one commit from walk");
3636 return single_pick(cmit
, opts
);
3640 * Start a new cherry-pick/ revert sequence; but
3641 * first, make sure that an existing one isn't in
3645 if (walk_revs_populate_todo(&todo_list
, opts
) ||
3646 create_seq_dir() < 0)
3648 if (get_oid("HEAD", &oid
) && (opts
->action
== REPLAY_REVERT
))
3649 return error(_("can't revert as initial commit"));
3650 if (save_head(oid_to_hex(&oid
)))
3652 if (save_opts(opts
))
3654 update_abort_safety_file();
3655 res
= pick_commits(&todo_list
, opts
);
3656 todo_list_release(&todo_list
);
3660 void append_signoff(struct strbuf
*msgbuf
, int ignore_footer
, unsigned flag
)
3662 unsigned no_dup_sob
= flag
& APPEND_SIGNOFF_DEDUP
;
3663 struct strbuf sob
= STRBUF_INIT
;
3666 strbuf_addstr(&sob
, sign_off_header
);
3667 strbuf_addstr(&sob
, fmt_name(getenv("GIT_COMMITTER_NAME"),
3668 getenv("GIT_COMMITTER_EMAIL")));
3669 strbuf_addch(&sob
, '\n');
3672 strbuf_complete_line(msgbuf
);
3675 * If the whole message buffer is equal to the sob, pretend that we
3676 * found a conforming footer with a matching sob
3678 if (msgbuf
->len
- ignore_footer
== sob
.len
&&
3679 !strncmp(msgbuf
->buf
, sob
.buf
, sob
.len
))
3682 has_footer
= has_conforming_footer(msgbuf
, &sob
, ignore_footer
);
3685 const char *append_newlines
= NULL
;
3686 size_t len
= msgbuf
->len
- ignore_footer
;
3690 * The buffer is completely empty. Leave foom for
3691 * the title and body to be filled in by the user.
3693 append_newlines
= "\n\n";
3694 } else if (len
== 1) {
3696 * Buffer contains a single newline. Add another
3697 * so that we leave room for the title and body.
3699 append_newlines
= "\n";
3700 } else if (msgbuf
->buf
[len
- 2] != '\n') {
3702 * Buffer ends with a single newline. Add another
3703 * so that there is an empty line between the message
3706 append_newlines
= "\n";
3707 } /* else, the buffer already ends with two newlines. */
3709 if (append_newlines
)
3710 strbuf_splice(msgbuf
, msgbuf
->len
- ignore_footer
, 0,
3711 append_newlines
, strlen(append_newlines
));
3714 if (has_footer
!= 3 && (!no_dup_sob
|| has_footer
!= 2))
3715 strbuf_splice(msgbuf
, msgbuf
->len
- ignore_footer
, 0,
3718 strbuf_release(&sob
);
3721 struct labels_entry
{
3722 struct hashmap_entry entry
;
3723 char label
[FLEX_ARRAY
];
3726 static int labels_cmp(const void *fndata
, const struct labels_entry
*a
,
3727 const struct labels_entry
*b
, const void *key
)
3729 return key
? strcmp(a
->label
, key
) : strcmp(a
->label
, b
->label
);
3732 struct string_entry
{
3733 struct oidmap_entry entry
;
3734 char string
[FLEX_ARRAY
];
3737 struct label_state
{
3738 struct oidmap commit2label
;
3739 struct hashmap labels
;
3743 static const char *label_oid(struct object_id
*oid
, const char *label
,
3744 struct label_state
*state
)
3746 struct labels_entry
*labels_entry
;
3747 struct string_entry
*string_entry
;
3748 struct object_id dummy
;
3752 string_entry
= oidmap_get(&state
->commit2label
, oid
);
3754 return string_entry
->string
;
3757 * For "uninteresting" commits, i.e. commits that are not to be
3758 * rebased, and which can therefore not be labeled, we use a unique
3759 * abbreviation of the commit name. This is slightly more complicated
3760 * than calling find_unique_abbrev() because we also need to make
3761 * sure that the abbreviation does not conflict with any other
3764 * We disallow "interesting" commits to be labeled by a string that
3765 * is a valid full-length hash, to ensure that we always can find an
3766 * abbreviation for any uninteresting commit's names that does not
3767 * clash with any other label.
3772 strbuf_reset(&state
->buf
);
3773 strbuf_grow(&state
->buf
, GIT_SHA1_HEXSZ
);
3774 label
= p
= state
->buf
.buf
;
3776 find_unique_abbrev_r(p
, oid
, default_abbrev
);
3779 * We may need to extend the abbreviated hash so that there is
3780 * no conflicting label.
3782 if (hashmap_get_from_hash(&state
->labels
, strihash(p
), p
)) {
3783 size_t i
= strlen(p
) + 1;
3785 oid_to_hex_r(p
, oid
);
3786 for (; i
< GIT_SHA1_HEXSZ
; i
++) {
3789 if (!hashmap_get_from_hash(&state
->labels
,
3795 } else if (((len
= strlen(label
)) == the_hash_algo
->hexsz
&&
3796 !get_oid_hex(label
, &dummy
)) ||
3797 (len
== 1 && *label
== '#') ||
3798 hashmap_get_from_hash(&state
->labels
,
3799 strihash(label
), label
)) {
3801 * If the label already exists, or if the label is a valid full
3802 * OID, or the label is a '#' (which we use as a separator
3803 * between merge heads and oneline), we append a dash and a
3804 * number to make it unique.
3806 struct strbuf
*buf
= &state
->buf
;
3809 strbuf_add(buf
, label
, len
);
3811 for (i
= 2; ; i
++) {
3812 strbuf_setlen(buf
, len
);
3813 strbuf_addf(buf
, "-%d", i
);
3814 if (!hashmap_get_from_hash(&state
->labels
,
3823 FLEX_ALLOC_STR(labels_entry
, label
, label
);
3824 hashmap_entry_init(labels_entry
, strihash(label
));
3825 hashmap_add(&state
->labels
, labels_entry
);
3827 FLEX_ALLOC_STR(string_entry
, string
, label
);
3828 oidcpy(&string_entry
->entry
.oid
, oid
);
3829 oidmap_put(&state
->commit2label
, string_entry
);
3831 return string_entry
->string
;
3834 static int make_script_with_merges(struct pretty_print_context
*pp
,
3835 struct rev_info
*revs
, FILE *out
,
3838 int keep_empty
= flags
& TODO_LIST_KEEP_EMPTY
;
3839 int rebase_cousins
= flags
& TODO_LIST_REBASE_COUSINS
;
3840 struct strbuf buf
= STRBUF_INIT
, oneline
= STRBUF_INIT
;
3841 struct strbuf label
= STRBUF_INIT
;
3842 struct commit_list
*commits
= NULL
, **tail
= &commits
, *iter
;
3843 struct commit_list
*tips
= NULL
, **tips_tail
= &tips
;
3844 struct commit
*commit
;
3845 struct oidmap commit2todo
= OIDMAP_INIT
;
3846 struct string_entry
*entry
;
3847 struct oidset interesting
= OIDSET_INIT
, child_seen
= OIDSET_INIT
,
3848 shown
= OIDSET_INIT
;
3849 struct label_state state
= { OIDMAP_INIT
, { NULL
}, STRBUF_INIT
};
3851 int abbr
= flags
& TODO_LIST_ABBREVIATE_CMDS
;
3852 const char *cmd_pick
= abbr
? "p" : "pick",
3853 *cmd_label
= abbr
? "l" : "label",
3854 *cmd_reset
= abbr
? "t" : "reset",
3855 *cmd_merge
= abbr
? "m" : "merge";
3857 oidmap_init(&commit2todo
, 0);
3858 oidmap_init(&state
.commit2label
, 0);
3859 hashmap_init(&state
.labels
, (hashmap_cmp_fn
) labels_cmp
, NULL
, 0);
3860 strbuf_init(&state
.buf
, 32);
3862 if (revs
->cmdline
.nr
&& (revs
->cmdline
.rev
[0].flags
& BOTTOM
)) {
3863 struct object_id
*oid
= &revs
->cmdline
.rev
[0].item
->oid
;
3864 FLEX_ALLOC_STR(entry
, string
, "onto");
3865 oidcpy(&entry
->entry
.oid
, oid
);
3866 oidmap_put(&state
.commit2label
, entry
);
3871 * - get onelines for all commits
3872 * - gather all branch tips (i.e. 2nd or later parents of merges)
3873 * - label all branch tips
3875 while ((commit
= get_revision(revs
))) {
3876 struct commit_list
*to_merge
;
3878 const char *p1
, *p2
;
3879 struct object_id
*oid
;
3882 tail
= &commit_list_insert(commit
, tail
)->next
;
3883 oidset_insert(&interesting
, &commit
->object
.oid
);
3885 is_empty
= is_original_commit_empty(commit
);
3886 if (!is_empty
&& (commit
->object
.flags
& PATCHSAME
))
3889 strbuf_reset(&oneline
);
3890 pretty_print_commit(pp
, commit
, &oneline
);
3892 to_merge
= commit
->parents
? commit
->parents
->next
: NULL
;
3894 /* non-merge commit: easy case */
3896 if (!keep_empty
&& is_empty
)
3897 strbuf_addf(&buf
, "%c ", comment_line_char
);
3898 strbuf_addf(&buf
, "%s %s %s", cmd_pick
,
3899 oid_to_hex(&commit
->object
.oid
),
3902 FLEX_ALLOC_STR(entry
, string
, buf
.buf
);
3903 oidcpy(&entry
->entry
.oid
, &commit
->object
.oid
);
3904 oidmap_put(&commit2todo
, entry
);
3909 is_octopus
= to_merge
&& to_merge
->next
;
3912 BUG("Octopus merges not yet supported");
3914 /* Create a label */
3915 strbuf_reset(&label
);
3916 if (skip_prefix(oneline
.buf
, "Merge ", &p1
) &&
3917 (p1
= strchr(p1
, '\'')) &&
3918 (p2
= strchr(++p1
, '\'')))
3919 strbuf_add(&label
, p1
, p2
- p1
);
3920 else if (skip_prefix(oneline
.buf
, "Merge pull request ",
3922 (p1
= strstr(p1
, " from ")))
3923 strbuf_addstr(&label
, p1
+ strlen(" from "));
3925 strbuf_addbuf(&label
, &oneline
);
3927 for (p1
= label
.buf
; *p1
; p1
++)
3932 strbuf_addf(&buf
, "%s -C %s",
3933 cmd_merge
, oid_to_hex(&commit
->object
.oid
));
3935 /* label the tip of merged branch */
3936 oid
= &to_merge
->item
->object
.oid
;
3937 strbuf_addch(&buf
, ' ');
3939 if (!oidset_contains(&interesting
, oid
))
3940 strbuf_addstr(&buf
, label_oid(oid
, NULL
, &state
));
3942 tips_tail
= &commit_list_insert(to_merge
->item
,
3945 strbuf_addstr(&buf
, label_oid(oid
, label
.buf
, &state
));
3947 strbuf_addf(&buf
, " # %s", oneline
.buf
);
3949 FLEX_ALLOC_STR(entry
, string
, buf
.buf
);
3950 oidcpy(&entry
->entry
.oid
, &commit
->object
.oid
);
3951 oidmap_put(&commit2todo
, entry
);
3956 * - label branch points
3957 * - add HEAD to the branch tips
3959 for (iter
= commits
; iter
; iter
= iter
->next
) {
3960 struct commit_list
*parent
= iter
->item
->parents
;
3961 for (; parent
; parent
= parent
->next
) {
3962 struct object_id
*oid
= &parent
->item
->object
.oid
;
3963 if (!oidset_contains(&interesting
, oid
))
3965 if (!oidset_contains(&child_seen
, oid
))
3966 oidset_insert(&child_seen
, oid
);
3968 label_oid(oid
, "branch-point", &state
);
3971 /* Add HEAD as implict "tip of branch" */
3973 tips_tail
= &commit_list_insert(iter
->item
,
3978 * Third phase: output the todo list. This is a bit tricky, as we
3979 * want to avoid jumping back and forth between revisions. To
3980 * accomplish that goal, we walk backwards from the branch tips,
3981 * gathering commits not yet shown, reversing the list on the fly,
3982 * then outputting that list (labeling revisions as needed).
3984 fprintf(out
, "%s onto\n", cmd_label
);
3985 for (iter
= tips
; iter
; iter
= iter
->next
) {
3986 struct commit_list
*list
= NULL
, *iter2
;
3988 commit
= iter
->item
;
3989 if (oidset_contains(&shown
, &commit
->object
.oid
))
3991 entry
= oidmap_get(&state
.commit2label
, &commit
->object
.oid
);
3994 fprintf(out
, "\n# Branch %s\n", entry
->string
);
3998 while (oidset_contains(&interesting
, &commit
->object
.oid
) &&
3999 !oidset_contains(&shown
, &commit
->object
.oid
)) {
4000 commit_list_insert(commit
, &list
);
4001 if (!commit
->parents
) {
4005 commit
= commit
->parents
->item
;
4009 fprintf(out
, "%s %s\n", cmd_reset
,
4010 rebase_cousins
? "onto" : "[new root]");
4012 const char *to
= NULL
;
4014 entry
= oidmap_get(&state
.commit2label
,
4015 &commit
->object
.oid
);
4018 else if (!rebase_cousins
)
4019 to
= label_oid(&commit
->object
.oid
, NULL
,
4022 if (!to
|| !strcmp(to
, "onto"))
4023 fprintf(out
, "%s onto\n", cmd_reset
);
4025 strbuf_reset(&oneline
);
4026 pretty_print_commit(pp
, commit
, &oneline
);
4027 fprintf(out
, "%s %s # %s\n",
4028 cmd_reset
, to
, oneline
.buf
);
4032 for (iter2
= list
; iter2
; iter2
= iter2
->next
) {
4033 struct object_id
*oid
= &iter2
->item
->object
.oid
;
4034 entry
= oidmap_get(&commit2todo
, oid
);
4035 /* only show if not already upstream */
4037 fprintf(out
, "%s\n", entry
->string
);
4038 entry
= oidmap_get(&state
.commit2label
, oid
);
4040 fprintf(out
, "%s %s\n",
4041 cmd_label
, entry
->string
);
4042 oidset_insert(&shown
, oid
);
4045 free_commit_list(list
);
4048 free_commit_list(commits
);
4049 free_commit_list(tips
);
4051 strbuf_release(&label
);
4052 strbuf_release(&oneline
);
4053 strbuf_release(&buf
);
4055 oidmap_free(&commit2todo
, 1);
4056 oidmap_free(&state
.commit2label
, 1);
4057 hashmap_free(&state
.labels
, 1);
4058 strbuf_release(&state
.buf
);
4063 int sequencer_make_script(FILE *out
, int argc
, const char **argv
,
4066 char *format
= NULL
;
4067 struct pretty_print_context pp
= {0};
4068 struct strbuf buf
= STRBUF_INIT
;
4069 struct rev_info revs
;
4070 struct commit
*commit
;
4071 int keep_empty
= flags
& TODO_LIST_KEEP_EMPTY
;
4072 const char *insn
= flags
& TODO_LIST_ABBREVIATE_CMDS
? "p" : "pick";
4073 int rebase_merges
= flags
& TODO_LIST_REBASE_MERGES
;
4075 init_revisions(&revs
, NULL
);
4076 revs
.verbose_header
= 1;
4078 revs
.max_parents
= 1;
4079 revs
.cherry_mark
= 1;
4082 revs
.right_only
= 1;
4083 revs
.sort_order
= REV_SORT_IN_GRAPH_ORDER
;
4084 revs
.topo_order
= 1;
4086 revs
.pretty_given
= 1;
4087 git_config_get_string("rebase.instructionFormat", &format
);
4088 if (!format
|| !*format
) {
4090 format
= xstrdup("%s");
4092 get_commit_format(format
, &revs
);
4094 pp
.fmt
= revs
.commit_format
;
4095 pp
.output_encoding
= get_log_output_encoding();
4097 if (setup_revisions(argc
, argv
, &revs
, NULL
) > 1)
4098 return error(_("make_script: unhandled options"));
4100 if (prepare_revision_walk(&revs
) < 0)
4101 return error(_("make_script: error preparing revisions"));
4104 return make_script_with_merges(&pp
, &revs
, out
, flags
);
4106 while ((commit
= get_revision(&revs
))) {
4107 int is_empty
= is_original_commit_empty(commit
);
4109 if (!is_empty
&& (commit
->object
.flags
& PATCHSAME
))
4112 if (!keep_empty
&& is_empty
)
4113 strbuf_addf(&buf
, "%c ", comment_line_char
);
4114 strbuf_addf(&buf
, "%s %s ", insn
,
4115 oid_to_hex(&commit
->object
.oid
));
4116 pretty_print_commit(&pp
, commit
, &buf
);
4117 strbuf_addch(&buf
, '\n');
4118 fputs(buf
.buf
, out
);
4120 strbuf_release(&buf
);
4125 * Add commands after pick and (series of) squash/fixup commands
4128 int sequencer_add_exec_commands(const char *commands
)
4130 const char *todo_file
= rebase_path_todo();
4131 struct todo_list todo_list
= TODO_LIST_INIT
;
4132 struct todo_item
*item
;
4133 struct strbuf
*buf
= &todo_list
.buf
;
4134 size_t offset
= 0, commands_len
= strlen(commands
);
4137 if (strbuf_read_file(&todo_list
.buf
, todo_file
, 0) < 0)
4138 return error(_("could not read '%s'."), todo_file
);
4140 if (parse_insn_buffer(todo_list
.buf
.buf
, &todo_list
)) {
4141 todo_list_release(&todo_list
);
4142 return error(_("unusable todo list: '%s'"), todo_file
);
4146 /* insert <commands> before every pick except the first one */
4147 for (item
= todo_list
.items
, i
= 0; i
< todo_list
.nr
; i
++, item
++) {
4148 if (item
->command
== TODO_PICK
&& !first
) {
4149 strbuf_insert(buf
, item
->offset_in_buf
+ offset
,
4150 commands
, commands_len
);
4151 offset
+= commands_len
;
4156 /* append final <commands> */
4157 strbuf_add(buf
, commands
, commands_len
);
4159 i
= write_message(buf
->buf
, buf
->len
, todo_file
, 0);
4160 todo_list_release(&todo_list
);
4164 int transform_todos(unsigned flags
)
4166 const char *todo_file
= rebase_path_todo();
4167 struct todo_list todo_list
= TODO_LIST_INIT
;
4168 struct strbuf buf
= STRBUF_INIT
;
4169 struct todo_item
*item
;
4172 if (strbuf_read_file(&todo_list
.buf
, todo_file
, 0) < 0)
4173 return error(_("could not read '%s'."), todo_file
);
4175 if (parse_insn_buffer(todo_list
.buf
.buf
, &todo_list
)) {
4176 todo_list_release(&todo_list
);
4177 return error(_("unusable todo list: '%s'"), todo_file
);
4180 for (item
= todo_list
.items
, i
= 0; i
< todo_list
.nr
; i
++, item
++) {
4181 /* if the item is not a command write it and continue */
4182 if (item
->command
>= TODO_COMMENT
) {
4183 strbuf_addf(&buf
, "%.*s\n", item
->arg_len
, item
->arg
);
4187 /* add command to the buffer */
4188 if (flags
& TODO_LIST_ABBREVIATE_CMDS
)
4189 strbuf_addch(&buf
, command_to_char(item
->command
));
4191 strbuf_addstr(&buf
, command_to_string(item
->command
));
4195 const char *oid
= flags
& TODO_LIST_SHORTEN_IDS
?
4196 short_commit_name(item
->commit
) :
4197 oid_to_hex(&item
->commit
->object
.oid
);
4199 if (item
->command
== TODO_MERGE
) {
4200 if (item
->flags
& TODO_EDIT_MERGE_MSG
)
4201 strbuf_addstr(&buf
, " -c");
4203 strbuf_addstr(&buf
, " -C");
4206 strbuf_addf(&buf
, " %s", oid
);
4209 /* add all the rest */
4211 strbuf_addch(&buf
, '\n');
4213 strbuf_addf(&buf
, " %.*s\n", item
->arg_len
, item
->arg
);
4216 i
= write_message(buf
.buf
, buf
.len
, todo_file
, 0);
4217 todo_list_release(&todo_list
);
4222 CHECK_IGNORE
= 0, CHECK_WARN
, CHECK_ERROR
4225 static enum check_level
get_missing_commit_check_level(void)
4229 if (git_config_get_value("rebase.missingcommitscheck", &value
) ||
4230 !strcasecmp("ignore", value
))
4231 return CHECK_IGNORE
;
4232 if (!strcasecmp("warn", value
))
4234 if (!strcasecmp("error", value
))
4236 warning(_("unrecognized setting %s for option "
4237 "rebase.missingCommitsCheck. Ignoring."), value
);
4238 return CHECK_IGNORE
;
4242 * Check if the user dropped some commits by mistake
4243 * Behaviour determined by rebase.missingCommitsCheck.
4244 * Check if there is an unrecognized command or a
4245 * bad SHA-1 in a command.
4247 int check_todo_list(void)
4249 enum check_level check_level
= get_missing_commit_check_level();
4250 struct strbuf todo_file
= STRBUF_INIT
;
4251 struct todo_list todo_list
= TODO_LIST_INIT
;
4252 struct strbuf missing
= STRBUF_INIT
;
4253 int advise_to_edit_todo
= 0, res
= 0, i
;
4255 strbuf_addstr(&todo_file
, rebase_path_todo());
4256 if (strbuf_read_file_or_whine(&todo_list
.buf
, todo_file
.buf
) < 0) {
4260 advise_to_edit_todo
= res
=
4261 parse_insn_buffer(todo_list
.buf
.buf
, &todo_list
);
4263 if (res
|| check_level
== CHECK_IGNORE
)
4266 /* Mark the commits in git-rebase-todo as seen */
4267 for (i
= 0; i
< todo_list
.nr
; i
++) {
4268 struct commit
*commit
= todo_list
.items
[i
].commit
;
4270 commit
->util
= (void *)1;
4273 todo_list_release(&todo_list
);
4274 strbuf_addstr(&todo_file
, ".backup");
4275 if (strbuf_read_file_or_whine(&todo_list
.buf
, todo_file
.buf
) < 0) {
4279 strbuf_release(&todo_file
);
4280 res
= !!parse_insn_buffer(todo_list
.buf
.buf
, &todo_list
);
4282 /* Find commits in git-rebase-todo.backup yet unseen */
4283 for (i
= todo_list
.nr
- 1; i
>= 0; i
--) {
4284 struct todo_item
*item
= todo_list
.items
+ i
;
4285 struct commit
*commit
= item
->commit
;
4286 if (commit
&& !commit
->util
) {
4287 strbuf_addf(&missing
, " - %s %.*s\n",
4288 short_commit_name(commit
),
4289 item
->arg_len
, item
->arg
);
4290 commit
->util
= (void *)1;
4294 /* Warn about missing commits */
4298 if (check_level
== CHECK_ERROR
)
4299 advise_to_edit_todo
= res
= 1;
4302 _("Warning: some commits may have been dropped accidentally.\n"
4303 "Dropped commits (newer to older):\n"));
4305 /* Make the list user-friendly and display */
4306 fputs(missing
.buf
, stderr
);
4307 strbuf_release(&missing
);
4309 fprintf(stderr
, _("To avoid this message, use \"drop\" to "
4310 "explicitly remove a commit.\n\n"
4311 "Use 'git config rebase.missingCommitsCheck' to change "
4312 "the level of warnings.\n"
4313 "The possible behaviours are: ignore, warn, error.\n\n"));
4316 strbuf_release(&todo_file
);
4317 todo_list_release(&todo_list
);
4319 if (advise_to_edit_todo
)
4321 _("You can fix this with 'git rebase --edit-todo' "
4322 "and then run 'git rebase --continue'.\n"
4323 "Or you can abort the rebase with 'git rebase"
4329 static int rewrite_file(const char *path
, const char *buf
, size_t len
)
4332 int fd
= open(path
, O_WRONLY
| O_TRUNC
);
4334 return error_errno(_("could not open '%s' for writing"), path
);
4335 if (write_in_full(fd
, buf
, len
) < 0)
4336 rc
= error_errno(_("could not write to '%s'"), path
);
4337 if (close(fd
) && !rc
)
4338 rc
= error_errno(_("could not close '%s'"), path
);
4342 /* skip picking commits whose parents are unchanged */
4343 int skip_unnecessary_picks(void)
4345 const char *todo_file
= rebase_path_todo();
4346 struct strbuf buf
= STRBUF_INIT
;
4347 struct todo_list todo_list
= TODO_LIST_INIT
;
4348 struct object_id onto_oid
, *oid
= &onto_oid
, *parent_oid
;
4351 if (!read_oneliner(&buf
, rebase_path_onto(), 0))
4352 return error(_("could not read 'onto'"));
4353 if (get_oid(buf
.buf
, &onto_oid
)) {
4354 strbuf_release(&buf
);
4355 return error(_("need a HEAD to fixup"));
4357 strbuf_release(&buf
);
4359 if (strbuf_read_file_or_whine(&todo_list
.buf
, todo_file
) < 0)
4361 if (parse_insn_buffer(todo_list
.buf
.buf
, &todo_list
) < 0) {
4362 todo_list_release(&todo_list
);
4366 for (i
= 0; i
< todo_list
.nr
; i
++) {
4367 struct todo_item
*item
= todo_list
.items
+ i
;
4369 if (item
->command
>= TODO_NOOP
)
4371 if (item
->command
!= TODO_PICK
)
4373 if (parse_commit(item
->commit
)) {
4374 todo_list_release(&todo_list
);
4375 return error(_("could not parse commit '%s'"),
4376 oid_to_hex(&item
->commit
->object
.oid
));
4378 if (!item
->commit
->parents
)
4379 break; /* root commit */
4380 if (item
->commit
->parents
->next
)
4381 break; /* merge commit */
4382 parent_oid
= &item
->commit
->parents
->item
->object
.oid
;
4383 if (hashcmp(parent_oid
->hash
, oid
->hash
))
4385 oid
= &item
->commit
->object
.oid
;
4388 int offset
= get_item_line_offset(&todo_list
, i
);
4389 const char *done_path
= rebase_path_done();
4391 fd
= open(done_path
, O_CREAT
| O_WRONLY
| O_APPEND
, 0666);
4393 error_errno(_("could not open '%s' for writing"),
4395 todo_list_release(&todo_list
);
4398 if (write_in_full(fd
, todo_list
.buf
.buf
, offset
) < 0) {
4399 error_errno(_("could not write to '%s'"), done_path
);
4400 todo_list_release(&todo_list
);
4406 if (rewrite_file(rebase_path_todo(), todo_list
.buf
.buf
+ offset
,
4407 todo_list
.buf
.len
- offset
) < 0) {
4408 todo_list_release(&todo_list
);
4412 todo_list
.current
= i
;
4413 if (is_fixup(peek_command(&todo_list
, 0)))
4414 record_in_rewritten(oid
, peek_command(&todo_list
, 0));
4417 todo_list_release(&todo_list
);
4418 printf("%s\n", oid_to_hex(oid
));
4423 struct subject2item_entry
{
4424 struct hashmap_entry entry
;
4426 char subject
[FLEX_ARRAY
];
4429 static int subject2item_cmp(const void *fndata
,
4430 const struct subject2item_entry
*a
,
4431 const struct subject2item_entry
*b
, const void *key
)
4433 return key
? strcmp(a
->subject
, key
) : strcmp(a
->subject
, b
->subject
);
4437 * Rearrange the todo list that has both "pick commit-id msg" and "pick
4438 * commit-id fixup!/squash! msg" in it so that the latter is put immediately
4439 * after the former, and change "pick" to "fixup"/"squash".
4441 * Note that if the config has specified a custom instruction format, each log
4442 * message will have to be retrieved from the commit (as the oneline in the
4443 * script cannot be trusted) in order to normalize the autosquash arrangement.
4445 int rearrange_squash(void)
4447 const char *todo_file
= rebase_path_todo();
4448 struct todo_list todo_list
= TODO_LIST_INIT
;
4449 struct hashmap subject2item
;
4450 int res
= 0, rearranged
= 0, *next
, *tail
, i
;
4453 if (strbuf_read_file_or_whine(&todo_list
.buf
, todo_file
) < 0)
4455 if (parse_insn_buffer(todo_list
.buf
.buf
, &todo_list
) < 0) {
4456 todo_list_release(&todo_list
);
4461 * The hashmap maps onelines to the respective todo list index.
4463 * If any items need to be rearranged, the next[i] value will indicate
4464 * which item was moved directly after the i'th.
4466 * In that case, last[i] will indicate the index of the latest item to
4467 * be moved to appear after the i'th.
4469 hashmap_init(&subject2item
, (hashmap_cmp_fn
) subject2item_cmp
,
4470 NULL
, todo_list
.nr
);
4471 ALLOC_ARRAY(next
, todo_list
.nr
);
4472 ALLOC_ARRAY(tail
, todo_list
.nr
);
4473 ALLOC_ARRAY(subjects
, todo_list
.nr
);
4474 for (i
= 0; i
< todo_list
.nr
; i
++) {
4475 struct strbuf buf
= STRBUF_INIT
;
4476 struct todo_item
*item
= todo_list
.items
+ i
;
4477 const char *commit_buffer
, *subject
, *p
;
4480 struct subject2item_entry
*entry
;
4482 next
[i
] = tail
[i
] = -1;
4483 if (!item
->commit
|| item
->command
== TODO_DROP
) {
4488 if (is_fixup(item
->command
)) {
4489 todo_list_release(&todo_list
);
4490 return error(_("the script was already rearranged."));
4493 item
->commit
->util
= item
;
4495 parse_commit(item
->commit
);
4496 commit_buffer
= get_commit_buffer(item
->commit
, NULL
);
4497 find_commit_subject(commit_buffer
, &subject
);
4498 format_subject(&buf
, subject
, " ");
4499 subject
= subjects
[i
] = strbuf_detach(&buf
, &subject_len
);
4500 unuse_commit_buffer(item
->commit
, commit_buffer
);
4501 if ((skip_prefix(subject
, "fixup! ", &p
) ||
4502 skip_prefix(subject
, "squash! ", &p
))) {
4503 struct commit
*commit2
;
4508 if (!skip_prefix(p
, "fixup! ", &p
) &&
4509 !skip_prefix(p
, "squash! ", &p
))
4513 if ((entry
= hashmap_get_from_hash(&subject2item
,
4515 /* found by title */
4517 else if (!strchr(p
, ' ') &&
4519 lookup_commit_reference_by_name(p
)) &&
4521 /* found by commit name */
4522 i2
= (struct todo_item
*)commit2
->util
4525 /* copy can be a prefix of the commit subject */
4526 for (i2
= 0; i2
< i
; i2
++)
4528 starts_with(subjects
[i2
], p
))
4536 todo_list
.items
[i
].command
=
4537 starts_with(subject
, "fixup!") ?
4538 TODO_FIXUP
: TODO_SQUASH
;
4544 } else if (!hashmap_get_from_hash(&subject2item
,
4545 strhash(subject
), subject
)) {
4546 FLEX_ALLOC_MEM(entry
, subject
, subject
, subject_len
);
4548 hashmap_entry_init(entry
, strhash(entry
->subject
));
4549 hashmap_put(&subject2item
, entry
);
4554 struct strbuf buf
= STRBUF_INIT
;
4556 for (i
= 0; i
< todo_list
.nr
; i
++) {
4557 enum todo_command command
= todo_list
.items
[i
].command
;
4561 * Initially, all commands are 'pick's. If it is a
4562 * fixup or a squash now, we have rearranged it.
4564 if (is_fixup(command
))
4569 get_item_line(&todo_list
, cur
);
4571 get_item_line(&todo_list
, cur
+ 1);
4573 /* replace 'pick', by 'fixup' or 'squash' */
4574 command
= todo_list
.items
[cur
].command
;
4575 if (is_fixup(command
)) {
4577 todo_command_info
[command
].str
);
4578 bol
+= strcspn(bol
, " \t");
4581 strbuf_add(&buf
, bol
, eol
- bol
);
4587 res
= rewrite_file(todo_file
, buf
.buf
, buf
.len
);
4588 strbuf_release(&buf
);
4593 for (i
= 0; i
< todo_list
.nr
; i
++)
4596 hashmap_free(&subject2item
, 1);
4597 todo_list_release(&todo_list
);