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"
31 #define GIT_REFLOG_ACTION "GIT_REFLOG_ACTION"
33 const char sign_off_header
[] = "Signed-off-by: ";
34 static const char cherry_picked_prefix
[] = "(cherry picked from commit ";
36 GIT_PATH_FUNC(git_path_commit_editmsg
, "COMMIT_EDITMSG")
38 GIT_PATH_FUNC(git_path_seq_dir
, "sequencer")
40 static GIT_PATH_FUNC(git_path_todo_file
, "sequencer/todo")
41 static GIT_PATH_FUNC(git_path_opts_file
, "sequencer/opts")
42 static GIT_PATH_FUNC(git_path_head_file
, "sequencer/head")
43 static GIT_PATH_FUNC(git_path_abort_safety_file
, "sequencer/abort-safety")
45 static GIT_PATH_FUNC(rebase_path
, "rebase-merge")
47 * The file containing rebase commands, comments, and empty lines.
48 * This file is created by "git rebase -i" then edited by the user. As
49 * the lines are processed, they are removed from the front of this
50 * file and written to the tail of 'done'.
52 static GIT_PATH_FUNC(rebase_path_todo
, "rebase-merge/git-rebase-todo")
54 * The rebase command lines that have already been processed. A line
55 * is moved here when it is first handled, before any associated user
58 static GIT_PATH_FUNC(rebase_path_done
, "rebase-merge/done")
60 * The file to keep track of how many commands were already processed (e.g.
63 static GIT_PATH_FUNC(rebase_path_msgnum
, "rebase-merge/msgnum");
65 * The file to keep track of how many commands are to be processed in total
66 * (e.g. for the prompt).
68 static GIT_PATH_FUNC(rebase_path_msgtotal
, "rebase-merge/end");
70 * The commit message that is planned to be used for any changes that
71 * need to be committed following a user interaction.
73 static GIT_PATH_FUNC(rebase_path_message
, "rebase-merge/message")
75 * The file into which is accumulated the suggested commit message for
76 * squash/fixup commands. When the first of a series of squash/fixups
77 * is seen, the file is created and the commit message from the
78 * previous commit and from the first squash/fixup commit are written
79 * to it. The commit message for each subsequent squash/fixup commit
80 * is appended to the file as it is processed.
82 static GIT_PATH_FUNC(rebase_path_squash_msg
, "rebase-merge/message-squash")
84 * If the current series of squash/fixups has not yet included a squash
85 * command, then this file exists and holds the commit message of the
86 * original "pick" commit. (If the series ends without a "squash"
87 * command, then this can be used as the commit message of the combined
88 * commit without opening the editor.)
90 static GIT_PATH_FUNC(rebase_path_fixup_msg
, "rebase-merge/message-fixup")
92 * This file contains the list fixup/squash commands that have been
93 * accumulated into message-fixup or message-squash so far.
95 static GIT_PATH_FUNC(rebase_path_current_fixups
, "rebase-merge/current-fixups")
97 * A script to set the GIT_AUTHOR_NAME, GIT_AUTHOR_EMAIL, and
98 * GIT_AUTHOR_DATE that will be used for the commit that is currently
101 static GIT_PATH_FUNC(rebase_path_author_script
, "rebase-merge/author-script")
103 * When an "edit" rebase command is being processed, the SHA1 of the
104 * commit to be edited is recorded in this file. When "git rebase
105 * --continue" is executed, if there are any staged changes then they
106 * will be amended to the HEAD commit, but only provided the HEAD
107 * commit is still the commit to be edited. When any other rebase
108 * command is processed, this file is deleted.
110 static GIT_PATH_FUNC(rebase_path_amend
, "rebase-merge/amend")
112 * When we stop at a given patch via the "edit" command, this file contains
113 * the abbreviated commit name of the corresponding patch.
115 static GIT_PATH_FUNC(rebase_path_stopped_sha
, "rebase-merge/stopped-sha")
117 * For the post-rewrite hook, we make a list of rewritten commits and
118 * their new sha1s. The rewritten-pending list keeps the sha1s of
119 * commits that have been processed, but not committed yet,
120 * e.g. because they are waiting for a 'squash' command.
122 static GIT_PATH_FUNC(rebase_path_rewritten_list
, "rebase-merge/rewritten-list")
123 static GIT_PATH_FUNC(rebase_path_rewritten_pending
,
124 "rebase-merge/rewritten-pending")
127 * The path of the file containig the OID of the "squash onto" commit, i.e.
128 * the dummy commit used for `reset [new root]`.
130 static GIT_PATH_FUNC(rebase_path_squash_onto
, "rebase-merge/squash-onto")
133 * The path of the file listing refs that need to be deleted after the rebase
134 * finishes. This is used by the `label` command to record the need for cleanup.
136 static GIT_PATH_FUNC(rebase_path_refs_to_delete
, "rebase-merge/refs-to-delete")
139 * The following files are written by git-rebase just after parsing the
140 * command-line (and are only consumed, not modified, by the sequencer).
142 static GIT_PATH_FUNC(rebase_path_gpg_sign_opt
, "rebase-merge/gpg_sign_opt")
143 static GIT_PATH_FUNC(rebase_path_orig_head
, "rebase-merge/orig-head")
144 static GIT_PATH_FUNC(rebase_path_verbose
, "rebase-merge/verbose")
145 static GIT_PATH_FUNC(rebase_path_signoff
, "rebase-merge/signoff")
146 static GIT_PATH_FUNC(rebase_path_head_name
, "rebase-merge/head-name")
147 static GIT_PATH_FUNC(rebase_path_onto
, "rebase-merge/onto")
148 static GIT_PATH_FUNC(rebase_path_autostash
, "rebase-merge/autostash")
149 static GIT_PATH_FUNC(rebase_path_strategy
, "rebase-merge/strategy")
150 static GIT_PATH_FUNC(rebase_path_strategy_opts
, "rebase-merge/strategy_opts")
151 static GIT_PATH_FUNC(rebase_path_allow_rerere_autoupdate
, "rebase-merge/allow_rerere_autoupdate")
153 static int git_sequencer_config(const char *k
, const char *v
, void *cb
)
155 struct replay_opts
*opts
= cb
;
158 if (!strcmp(k
, "commit.cleanup")) {
161 status
= git_config_string(&s
, k
, v
);
165 if (!strcmp(s
, "verbatim"))
166 opts
->default_msg_cleanup
= COMMIT_MSG_CLEANUP_NONE
;
167 else if (!strcmp(s
, "whitespace"))
168 opts
->default_msg_cleanup
= COMMIT_MSG_CLEANUP_SPACE
;
169 else if (!strcmp(s
, "strip"))
170 opts
->default_msg_cleanup
= COMMIT_MSG_CLEANUP_ALL
;
171 else if (!strcmp(s
, "scissors"))
172 opts
->default_msg_cleanup
= COMMIT_MSG_CLEANUP_SPACE
;
174 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 res
= write_message(buf
.buf
, buf
.len
, rebase_path_author_script(), 1);
655 strbuf_release(&buf
);
660 * Read a list of environment variable assignments (such as the author-script
661 * file) into an environment block. Returns -1 on error, 0 otherwise.
663 static int read_env_script(struct argv_array
*env
)
665 struct strbuf script
= STRBUF_INIT
;
669 if (strbuf_read_file(&script
, rebase_path_author_script(), 256) <= 0)
672 for (p
= script
.buf
; *p
; p
++)
673 if (skip_prefix(p
, "'\\\\''", (const char **)&p2
))
674 strbuf_splice(&script
, p
- script
.buf
, p2
- p
, "'", 1);
676 strbuf_splice(&script
, p
-- - script
.buf
, 1, "", 0);
677 else if (*p
== '\n') {
682 for (i
= 0, p
= script
.buf
; i
< count
; i
++) {
683 argv_array_push(env
, p
);
690 static char *get_author(const char *message
)
695 a
= find_commit_header(message
, "author", &len
);
697 return xmemdupz(a
, len
);
702 /* Read author-script and return an ident line (author <email> timestamp) */
703 static const char *read_author_ident(struct strbuf
*buf
)
705 const char *keys
[] = {
706 "GIT_AUTHOR_NAME=", "GIT_AUTHOR_EMAIL=", "GIT_AUTHOR_DATE="
708 char *in
, *out
, *eol
;
711 if (strbuf_read_file(buf
, rebase_path_author_script(), 256) <= 0)
714 /* dequote values and construct ident line in-place */
715 for (in
= out
= buf
->buf
; i
< 3 && in
- buf
->buf
< buf
->len
; i
++) {
716 if (!skip_prefix(in
, keys
[i
], (const char **)&in
)) {
717 warning("could not parse '%s' (looking for '%s'",
718 rebase_path_author_script(), keys
[i
]);
722 eol
= strchrnul(in
, '\n');
727 if (i
> 0) /* separate values by spaces */
729 if (i
== 1) /* email needs to be surrounded by <...> */
731 memmove(out
, in
, len
);
733 if (i
== 1) /* email needs to be surrounded by <...> */
739 warning("could not parse '%s' (looking for '%s')",
740 rebase_path_author_script(), keys
[i
]);
744 buf
->len
= out
- buf
->buf
;
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
) {
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
);
1778 res
|= write_message(msgbuf
.buf
, msgbuf
.len
,
1779 git_path_merge_msg(), 0);
1781 struct commit_list
*common
= NULL
;
1782 struct commit_list
*remotes
= NULL
;
1784 res
= write_message(msgbuf
.buf
, msgbuf
.len
,
1785 git_path_merge_msg(), 0);
1787 commit_list_insert(base
, &common
);
1788 commit_list_insert(next
, &remotes
);
1789 res
|= try_merge_command(opts
->strategy
,
1790 opts
->xopts_nr
, (const char **)opts
->xopts
,
1791 common
, oid_to_hex(&head
), remotes
);
1792 free_commit_list(common
);
1793 free_commit_list(remotes
);
1795 strbuf_release(&msgbuf
);
1798 * If the merge was clean or if it failed due to conflict, we write
1799 * CHERRY_PICK_HEAD for the subsequent invocation of commit to use.
1800 * However, if the merge did not even start, then we don't want to
1803 if (command
== TODO_PICK
&& !opts
->no_commit
&& (res
== 0 || res
== 1) &&
1804 update_ref(NULL
, "CHERRY_PICK_HEAD", &commit
->object
.oid
, NULL
,
1805 REF_NO_DEREF
, UPDATE_REFS_MSG_ON_ERR
))
1807 if (command
== TODO_REVERT
&& ((opts
->no_commit
&& res
== 0) || res
== 1) &&
1808 update_ref(NULL
, "REVERT_HEAD", &commit
->object
.oid
, NULL
,
1809 REF_NO_DEREF
, UPDATE_REFS_MSG_ON_ERR
))
1813 error(command
== TODO_REVERT
1814 ? _("could not revert %s... %s")
1815 : _("could not apply %s... %s"),
1816 short_commit_name(commit
), msg
.subject
);
1817 print_advice(res
== 1, opts
);
1818 rerere(opts
->allow_rerere_auto
);
1822 allow
= allow_empty(opts
, commit
);
1827 flags
|= ALLOW_EMPTY
;
1828 if (!opts
->no_commit
) {
1830 if (author
|| command
== TODO_REVERT
|| (flags
& AMEND_MSG
))
1831 res
= do_commit(msg_file
, author
, opts
, flags
);
1833 res
= error(_("unable to parse commit author"));
1836 if (!res
&& final_fixup
) {
1837 unlink(rebase_path_fixup_msg());
1838 unlink(rebase_path_squash_msg());
1839 unlink(rebase_path_current_fixups());
1840 strbuf_reset(&opts
->current_fixups
);
1841 opts
->current_fixup_count
= 0;
1845 free_message(commit
, &msg
);
1847 update_abort_safety_file();
1852 static int prepare_revs(struct replay_opts
*opts
)
1855 * picking (but not reverting) ranges (but not individual revisions)
1856 * should be done in reverse
1858 if (opts
->action
== REPLAY_PICK
&& !opts
->revs
->no_walk
)
1859 opts
->revs
->reverse
^= 1;
1861 if (prepare_revision_walk(opts
->revs
))
1862 return error(_("revision walk setup failed"));
1864 if (!opts
->revs
->commits
)
1865 return error(_("empty commit set passed"));
1869 static int read_and_refresh_cache(struct replay_opts
*opts
)
1871 struct lock_file index_lock
= LOCK_INIT
;
1872 int index_fd
= hold_locked_index(&index_lock
, 0);
1873 if (read_index_preload(&the_index
, NULL
) < 0) {
1874 rollback_lock_file(&index_lock
);
1875 return error(_("git %s: failed to read the index"),
1876 _(action_name(opts
)));
1878 refresh_index(&the_index
, REFRESH_QUIET
|REFRESH_UNMERGED
, NULL
, NULL
, NULL
);
1879 if (index_fd
>= 0) {
1880 if (write_locked_index(&the_index
, &index_lock
,
1881 COMMIT_LOCK
| SKIP_IF_UNCHANGED
)) {
1882 return error(_("git %s: failed to refresh the index"),
1883 _(action_name(opts
)));
1889 enum todo_item_flags
{
1890 TODO_EDIT_MERGE_MSG
= 1
1894 enum todo_command command
;
1895 struct commit
*commit
;
1899 size_t offset_in_buf
;
1904 struct todo_item
*items
;
1905 int nr
, alloc
, current
;
1906 int done_nr
, total_nr
;
1907 struct stat_data stat
;
1910 #define TODO_LIST_INIT { STRBUF_INIT }
1912 static void todo_list_release(struct todo_list
*todo_list
)
1914 strbuf_release(&todo_list
->buf
);
1915 FREE_AND_NULL(todo_list
->items
);
1916 todo_list
->nr
= todo_list
->alloc
= 0;
1919 static struct todo_item
*append_new_todo(struct todo_list
*todo_list
)
1921 ALLOC_GROW(todo_list
->items
, todo_list
->nr
+ 1, todo_list
->alloc
);
1922 return todo_list
->items
+ todo_list
->nr
++;
1925 static int parse_insn_line(struct todo_item
*item
, const char *bol
, char *eol
)
1927 struct object_id commit_oid
;
1928 char *end_of_object_name
;
1929 int i
, saved
, status
, padding
;
1934 bol
+= strspn(bol
, " \t");
1936 if (bol
== eol
|| *bol
== '\r' || *bol
== comment_line_char
) {
1937 item
->command
= TODO_COMMENT
;
1938 item
->commit
= NULL
;
1940 item
->arg_len
= eol
- bol
;
1944 for (i
= 0; i
< TODO_COMMENT
; i
++)
1945 if (skip_prefix(bol
, todo_command_info
[i
].str
, &bol
)) {
1948 } else if (bol
[1] == ' ' && *bol
== todo_command_info
[i
].c
) {
1953 if (i
>= TODO_COMMENT
)
1956 /* Eat up extra spaces/ tabs before object name */
1957 padding
= strspn(bol
, " \t");
1960 if (item
->command
== TODO_NOOP
) {
1962 return error(_("%s does not accept arguments: '%s'"),
1963 command_to_string(item
->command
), bol
);
1964 item
->commit
= NULL
;
1966 item
->arg_len
= eol
- bol
;
1971 return error(_("missing arguments for %s"),
1972 command_to_string(item
->command
));
1974 if (item
->command
== TODO_EXEC
|| item
->command
== TODO_LABEL
||
1975 item
->command
== TODO_RESET
) {
1976 item
->commit
= NULL
;
1978 item
->arg_len
= (int)(eol
- bol
);
1982 if (item
->command
== TODO_MERGE
) {
1983 if (skip_prefix(bol
, "-C", &bol
))
1984 bol
+= strspn(bol
, " \t");
1985 else if (skip_prefix(bol
, "-c", &bol
)) {
1986 bol
+= strspn(bol
, " \t");
1987 item
->flags
|= TODO_EDIT_MERGE_MSG
;
1989 item
->flags
|= TODO_EDIT_MERGE_MSG
;
1990 item
->commit
= NULL
;
1992 item
->arg_len
= (int)(eol
- bol
);
1997 end_of_object_name
= (char *) bol
+ strcspn(bol
, " \t\n");
1998 saved
= *end_of_object_name
;
1999 *end_of_object_name
= '\0';
2000 status
= get_oid(bol
, &commit_oid
);
2001 *end_of_object_name
= saved
;
2003 item
->arg
= end_of_object_name
+ strspn(end_of_object_name
, " \t");
2004 item
->arg_len
= (int)(eol
- item
->arg
);
2009 item
->commit
= lookup_commit_reference(&commit_oid
);
2010 return !item
->commit
;
2013 static int parse_insn_buffer(char *buf
, struct todo_list
*todo_list
)
2015 struct todo_item
*item
;
2016 char *p
= buf
, *next_p
;
2017 int i
, res
= 0, fixup_okay
= file_exists(rebase_path_done());
2019 for (i
= 1; *p
; i
++, p
= next_p
) {
2020 char *eol
= strchrnul(p
, '\n');
2022 next_p
= *eol
? eol
+ 1 /* skip LF */ : eol
;
2024 if (p
!= eol
&& eol
[-1] == '\r')
2025 eol
--; /* strip Carriage Return */
2027 item
= append_new_todo(todo_list
);
2028 item
->offset_in_buf
= p
- todo_list
->buf
.buf
;
2029 if (parse_insn_line(item
, p
, eol
)) {
2030 res
= error(_("invalid line %d: %.*s"),
2031 i
, (int)(eol
- p
), p
);
2032 item
->command
= TODO_NOOP
;
2037 else if (is_fixup(item
->command
))
2038 return error(_("cannot '%s' without a previous commit"),
2039 command_to_string(item
->command
));
2040 else if (!is_noop(item
->command
))
2047 static int count_commands(struct todo_list
*todo_list
)
2051 for (i
= 0; i
< todo_list
->nr
; i
++)
2052 if (todo_list
->items
[i
].command
!= TODO_COMMENT
)
2058 static int get_item_line_offset(struct todo_list
*todo_list
, int index
)
2060 return index
< todo_list
->nr
?
2061 todo_list
->items
[index
].offset_in_buf
: todo_list
->buf
.len
;
2064 static const char *get_item_line(struct todo_list
*todo_list
, int index
)
2066 return todo_list
->buf
.buf
+ get_item_line_offset(todo_list
, index
);
2069 static int get_item_line_length(struct todo_list
*todo_list
, int index
)
2071 return get_item_line_offset(todo_list
, index
+ 1)
2072 - get_item_line_offset(todo_list
, index
);
2075 static ssize_t
strbuf_read_file_or_whine(struct strbuf
*sb
, const char *path
)
2080 fd
= open(path
, O_RDONLY
);
2082 return error_errno(_("could not open '%s'"), path
);
2083 len
= strbuf_read(sb
, fd
, 0);
2086 return error(_("could not read '%s'."), path
);
2090 static int read_populate_todo(struct todo_list
*todo_list
,
2091 struct replay_opts
*opts
)
2094 const char *todo_file
= get_todo_path(opts
);
2097 strbuf_reset(&todo_list
->buf
);
2098 if (strbuf_read_file_or_whine(&todo_list
->buf
, todo_file
) < 0)
2101 res
= stat(todo_file
, &st
);
2103 return error(_("could not stat '%s'"), todo_file
);
2104 fill_stat_data(&todo_list
->stat
, &st
);
2106 res
= parse_insn_buffer(todo_list
->buf
.buf
, todo_list
);
2108 if (is_rebase_i(opts
))
2109 return error(_("please fix this using "
2110 "'git rebase --edit-todo'."));
2111 return error(_("unusable instruction sheet: '%s'"), todo_file
);
2114 if (!todo_list
->nr
&&
2115 (!is_rebase_i(opts
) || !file_exists(rebase_path_done())))
2116 return error(_("no commits parsed."));
2118 if (!is_rebase_i(opts
)) {
2119 enum todo_command valid
=
2120 opts
->action
== REPLAY_PICK
? TODO_PICK
: TODO_REVERT
;
2123 for (i
= 0; i
< todo_list
->nr
; i
++)
2124 if (valid
== todo_list
->items
[i
].command
)
2126 else if (valid
== TODO_PICK
)
2127 return error(_("cannot cherry-pick during a revert."));
2129 return error(_("cannot revert during a cherry-pick."));
2132 if (is_rebase_i(opts
)) {
2133 struct todo_list done
= TODO_LIST_INIT
;
2134 FILE *f
= fopen_or_warn(rebase_path_msgtotal(), "w");
2136 if (strbuf_read_file(&done
.buf
, rebase_path_done(), 0) > 0 &&
2137 !parse_insn_buffer(done
.buf
.buf
, &done
))
2138 todo_list
->done_nr
= count_commands(&done
);
2140 todo_list
->done_nr
= 0;
2142 todo_list
->total_nr
= todo_list
->done_nr
2143 + count_commands(todo_list
);
2144 todo_list_release(&done
);
2147 fprintf(f
, "%d\n", todo_list
->total_nr
);
2155 static int git_config_string_dup(char **dest
,
2156 const char *var
, const char *value
)
2159 return config_error_nonbool(var
);
2161 *dest
= xstrdup(value
);
2165 static int populate_opts_cb(const char *key
, const char *value
, void *data
)
2167 struct replay_opts
*opts
= data
;
2172 else if (!strcmp(key
, "options.no-commit"))
2173 opts
->no_commit
= git_config_bool_or_int(key
, value
, &error_flag
);
2174 else if (!strcmp(key
, "options.edit"))
2175 opts
->edit
= git_config_bool_or_int(key
, value
, &error_flag
);
2176 else if (!strcmp(key
, "options.signoff"))
2177 opts
->signoff
= git_config_bool_or_int(key
, value
, &error_flag
);
2178 else if (!strcmp(key
, "options.record-origin"))
2179 opts
->record_origin
= git_config_bool_or_int(key
, value
, &error_flag
);
2180 else if (!strcmp(key
, "options.allow-ff"))
2181 opts
->allow_ff
= git_config_bool_or_int(key
, value
, &error_flag
);
2182 else if (!strcmp(key
, "options.mainline"))
2183 opts
->mainline
= git_config_int(key
, value
);
2184 else if (!strcmp(key
, "options.strategy"))
2185 git_config_string_dup(&opts
->strategy
, key
, value
);
2186 else if (!strcmp(key
, "options.gpg-sign"))
2187 git_config_string_dup(&opts
->gpg_sign
, key
, value
);
2188 else if (!strcmp(key
, "options.strategy-option")) {
2189 ALLOC_GROW(opts
->xopts
, opts
->xopts_nr
+ 1, opts
->xopts_alloc
);
2190 opts
->xopts
[opts
->xopts_nr
++] = xstrdup(value
);
2191 } else if (!strcmp(key
, "options.allow-rerere-auto"))
2192 opts
->allow_rerere_auto
=
2193 git_config_bool_or_int(key
, value
, &error_flag
) ?
2194 RERERE_AUTOUPDATE
: RERERE_NOAUTOUPDATE
;
2196 return error(_("invalid key: %s"), key
);
2199 return error(_("invalid value for %s: %s"), key
, value
);
2204 static void read_strategy_opts(struct replay_opts
*opts
, struct strbuf
*buf
)
2209 if (!read_oneliner(buf
, rebase_path_strategy(), 0))
2211 opts
->strategy
= strbuf_detach(buf
, NULL
);
2212 if (!read_oneliner(buf
, rebase_path_strategy_opts(), 0))
2215 opts
->xopts_nr
= split_cmdline(buf
->buf
, (const char ***)&opts
->xopts
);
2216 for (i
= 0; i
< opts
->xopts_nr
; i
++) {
2217 const char *arg
= opts
->xopts
[i
];
2219 skip_prefix(arg
, "--", &arg
);
2220 opts
->xopts
[i
] = xstrdup(arg
);
2224 static int read_populate_opts(struct replay_opts
*opts
)
2226 if (is_rebase_i(opts
)) {
2227 struct strbuf buf
= STRBUF_INIT
;
2229 if (read_oneliner(&buf
, rebase_path_gpg_sign_opt(), 1)) {
2230 if (!starts_with(buf
.buf
, "-S"))
2233 free(opts
->gpg_sign
);
2234 opts
->gpg_sign
= xstrdup(buf
.buf
+ 2);
2239 if (read_oneliner(&buf
, rebase_path_allow_rerere_autoupdate(), 1)) {
2240 if (!strcmp(buf
.buf
, "--rerere-autoupdate"))
2241 opts
->allow_rerere_auto
= RERERE_AUTOUPDATE
;
2242 else if (!strcmp(buf
.buf
, "--no-rerere-autoupdate"))
2243 opts
->allow_rerere_auto
= RERERE_NOAUTOUPDATE
;
2247 if (file_exists(rebase_path_verbose()))
2250 if (file_exists(rebase_path_signoff())) {
2255 read_strategy_opts(opts
, &buf
);
2256 strbuf_release(&buf
);
2258 if (read_oneliner(&opts
->current_fixups
,
2259 rebase_path_current_fixups(), 1)) {
2260 const char *p
= opts
->current_fixups
.buf
;
2261 opts
->current_fixup_count
= 1;
2262 while ((p
= strchr(p
, '\n'))) {
2263 opts
->current_fixup_count
++;
2268 if (read_oneliner(&buf
, rebase_path_squash_onto(), 0)) {
2269 if (get_oid_hex(buf
.buf
, &opts
->squash_onto
) < 0)
2270 return error(_("unusable squash-onto"));
2271 opts
->have_squash_onto
= 1;
2277 if (!file_exists(git_path_opts_file()))
2280 * The function git_parse_source(), called from git_config_from_file(),
2281 * may die() in case of a syntactically incorrect file. We do not care
2282 * about this case, though, because we wrote that file ourselves, so we
2283 * are pretty certain that it is syntactically correct.
2285 if (git_config_from_file(populate_opts_cb
, git_path_opts_file(), opts
) < 0)
2286 return error(_("malformed options sheet: '%s'"),
2287 git_path_opts_file());
2291 static int walk_revs_populate_todo(struct todo_list
*todo_list
,
2292 struct replay_opts
*opts
)
2294 enum todo_command command
= opts
->action
== REPLAY_PICK
?
2295 TODO_PICK
: TODO_REVERT
;
2296 const char *command_string
= todo_command_info
[command
].str
;
2297 struct commit
*commit
;
2299 if (prepare_revs(opts
))
2302 while ((commit
= get_revision(opts
->revs
))) {
2303 struct todo_item
*item
= append_new_todo(todo_list
);
2304 const char *commit_buffer
= get_commit_buffer(commit
, NULL
);
2305 const char *subject
;
2308 item
->command
= command
;
2309 item
->commit
= commit
;
2312 item
->offset_in_buf
= todo_list
->buf
.len
;
2313 subject_len
= find_commit_subject(commit_buffer
, &subject
);
2314 strbuf_addf(&todo_list
->buf
, "%s %s %.*s\n", command_string
,
2315 short_commit_name(commit
), subject_len
, subject
);
2316 unuse_commit_buffer(commit
, commit_buffer
);
2321 static int create_seq_dir(void)
2323 if (file_exists(git_path_seq_dir())) {
2324 error(_("a cherry-pick or revert is already in progress"));
2325 advise(_("try \"git cherry-pick (--continue | --quit | --abort)\""));
2327 } else if (mkdir(git_path_seq_dir(), 0777) < 0)
2328 return error_errno(_("could not create sequencer directory '%s'"),
2329 git_path_seq_dir());
2333 static int save_head(const char *head
)
2335 struct lock_file head_lock
= LOCK_INIT
;
2336 struct strbuf buf
= STRBUF_INIT
;
2340 fd
= hold_lock_file_for_update(&head_lock
, git_path_head_file(), 0);
2342 return error_errno(_("could not lock HEAD"));
2343 strbuf_addf(&buf
, "%s\n", head
);
2344 written
= write_in_full(fd
, buf
.buf
, buf
.len
);
2345 strbuf_release(&buf
);
2347 error_errno(_("could not write to '%s'"), git_path_head_file());
2348 rollback_lock_file(&head_lock
);
2351 if (commit_lock_file(&head_lock
) < 0)
2352 return error(_("failed to finalize '%s'"), git_path_head_file());
2356 static int rollback_is_safe(void)
2358 struct strbuf sb
= STRBUF_INIT
;
2359 struct object_id expected_head
, actual_head
;
2361 if (strbuf_read_file(&sb
, git_path_abort_safety_file(), 0) >= 0) {
2363 if (get_oid_hex(sb
.buf
, &expected_head
)) {
2364 strbuf_release(&sb
);
2365 die(_("could not parse %s"), git_path_abort_safety_file());
2367 strbuf_release(&sb
);
2369 else if (errno
== ENOENT
)
2370 oidclr(&expected_head
);
2372 die_errno(_("could not read '%s'"), git_path_abort_safety_file());
2374 if (get_oid("HEAD", &actual_head
))
2375 oidclr(&actual_head
);
2377 return !oidcmp(&actual_head
, &expected_head
);
2380 static int reset_for_rollback(const struct object_id
*oid
)
2382 const char *argv
[4]; /* reset --merge <arg> + NULL */
2385 argv
[1] = "--merge";
2386 argv
[2] = oid_to_hex(oid
);
2388 return run_command_v_opt(argv
, RUN_GIT_CMD
);
2391 static int rollback_single_pick(void)
2393 struct object_id head_oid
;
2395 if (!file_exists(git_path_cherry_pick_head()) &&
2396 !file_exists(git_path_revert_head()))
2397 return error(_("no cherry-pick or revert in progress"));
2398 if (read_ref_full("HEAD", 0, &head_oid
, NULL
))
2399 return error(_("cannot resolve HEAD"));
2400 if (is_null_oid(&head_oid
))
2401 return error(_("cannot abort from a branch yet to be born"));
2402 return reset_for_rollback(&head_oid
);
2405 int sequencer_rollback(struct replay_opts
*opts
)
2408 struct object_id oid
;
2409 struct strbuf buf
= STRBUF_INIT
;
2412 f
= fopen(git_path_head_file(), "r");
2413 if (!f
&& errno
== ENOENT
) {
2415 * There is no multiple-cherry-pick in progress.
2416 * If CHERRY_PICK_HEAD or REVERT_HEAD indicates
2417 * a single-cherry-pick in progress, abort that.
2419 return rollback_single_pick();
2422 return error_errno(_("cannot open '%s'"), git_path_head_file());
2423 if (strbuf_getline_lf(&buf
, f
)) {
2424 error(_("cannot read '%s': %s"), git_path_head_file(),
2425 ferror(f
) ? strerror(errno
) : _("unexpected end of file"));
2430 if (parse_oid_hex(buf
.buf
, &oid
, &p
) || *p
!= '\0') {
2431 error(_("stored pre-cherry-pick HEAD file '%s' is corrupt"),
2432 git_path_head_file());
2435 if (is_null_oid(&oid
)) {
2436 error(_("cannot abort from a branch yet to be born"));
2440 if (!rollback_is_safe()) {
2441 /* Do not error, just do not rollback */
2442 warning(_("You seem to have moved HEAD. "
2443 "Not rewinding, check your HEAD!"));
2445 if (reset_for_rollback(&oid
))
2447 strbuf_release(&buf
);
2448 return sequencer_remove_state(opts
);
2450 strbuf_release(&buf
);
2454 static int save_todo(struct todo_list
*todo_list
, struct replay_opts
*opts
)
2456 struct lock_file todo_lock
= LOCK_INIT
;
2457 const char *todo_path
= get_todo_path(opts
);
2458 int next
= todo_list
->current
, offset
, fd
;
2461 * rebase -i writes "git-rebase-todo" without the currently executing
2462 * command, appending it to "done" instead.
2464 if (is_rebase_i(opts
))
2467 fd
= hold_lock_file_for_update(&todo_lock
, todo_path
, 0);
2469 return error_errno(_("could not lock '%s'"), todo_path
);
2470 offset
= get_item_line_offset(todo_list
, next
);
2471 if (write_in_full(fd
, todo_list
->buf
.buf
+ offset
,
2472 todo_list
->buf
.len
- offset
) < 0)
2473 return error_errno(_("could not write to '%s'"), todo_path
);
2474 if (commit_lock_file(&todo_lock
) < 0)
2475 return error(_("failed to finalize '%s'"), todo_path
);
2477 if (is_rebase_i(opts
) && next
> 0) {
2478 const char *done
= rebase_path_done();
2479 int fd
= open(done
, O_CREAT
| O_WRONLY
| O_APPEND
, 0666);
2484 if (write_in_full(fd
, get_item_line(todo_list
, next
- 1),
2485 get_item_line_length(todo_list
, next
- 1))
2487 ret
= error_errno(_("could not write to '%s'"), done
);
2489 ret
= error_errno(_("failed to finalize '%s'"), done
);
2495 static int save_opts(struct replay_opts
*opts
)
2497 const char *opts_file
= git_path_opts_file();
2500 if (opts
->no_commit
)
2501 res
|= git_config_set_in_file_gently(opts_file
, "options.no-commit", "true");
2503 res
|= git_config_set_in_file_gently(opts_file
, "options.edit", "true");
2505 res
|= git_config_set_in_file_gently(opts_file
, "options.signoff", "true");
2506 if (opts
->record_origin
)
2507 res
|= git_config_set_in_file_gently(opts_file
, "options.record-origin", "true");
2509 res
|= git_config_set_in_file_gently(opts_file
, "options.allow-ff", "true");
2510 if (opts
->mainline
) {
2511 struct strbuf buf
= STRBUF_INIT
;
2512 strbuf_addf(&buf
, "%d", opts
->mainline
);
2513 res
|= git_config_set_in_file_gently(opts_file
, "options.mainline", buf
.buf
);
2514 strbuf_release(&buf
);
2517 res
|= git_config_set_in_file_gently(opts_file
, "options.strategy", opts
->strategy
);
2519 res
|= git_config_set_in_file_gently(opts_file
, "options.gpg-sign", opts
->gpg_sign
);
2522 for (i
= 0; i
< opts
->xopts_nr
; i
++)
2523 res
|= git_config_set_multivar_in_file_gently(opts_file
,
2524 "options.strategy-option",
2525 opts
->xopts
[i
], "^$", 0);
2527 if (opts
->allow_rerere_auto
)
2528 res
|= git_config_set_in_file_gently(opts_file
, "options.allow-rerere-auto",
2529 opts
->allow_rerere_auto
== RERERE_AUTOUPDATE
?
2534 static int make_patch(struct commit
*commit
, struct replay_opts
*opts
)
2536 struct strbuf buf
= STRBUF_INIT
;
2537 struct rev_info log_tree_opt
;
2538 const char *subject
, *p
;
2541 p
= short_commit_name(commit
);
2542 if (write_message(p
, strlen(p
), rebase_path_stopped_sha(), 1) < 0)
2544 if (update_ref("rebase", "REBASE_HEAD", &commit
->object
.oid
,
2545 NULL
, REF_NO_DEREF
, UPDATE_REFS_MSG_ON_ERR
))
2546 res
|= error(_("could not update %s"), "REBASE_HEAD");
2548 strbuf_addf(&buf
, "%s/patch", get_dir(opts
));
2549 memset(&log_tree_opt
, 0, sizeof(log_tree_opt
));
2550 init_revisions(&log_tree_opt
, NULL
);
2551 log_tree_opt
.abbrev
= 0;
2552 log_tree_opt
.diff
= 1;
2553 log_tree_opt
.diffopt
.output_format
= DIFF_FORMAT_PATCH
;
2554 log_tree_opt
.disable_stdin
= 1;
2555 log_tree_opt
.no_commit_id
= 1;
2556 log_tree_opt
.diffopt
.file
= fopen(buf
.buf
, "w");
2557 log_tree_opt
.diffopt
.use_color
= GIT_COLOR_NEVER
;
2558 if (!log_tree_opt
.diffopt
.file
)
2559 res
|= error_errno(_("could not open '%s'"), buf
.buf
);
2561 res
|= log_tree_commit(&log_tree_opt
, commit
);
2562 fclose(log_tree_opt
.diffopt
.file
);
2566 strbuf_addf(&buf
, "%s/message", get_dir(opts
));
2567 if (!file_exists(buf
.buf
)) {
2568 const char *commit_buffer
= get_commit_buffer(commit
, NULL
);
2569 find_commit_subject(commit_buffer
, &subject
);
2570 res
|= write_message(subject
, strlen(subject
), buf
.buf
, 1);
2571 unuse_commit_buffer(commit
, commit_buffer
);
2573 strbuf_release(&buf
);
2578 static int intend_to_amend(void)
2580 struct object_id head
;
2583 if (get_oid("HEAD", &head
))
2584 return error(_("cannot read HEAD"));
2586 p
= oid_to_hex(&head
);
2587 return write_message(p
, strlen(p
), rebase_path_amend(), 1);
2590 static int error_with_patch(struct commit
*commit
,
2591 const char *subject
, int subject_len
,
2592 struct replay_opts
*opts
, int exit_code
, int to_amend
)
2594 if (make_patch(commit
, opts
))
2598 if (intend_to_amend())
2601 fprintf(stderr
, "You can amend the commit now, with\n"
2603 " git commit --amend %s\n"
2605 "Once you are satisfied with your changes, run\n"
2607 " git rebase --continue\n", gpg_sign_opt_quoted(opts
));
2608 } else if (exit_code
)
2609 fprintf(stderr
, "Could not apply %s... %.*s\n",
2610 short_commit_name(commit
), subject_len
, subject
);
2615 static int error_failed_squash(struct commit
*commit
,
2616 struct replay_opts
*opts
, int subject_len
, const char *subject
)
2618 if (copy_file(rebase_path_message(), rebase_path_squash_msg(), 0666))
2619 return error(_("could not copy '%s' to '%s'"),
2620 rebase_path_squash_msg(), rebase_path_message());
2621 unlink(git_path_merge_msg());
2622 if (copy_file(git_path_merge_msg(), rebase_path_message(), 0666))
2623 return error(_("could not copy '%s' to '%s'"),
2624 rebase_path_message(), git_path_merge_msg());
2625 return error_with_patch(commit
, subject
, subject_len
, opts
, 1, 0);
2628 static int do_exec(const char *command_line
)
2630 struct argv_array child_env
= ARGV_ARRAY_INIT
;
2631 const char *child_argv
[] = { NULL
, NULL
};
2634 fprintf(stderr
, "Executing: %s\n", command_line
);
2635 child_argv
[0] = command_line
;
2636 argv_array_pushf(&child_env
, "GIT_DIR=%s", absolute_path(get_git_dir()));
2637 status
= run_command_v_opt_cd_env(child_argv
, RUN_USING_SHELL
, NULL
,
2640 /* force re-reading of the cache */
2641 if (discard_cache() < 0 || read_cache() < 0)
2642 return error(_("could not read index"));
2644 dirty
= require_clean_work_tree("rebase", NULL
, 1, 1);
2647 warning(_("execution failed: %s\n%s"
2648 "You can fix the problem, and then run\n"
2650 " git rebase --continue\n"
2653 dirty
? N_("and made changes to the index and/or the "
2654 "working tree\n") : "");
2656 /* command not found */
2659 warning(_("execution succeeded: %s\nbut "
2660 "left changes to the index and/or the working tree\n"
2661 "Commit or stash your changes, and then run\n"
2663 " git rebase --continue\n"
2664 "\n"), command_line
);
2668 argv_array_clear(&child_env
);
2673 static int safe_append(const char *filename
, const char *fmt
, ...)
2676 struct lock_file lock
= LOCK_INIT
;
2677 int fd
= hold_lock_file_for_update(&lock
, filename
,
2678 LOCK_REPORT_ON_ERROR
);
2679 struct strbuf buf
= STRBUF_INIT
;
2684 if (strbuf_read_file(&buf
, filename
, 0) < 0 && errno
!= ENOENT
) {
2685 error_errno(_("could not read '%s'"), filename
);
2686 rollback_lock_file(&lock
);
2689 strbuf_complete(&buf
, '\n');
2691 strbuf_vaddf(&buf
, fmt
, ap
);
2694 if (write_in_full(fd
, buf
.buf
, buf
.len
) < 0) {
2695 error_errno(_("could not write to '%s'"), filename
);
2696 strbuf_release(&buf
);
2697 rollback_lock_file(&lock
);
2700 if (commit_lock_file(&lock
) < 0) {
2701 strbuf_release(&buf
);
2702 rollback_lock_file(&lock
);
2703 return error(_("failed to finalize '%s'"), filename
);
2706 strbuf_release(&buf
);
2710 static int do_label(const char *name
, int len
)
2712 struct ref_store
*refs
= get_main_ref_store(the_repository
);
2713 struct ref_transaction
*transaction
;
2714 struct strbuf ref_name
= STRBUF_INIT
, err
= STRBUF_INIT
;
2715 struct strbuf msg
= STRBUF_INIT
;
2717 struct object_id head_oid
;
2719 if (len
== 1 && *name
== '#')
2720 return error("Illegal label name: '%.*s'", len
, name
);
2722 strbuf_addf(&ref_name
, "refs/rewritten/%.*s", len
, name
);
2723 strbuf_addf(&msg
, "rebase -i (label) '%.*s'", len
, name
);
2725 transaction
= ref_store_transaction_begin(refs
, &err
);
2727 error("%s", err
.buf
);
2729 } else if (get_oid("HEAD", &head_oid
)) {
2730 error(_("could not read HEAD"));
2732 } else if (ref_transaction_update(transaction
, ref_name
.buf
, &head_oid
,
2733 NULL
, 0, msg
.buf
, &err
) < 0 ||
2734 ref_transaction_commit(transaction
, &err
)) {
2735 error("%s", err
.buf
);
2738 ref_transaction_free(transaction
);
2739 strbuf_release(&err
);
2740 strbuf_release(&msg
);
2743 ret
= safe_append(rebase_path_refs_to_delete(),
2744 "%s\n", ref_name
.buf
);
2745 strbuf_release(&ref_name
);
2750 static const char *reflog_message(struct replay_opts
*opts
,
2751 const char *sub_action
, const char *fmt
, ...);
2753 static int do_reset(const char *name
, int len
, struct replay_opts
*opts
)
2755 struct strbuf ref_name
= STRBUF_INIT
;
2756 struct object_id oid
;
2757 struct lock_file lock
= LOCK_INIT
;
2758 struct tree_desc desc
;
2760 struct unpack_trees_options unpack_tree_opts
;
2763 if (hold_locked_index(&lock
, LOCK_REPORT_ON_ERROR
) < 0)
2766 if (len
== 10 && !strncmp("[new root]", name
, len
)) {
2767 if (!opts
->have_squash_onto
) {
2769 if (commit_tree("", 0, the_hash_algo
->empty_tree
,
2770 NULL
, &opts
->squash_onto
,
2772 return error(_("writing fake root commit"));
2773 opts
->have_squash_onto
= 1;
2774 hex
= oid_to_hex(&opts
->squash_onto
);
2775 if (write_message(hex
, strlen(hex
),
2776 rebase_path_squash_onto(), 0))
2777 return error(_("writing squash-onto"));
2779 oidcpy(&oid
, &opts
->squash_onto
);
2781 /* Determine the length of the label */
2782 for (i
= 0; i
< len
; i
++)
2783 if (isspace(name
[i
]))
2786 strbuf_addf(&ref_name
, "refs/rewritten/%.*s", len
, name
);
2787 if (get_oid(ref_name
.buf
, &oid
) &&
2788 get_oid(ref_name
.buf
+ strlen("refs/rewritten/"), &oid
)) {
2789 error(_("could not read '%s'"), ref_name
.buf
);
2790 rollback_lock_file(&lock
);
2791 strbuf_release(&ref_name
);
2796 memset(&unpack_tree_opts
, 0, sizeof(unpack_tree_opts
));
2797 setup_unpack_trees_porcelain(&unpack_tree_opts
, "reset");
2798 unpack_tree_opts
.head_idx
= 1;
2799 unpack_tree_opts
.src_index
= &the_index
;
2800 unpack_tree_opts
.dst_index
= &the_index
;
2801 unpack_tree_opts
.fn
= oneway_merge
;
2802 unpack_tree_opts
.merge
= 1;
2803 unpack_tree_opts
.update
= 1;
2805 if (read_cache_unmerged()) {
2806 rollback_lock_file(&lock
);
2807 strbuf_release(&ref_name
);
2808 return error_resolve_conflict(_(action_name(opts
)));
2811 if (!fill_tree_descriptor(&desc
, &oid
)) {
2812 error(_("failed to find tree of %s"), oid_to_hex(&oid
));
2813 rollback_lock_file(&lock
);
2814 free((void *)desc
.buffer
);
2815 strbuf_release(&ref_name
);
2819 if (unpack_trees(1, &desc
, &unpack_tree_opts
)) {
2820 rollback_lock_file(&lock
);
2821 free((void *)desc
.buffer
);
2822 strbuf_release(&ref_name
);
2826 tree
= parse_tree_indirect(&oid
);
2827 prime_cache_tree(&the_index
, tree
);
2829 if (write_locked_index(&the_index
, &lock
, COMMIT_LOCK
) < 0)
2830 ret
= error(_("could not write index"));
2831 free((void *)desc
.buffer
);
2834 ret
= update_ref(reflog_message(opts
, "reset", "'%.*s'",
2835 len
, name
), "HEAD", &oid
,
2836 NULL
, 0, UPDATE_REFS_MSG_ON_ERR
);
2838 strbuf_release(&ref_name
);
2842 static int do_merge(struct commit
*commit
, const char *arg
, int arg_len
,
2843 int flags
, struct replay_opts
*opts
)
2845 int run_commit_flags
= (flags
& TODO_EDIT_MERGE_MSG
) ?
2846 EDIT_MSG
| VERIFY_MSG
: 0;
2847 struct strbuf ref_name
= STRBUF_INIT
;
2848 struct commit
*head_commit
, *merge_commit
, *i
;
2849 struct commit_list
*bases
, *j
, *reversed
= NULL
;
2850 struct merge_options o
;
2851 int merge_arg_len
, oneline_offset
, can_fast_forward
, ret
;
2852 static struct lock_file lock
;
2855 if (hold_locked_index(&lock
, LOCK_REPORT_ON_ERROR
) < 0) {
2860 head_commit
= lookup_commit_reference_by_name("HEAD");
2862 ret
= error(_("cannot merge without a current revision"));
2866 oneline_offset
= arg_len
;
2867 merge_arg_len
= strcspn(arg
, " \t\n");
2868 p
= arg
+ merge_arg_len
;
2869 p
+= strspn(p
, " \t\n");
2870 if (*p
== '#' && (!p
[1] || isspace(p
[1]))) {
2871 p
+= 1 + strspn(p
+ 1, " \t\n");
2872 oneline_offset
= p
- arg
;
2873 } else if (p
- arg
< arg_len
)
2874 BUG("octopus merges are not supported yet: '%s'", p
);
2876 strbuf_addf(&ref_name
, "refs/rewritten/%.*s", merge_arg_len
, arg
);
2877 merge_commit
= lookup_commit_reference_by_name(ref_name
.buf
);
2878 if (!merge_commit
) {
2879 /* fall back to non-rewritten ref or commit */
2880 strbuf_splice(&ref_name
, 0, strlen("refs/rewritten/"), "", 0);
2881 merge_commit
= lookup_commit_reference_by_name(ref_name
.buf
);
2884 if (!merge_commit
) {
2885 ret
= error(_("could not resolve '%s'"), ref_name
.buf
);
2889 if (opts
->have_squash_onto
&&
2890 !oidcmp(&head_commit
->object
.oid
, &opts
->squash_onto
)) {
2892 * When the user tells us to "merge" something into a
2893 * "[new root]", let's simply fast-forward to the merge head.
2895 rollback_lock_file(&lock
);
2896 ret
= fast_forward_to(&merge_commit
->object
.oid
,
2897 &head_commit
->object
.oid
, 0, opts
);
2902 const char *message
= get_commit_buffer(commit
, NULL
);
2907 ret
= error(_("could not get commit message of '%s'"),
2908 oid_to_hex(&commit
->object
.oid
));
2911 write_author_script(message
);
2912 find_commit_subject(message
, &body
);
2914 ret
= write_message(body
, len
, git_path_merge_msg(), 0);
2915 unuse_commit_buffer(commit
, message
);
2917 error_errno(_("could not write '%s'"),
2918 git_path_merge_msg());
2922 struct strbuf buf
= STRBUF_INIT
;
2925 strbuf_addf(&buf
, "author %s", git_author_info(0));
2926 write_author_script(buf
.buf
);
2929 if (oneline_offset
< arg_len
) {
2930 p
= arg
+ oneline_offset
;
2931 len
= arg_len
- oneline_offset
;
2933 strbuf_addf(&buf
, "Merge branch '%.*s'",
2934 merge_arg_len
, arg
);
2939 ret
= write_message(p
, len
, git_path_merge_msg(), 0);
2940 strbuf_release(&buf
);
2942 error_errno(_("could not write '%s'"),
2943 git_path_merge_msg());
2949 * If HEAD is not identical to the first parent of the original merge
2950 * commit, we cannot fast-forward.
2952 can_fast_forward
= opts
->allow_ff
&& commit
&& commit
->parents
&&
2953 !oidcmp(&commit
->parents
->item
->object
.oid
,
2954 &head_commit
->object
.oid
);
2957 * If the merge head is different from the original one, we cannot
2960 if (can_fast_forward
) {
2961 struct commit_list
*second_parent
= commit
->parents
->next
;
2963 if (second_parent
&& !second_parent
->next
&&
2964 oidcmp(&merge_commit
->object
.oid
,
2965 &second_parent
->item
->object
.oid
))
2966 can_fast_forward
= 0;
2969 if (can_fast_forward
&& commit
->parents
->next
&&
2970 !commit
->parents
->next
->next
&&
2971 !oidcmp(&commit
->parents
->next
->item
->object
.oid
,
2972 &merge_commit
->object
.oid
)) {
2973 rollback_lock_file(&lock
);
2974 ret
= fast_forward_to(&commit
->object
.oid
,
2975 &head_commit
->object
.oid
, 0, opts
);
2979 write_message(oid_to_hex(&merge_commit
->object
.oid
), GIT_SHA1_HEXSZ
,
2980 git_path_merge_head(), 0);
2981 write_message("no-ff", 5, git_path_merge_mode(), 0);
2983 bases
= get_merge_bases(head_commit
, merge_commit
);
2984 if (bases
&& !oidcmp(&merge_commit
->object
.oid
,
2985 &bases
->item
->object
.oid
)) {
2987 /* skip merging an ancestor of HEAD */
2991 for (j
= bases
; j
; j
= j
->next
)
2992 commit_list_insert(j
->item
, &reversed
);
2993 free_commit_list(bases
);
2996 init_merge_options(&o
);
2998 o
.branch2
= ref_name
.buf
;
2999 o
.buffer_output
= 2;
3001 ret
= merge_recursive(&o
, head_commit
, merge_commit
, reversed
, &i
);
3003 fputs(o
.obuf
.buf
, stdout
);
3004 strbuf_release(&o
.obuf
);
3006 error(_("could not even attempt to merge '%.*s'"),
3007 merge_arg_len
, arg
);
3011 * The return value of merge_recursive() is 1 on clean, and 0 on
3014 * Let's reverse that, so that do_merge() returns 0 upon success and
3015 * 1 upon failed merge (keeping the return value -1 for the cases where
3016 * we will want to reschedule the `merge` command).
3020 if (active_cache_changed
&&
3021 write_locked_index(&the_index
, &lock
, COMMIT_LOCK
)) {
3022 ret
= error(_("merge: Unable to write new index file"));
3026 rollback_lock_file(&lock
);
3028 rerere(opts
->allow_rerere_auto
);
3031 * In case of problems, we now want to return a positive
3032 * value (a negative one would indicate that the `merge`
3033 * command needs to be rescheduled).
3035 ret
= !!run_git_commit(git_path_merge_msg(), opts
,
3039 strbuf_release(&ref_name
);
3040 rollback_lock_file(&lock
);
3044 static int is_final_fixup(struct todo_list
*todo_list
)
3046 int i
= todo_list
->current
;
3048 if (!is_fixup(todo_list
->items
[i
].command
))
3051 while (++i
< todo_list
->nr
)
3052 if (is_fixup(todo_list
->items
[i
].command
))
3054 else if (!is_noop(todo_list
->items
[i
].command
))
3059 static enum todo_command
peek_command(struct todo_list
*todo_list
, int offset
)
3063 for (i
= todo_list
->current
+ offset
; i
< todo_list
->nr
; i
++)
3064 if (!is_noop(todo_list
->items
[i
].command
))
3065 return todo_list
->items
[i
].command
;
3070 static int apply_autostash(struct replay_opts
*opts
)
3072 struct strbuf stash_sha1
= STRBUF_INIT
;
3073 struct child_process child
= CHILD_PROCESS_INIT
;
3076 if (!read_oneliner(&stash_sha1
, rebase_path_autostash(), 1)) {
3077 strbuf_release(&stash_sha1
);
3080 strbuf_trim(&stash_sha1
);
3083 child
.no_stdout
= 1;
3084 child
.no_stderr
= 1;
3085 argv_array_push(&child
.args
, "stash");
3086 argv_array_push(&child
.args
, "apply");
3087 argv_array_push(&child
.args
, stash_sha1
.buf
);
3088 if (!run_command(&child
))
3089 fprintf(stderr
, _("Applied autostash.\n"));
3091 struct child_process store
= CHILD_PROCESS_INIT
;
3094 argv_array_push(&store
.args
, "stash");
3095 argv_array_push(&store
.args
, "store");
3096 argv_array_push(&store
.args
, "-m");
3097 argv_array_push(&store
.args
, "autostash");
3098 argv_array_push(&store
.args
, "-q");
3099 argv_array_push(&store
.args
, stash_sha1
.buf
);
3100 if (run_command(&store
))
3101 ret
= error(_("cannot store %s"), stash_sha1
.buf
);
3104 _("Applying autostash resulted in conflicts.\n"
3105 "Your changes are safe in the stash.\n"
3106 "You can run \"git stash pop\" or"
3107 " \"git stash drop\" at any time.\n"));
3110 strbuf_release(&stash_sha1
);
3114 static const char *reflog_message(struct replay_opts
*opts
,
3115 const char *sub_action
, const char *fmt
, ...)
3118 static struct strbuf buf
= STRBUF_INIT
;
3122 strbuf_addstr(&buf
, action_name(opts
));
3124 strbuf_addf(&buf
, " (%s)", sub_action
);
3126 strbuf_addstr(&buf
, ": ");
3127 strbuf_vaddf(&buf
, fmt
, ap
);
3134 static const char rescheduled_advice
[] =
3135 N_("Could not execute the todo command\n"
3139 "It has been rescheduled; To edit the command before continuing, please\n"
3140 "edit the todo list first:\n"
3142 " git rebase --edit-todo\n"
3143 " git rebase --continue\n");
3145 static int pick_commits(struct todo_list
*todo_list
, struct replay_opts
*opts
)
3147 int res
= 0, reschedule
= 0;
3149 setenv(GIT_REFLOG_ACTION
, action_name(opts
), 0);
3151 assert(!(opts
->signoff
|| opts
->no_commit
||
3152 opts
->record_origin
|| opts
->edit
));
3153 if (read_and_refresh_cache(opts
))
3156 while (todo_list
->current
< todo_list
->nr
) {
3157 struct todo_item
*item
= todo_list
->items
+ todo_list
->current
;
3158 if (save_todo(todo_list
, opts
))
3160 if (is_rebase_i(opts
)) {
3161 if (item
->command
!= TODO_COMMENT
) {
3162 FILE *f
= fopen(rebase_path_msgnum(), "w");
3164 todo_list
->done_nr
++;
3167 fprintf(f
, "%d\n", todo_list
->done_nr
);
3170 fprintf(stderr
, "Rebasing (%d/%d)%s",
3172 todo_list
->total_nr
,
3173 opts
->verbose
? "\n" : "\r");
3175 unlink(rebase_path_message());
3176 unlink(rebase_path_author_script());
3177 unlink(rebase_path_stopped_sha());
3178 unlink(rebase_path_amend());
3179 delete_ref(NULL
, "REBASE_HEAD", NULL
, REF_NO_DEREF
);
3181 if (item
->command
<= TODO_SQUASH
) {
3182 if (is_rebase_i(opts
))
3183 setenv("GIT_REFLOG_ACTION", reflog_message(opts
,
3184 command_to_string(item
->command
), NULL
),
3186 res
= do_pick_commit(item
->command
, item
->commit
,
3187 opts
, is_final_fixup(todo_list
));
3188 if (is_rebase_i(opts
) && res
< 0) {
3190 advise(_(rescheduled_advice
),
3191 get_item_line_length(todo_list
,
3192 todo_list
->current
),
3193 get_item_line(todo_list
,
3194 todo_list
->current
));
3195 todo_list
->current
--;
3196 if (save_todo(todo_list
, opts
))
3199 if (item
->command
== TODO_EDIT
) {
3200 struct commit
*commit
= item
->commit
;
3203 _("Stopped at %s... %.*s\n"),
3204 short_commit_name(commit
),
3205 item
->arg_len
, item
->arg
);
3206 return error_with_patch(commit
,
3207 item
->arg
, item
->arg_len
, opts
, res
,
3210 if (is_rebase_i(opts
) && !res
)
3211 record_in_rewritten(&item
->commit
->object
.oid
,
3212 peek_command(todo_list
, 1));
3213 if (res
&& is_fixup(item
->command
)) {
3216 return error_failed_squash(item
->commit
, opts
,
3217 item
->arg_len
, item
->arg
);
3218 } else if (res
&& is_rebase_i(opts
) && item
->commit
)
3219 return res
| error_with_patch(item
->commit
,
3220 item
->arg
, item
->arg_len
, opts
, res
,
3221 item
->command
== TODO_REWORD
);
3222 } else if (item
->command
== TODO_EXEC
) {
3223 char *end_of_arg
= (char *)(item
->arg
+ item
->arg_len
);
3224 int saved
= *end_of_arg
;
3228 res
= do_exec(item
->arg
);
3229 *end_of_arg
= saved
;
3231 /* Reread the todo file if it has changed. */
3233 ; /* fall through */
3234 else if (stat(get_todo_path(opts
), &st
))
3235 res
= error_errno(_("could not stat '%s'"),
3236 get_todo_path(opts
));
3237 else if (match_stat_data(&todo_list
->stat
, &st
)) {
3238 todo_list_release(todo_list
);
3239 if (read_populate_todo(todo_list
, opts
))
3240 res
= -1; /* message was printed */
3241 /* `current` will be incremented below */
3242 todo_list
->current
= -1;
3244 } else if (item
->command
== TODO_LABEL
) {
3245 if ((res
= do_label(item
->arg
, item
->arg_len
)))
3247 } else if (item
->command
== TODO_RESET
) {
3248 if ((res
= do_reset(item
->arg
, item
->arg_len
, opts
)))
3250 } else if (item
->command
== TODO_MERGE
) {
3251 if ((res
= do_merge(item
->commit
,
3252 item
->arg
, item
->arg_len
,
3253 item
->flags
, opts
)) < 0)
3255 else if (item
->commit
)
3256 record_in_rewritten(&item
->commit
->object
.oid
,
3257 peek_command(todo_list
, 1));
3259 /* failed with merge conflicts */
3260 return error_with_patch(item
->commit
,
3262 item
->arg_len
, opts
,
3264 } else if (!is_noop(item
->command
))
3265 return error(_("unknown command %d"), item
->command
);
3268 advise(_(rescheduled_advice
),
3269 get_item_line_length(todo_list
,
3270 todo_list
->current
),
3271 get_item_line(todo_list
, todo_list
->current
));
3272 todo_list
->current
--;
3273 if (save_todo(todo_list
, opts
))
3276 return error_with_patch(item
->commit
,
3278 item
->arg_len
, opts
,
3282 todo_list
->current
++;
3287 if (is_rebase_i(opts
)) {
3288 struct strbuf head_ref
= STRBUF_INIT
, buf
= STRBUF_INIT
;
3291 /* Stopped in the middle, as planned? */
3292 if (todo_list
->current
< todo_list
->nr
)
3295 if (read_oneliner(&head_ref
, rebase_path_head_name(), 0) &&
3296 starts_with(head_ref
.buf
, "refs/")) {
3298 struct object_id head
, orig
;
3301 if (get_oid("HEAD", &head
)) {
3302 res
= error(_("cannot read HEAD"));
3304 strbuf_release(&head_ref
);
3305 strbuf_release(&buf
);
3308 if (!read_oneliner(&buf
, rebase_path_orig_head(), 0) ||
3309 get_oid_hex(buf
.buf
, &orig
)) {
3310 res
= error(_("could not read orig-head"));
3311 goto cleanup_head_ref
;
3314 if (!read_oneliner(&buf
, rebase_path_onto(), 0)) {
3315 res
= error(_("could not read 'onto'"));
3316 goto cleanup_head_ref
;
3318 msg
= reflog_message(opts
, "finish", "%s onto %s",
3319 head_ref
.buf
, buf
.buf
);
3320 if (update_ref(msg
, head_ref
.buf
, &head
, &orig
,
3321 REF_NO_DEREF
, UPDATE_REFS_MSG_ON_ERR
)) {
3322 res
= error(_("could not update %s"),
3324 goto cleanup_head_ref
;
3326 msg
= reflog_message(opts
, "finish", "returning to %s",
3328 if (create_symref("HEAD", head_ref
.buf
, msg
)) {
3329 res
= error(_("could not update HEAD to %s"),
3331 goto cleanup_head_ref
;
3336 if (opts
->verbose
) {
3337 struct rev_info log_tree_opt
;
3338 struct object_id orig
, head
;
3340 memset(&log_tree_opt
, 0, sizeof(log_tree_opt
));
3341 init_revisions(&log_tree_opt
, NULL
);
3342 log_tree_opt
.diff
= 1;
3343 log_tree_opt
.diffopt
.output_format
=
3344 DIFF_FORMAT_DIFFSTAT
;
3345 log_tree_opt
.disable_stdin
= 1;
3347 if (read_oneliner(&buf
, rebase_path_orig_head(), 0) &&
3348 !get_oid(buf
.buf
, &orig
) &&
3349 !get_oid("HEAD", &head
)) {
3350 diff_tree_oid(&orig
, &head
, "",
3351 &log_tree_opt
.diffopt
);
3352 log_tree_diff_flush(&log_tree_opt
);
3355 flush_rewritten_pending();
3356 if (!stat(rebase_path_rewritten_list(), &st
) &&
3358 struct child_process child
= CHILD_PROCESS_INIT
;
3359 const char *post_rewrite_hook
=
3360 find_hook("post-rewrite");
3362 child
.in
= open(rebase_path_rewritten_list(), O_RDONLY
);
3364 argv_array_push(&child
.args
, "notes");
3365 argv_array_push(&child
.args
, "copy");
3366 argv_array_push(&child
.args
, "--for-rewrite=rebase");
3367 /* we don't care if this copying failed */
3368 run_command(&child
);
3370 if (post_rewrite_hook
) {
3371 struct child_process hook
= CHILD_PROCESS_INIT
;
3373 hook
.in
= open(rebase_path_rewritten_list(),
3375 hook
.stdout_to_stderr
= 1;
3376 argv_array_push(&hook
.args
, post_rewrite_hook
);
3377 argv_array_push(&hook
.args
, "rebase");
3378 /* we don't care if this hook failed */
3382 apply_autostash(opts
);
3384 fprintf(stderr
, "Successfully rebased and updated %s.\n",
3387 strbuf_release(&buf
);
3388 strbuf_release(&head_ref
);
3392 * Sequence of picks finished successfully; cleanup by
3393 * removing the .git/sequencer directory
3395 return sequencer_remove_state(opts
);
3398 static int continue_single_pick(void)
3400 const char *argv
[] = { "commit", NULL
};
3402 if (!file_exists(git_path_cherry_pick_head()) &&
3403 !file_exists(git_path_revert_head()))
3404 return error(_("no cherry-pick or revert in progress"));
3405 return run_command_v_opt(argv
, RUN_GIT_CMD
);
3408 static int commit_staged_changes(struct replay_opts
*opts
,
3409 struct todo_list
*todo_list
)
3411 unsigned int flags
= ALLOW_EMPTY
| EDIT_MSG
;
3412 unsigned int final_fixup
= 0, is_clean
;
3414 if (has_unstaged_changes(1))
3415 return error(_("cannot rebase: You have unstaged changes."));
3417 is_clean
= !has_uncommitted_changes(0);
3419 if (file_exists(rebase_path_amend())) {
3420 struct strbuf rev
= STRBUF_INIT
;
3421 struct object_id head
, to_amend
;
3423 if (get_oid("HEAD", &head
))
3424 return error(_("cannot amend non-existing commit"));
3425 if (!read_oneliner(&rev
, rebase_path_amend(), 0))
3426 return error(_("invalid file: '%s'"), rebase_path_amend());
3427 if (get_oid_hex(rev
.buf
, &to_amend
))
3428 return error(_("invalid contents: '%s'"),
3429 rebase_path_amend());
3430 if (!is_clean
&& oidcmp(&head
, &to_amend
))
3431 return error(_("\nYou have uncommitted changes in your "
3432 "working tree. Please, commit them\n"
3433 "first and then run 'git rebase "
3434 "--continue' again."));
3436 * When skipping a failed fixup/squash, we need to edit the
3437 * commit message, the current fixup list and count, and if it
3438 * was the last fixup/squash in the chain, we need to clean up
3439 * the commit message and if there was a squash, let the user
3442 if (is_clean
&& !oidcmp(&head
, &to_amend
) &&
3443 opts
->current_fixup_count
> 0 &&
3444 file_exists(rebase_path_stopped_sha())) {
3445 const char *p
= opts
->current_fixups
.buf
;
3446 int len
= opts
->current_fixups
.len
;
3448 opts
->current_fixup_count
--;
3450 BUG("Incorrect current_fixups:\n%s", p
);
3451 while (len
&& p
[len
- 1] != '\n')
3453 strbuf_setlen(&opts
->current_fixups
, len
);
3454 if (write_message(p
, len
, rebase_path_current_fixups(),
3456 return error(_("could not write file: '%s'"),
3457 rebase_path_current_fixups());
3460 * If a fixup/squash in a fixup/squash chain failed, the
3461 * commit message is already correct, no need to commit
3464 * Only if it is the final command in the fixup/squash
3465 * chain, and only if the chain is longer than a single
3466 * fixup/squash command (which was just skipped), do we
3467 * actually need to re-commit with a cleaned up commit
3470 if (opts
->current_fixup_count
> 0 &&
3471 !is_fixup(peek_command(todo_list
, 0))) {
3474 * If there was not a single "squash" in the
3475 * chain, we only need to clean up the commit
3476 * message, no need to bother the user with
3477 * opening the commit message in the editor.
3479 if (!starts_with(p
, "squash ") &&
3480 !strstr(p
, "\nsquash "))
3481 flags
= (flags
& ~EDIT_MSG
) | CLEANUP_MSG
;
3482 } else if (is_fixup(peek_command(todo_list
, 0))) {
3484 * We need to update the squash message to skip
3485 * the latest commit message.
3487 struct commit
*commit
;
3488 const char *path
= rebase_path_squash_msg();
3490 if (parse_head(&commit
) ||
3491 !(p
= get_commit_buffer(commit
, NULL
)) ||
3492 write_message(p
, strlen(p
), path
, 0)) {
3493 unuse_commit_buffer(commit
, p
);
3494 return error(_("could not write file: "
3497 unuse_commit_buffer(commit
, p
);
3501 strbuf_release(&rev
);
3506 const char *cherry_pick_head
= git_path_cherry_pick_head();
3508 if (file_exists(cherry_pick_head
) && unlink(cherry_pick_head
))
3509 return error(_("could not remove CHERRY_PICK_HEAD"));
3514 if (run_git_commit(final_fixup
? NULL
: rebase_path_message(),
3516 return error(_("could not commit staged changes."));
3517 unlink(rebase_path_amend());
3519 unlink(rebase_path_fixup_msg());
3520 unlink(rebase_path_squash_msg());
3522 if (opts
->current_fixup_count
> 0) {
3524 * Whether final fixup or not, we just cleaned up the commit
3527 unlink(rebase_path_current_fixups());
3528 strbuf_reset(&opts
->current_fixups
);
3529 opts
->current_fixup_count
= 0;
3534 int sequencer_continue(struct replay_opts
*opts
)
3536 struct todo_list todo_list
= TODO_LIST_INIT
;
3539 if (read_and_refresh_cache(opts
))
3542 if (read_populate_opts(opts
))
3544 if (is_rebase_i(opts
)) {
3545 if ((res
= read_populate_todo(&todo_list
, opts
)))
3546 goto release_todo_list
;
3547 if (commit_staged_changes(opts
, &todo_list
))
3549 } else if (!file_exists(get_todo_path(opts
)))
3550 return continue_single_pick();
3551 else if ((res
= read_populate_todo(&todo_list
, opts
)))
3552 goto release_todo_list
;
3554 if (!is_rebase_i(opts
)) {
3555 /* Verify that the conflict has been resolved */
3556 if (file_exists(git_path_cherry_pick_head()) ||
3557 file_exists(git_path_revert_head())) {
3558 res
= continue_single_pick();
3560 goto release_todo_list
;
3562 if (index_differs_from("HEAD", NULL
, 0)) {
3563 res
= error_dirty_index(opts
);
3564 goto release_todo_list
;
3566 todo_list
.current
++;
3567 } else if (file_exists(rebase_path_stopped_sha())) {
3568 struct strbuf buf
= STRBUF_INIT
;
3569 struct object_id oid
;
3571 if (read_oneliner(&buf
, rebase_path_stopped_sha(), 1) &&
3572 !get_oid_committish(buf
.buf
, &oid
))
3573 record_in_rewritten(&oid
, peek_command(&todo_list
, 0));
3574 strbuf_release(&buf
);
3577 res
= pick_commits(&todo_list
, opts
);
3579 todo_list_release(&todo_list
);
3583 static int single_pick(struct commit
*cmit
, struct replay_opts
*opts
)
3585 setenv(GIT_REFLOG_ACTION
, action_name(opts
), 0);
3586 return do_pick_commit(opts
->action
== REPLAY_PICK
?
3587 TODO_PICK
: TODO_REVERT
, cmit
, opts
, 0);
3590 int sequencer_pick_revisions(struct replay_opts
*opts
)
3592 struct todo_list todo_list
= TODO_LIST_INIT
;
3593 struct object_id oid
;
3597 if (read_and_refresh_cache(opts
))
3600 for (i
= 0; i
< opts
->revs
->pending
.nr
; i
++) {
3601 struct object_id oid
;
3602 const char *name
= opts
->revs
->pending
.objects
[i
].name
;
3604 /* This happens when using --stdin. */
3608 if (!get_oid(name
, &oid
)) {
3609 if (!lookup_commit_reference_gently(&oid
, 1)) {
3610 enum object_type type
= oid_object_info(the_repository
,
3613 return error(_("%s: can't cherry-pick a %s"),
3614 name
, type_name(type
));
3617 return error(_("%s: bad revision"), name
);
3621 * If we were called as "git cherry-pick <commit>", just
3622 * cherry-pick/revert it, set CHERRY_PICK_HEAD /
3623 * REVERT_HEAD, and don't touch the sequencer state.
3624 * This means it is possible to cherry-pick in the middle
3625 * of a cherry-pick sequence.
3627 if (opts
->revs
->cmdline
.nr
== 1 &&
3628 opts
->revs
->cmdline
.rev
->whence
== REV_CMD_REV
&&
3629 opts
->revs
->no_walk
&&
3630 !opts
->revs
->cmdline
.rev
->flags
) {
3631 struct commit
*cmit
;
3632 if (prepare_revision_walk(opts
->revs
))
3633 return error(_("revision walk setup failed"));
3634 cmit
= get_revision(opts
->revs
);
3635 if (!cmit
|| get_revision(opts
->revs
))
3636 return error("BUG: expected exactly one commit from walk");
3637 return single_pick(cmit
, opts
);
3641 * Start a new cherry-pick/ revert sequence; but
3642 * first, make sure that an existing one isn't in
3646 if (walk_revs_populate_todo(&todo_list
, opts
) ||
3647 create_seq_dir() < 0)
3649 if (get_oid("HEAD", &oid
) && (opts
->action
== REPLAY_REVERT
))
3650 return error(_("can't revert as initial commit"));
3651 if (save_head(oid_to_hex(&oid
)))
3653 if (save_opts(opts
))
3655 update_abort_safety_file();
3656 res
= pick_commits(&todo_list
, opts
);
3657 todo_list_release(&todo_list
);
3661 void append_signoff(struct strbuf
*msgbuf
, int ignore_footer
, unsigned flag
)
3663 unsigned no_dup_sob
= flag
& APPEND_SIGNOFF_DEDUP
;
3664 struct strbuf sob
= STRBUF_INIT
;
3667 strbuf_addstr(&sob
, sign_off_header
);
3668 strbuf_addstr(&sob
, fmt_name(getenv("GIT_COMMITTER_NAME"),
3669 getenv("GIT_COMMITTER_EMAIL")));
3670 strbuf_addch(&sob
, '\n');
3673 strbuf_complete_line(msgbuf
);
3676 * If the whole message buffer is equal to the sob, pretend that we
3677 * found a conforming footer with a matching sob
3679 if (msgbuf
->len
- ignore_footer
== sob
.len
&&
3680 !strncmp(msgbuf
->buf
, sob
.buf
, sob
.len
))
3683 has_footer
= has_conforming_footer(msgbuf
, &sob
, ignore_footer
);
3686 const char *append_newlines
= NULL
;
3687 size_t len
= msgbuf
->len
- ignore_footer
;
3691 * The buffer is completely empty. Leave foom for
3692 * the title and body to be filled in by the user.
3694 append_newlines
= "\n\n";
3695 } else if (len
== 1) {
3697 * Buffer contains a single newline. Add another
3698 * so that we leave room for the title and body.
3700 append_newlines
= "\n";
3701 } else if (msgbuf
->buf
[len
- 2] != '\n') {
3703 * Buffer ends with a single newline. Add another
3704 * so that there is an empty line between the message
3707 append_newlines
= "\n";
3708 } /* else, the buffer already ends with two newlines. */
3710 if (append_newlines
)
3711 strbuf_splice(msgbuf
, msgbuf
->len
- ignore_footer
, 0,
3712 append_newlines
, strlen(append_newlines
));
3715 if (has_footer
!= 3 && (!no_dup_sob
|| has_footer
!= 2))
3716 strbuf_splice(msgbuf
, msgbuf
->len
- ignore_footer
, 0,
3719 strbuf_release(&sob
);
3722 struct labels_entry
{
3723 struct hashmap_entry entry
;
3724 char label
[FLEX_ARRAY
];
3727 static int labels_cmp(const void *fndata
, const struct labels_entry
*a
,
3728 const struct labels_entry
*b
, const void *key
)
3730 return key
? strcmp(a
->label
, key
) : strcmp(a
->label
, b
->label
);
3733 struct string_entry
{
3734 struct oidmap_entry entry
;
3735 char string
[FLEX_ARRAY
];
3738 struct label_state
{
3739 struct oidmap commit2label
;
3740 struct hashmap labels
;
3744 static const char *label_oid(struct object_id
*oid
, const char *label
,
3745 struct label_state
*state
)
3747 struct labels_entry
*labels_entry
;
3748 struct string_entry
*string_entry
;
3749 struct object_id dummy
;
3753 string_entry
= oidmap_get(&state
->commit2label
, oid
);
3755 return string_entry
->string
;
3758 * For "uninteresting" commits, i.e. commits that are not to be
3759 * rebased, and which can therefore not be labeled, we use a unique
3760 * abbreviation of the commit name. This is slightly more complicated
3761 * than calling find_unique_abbrev() because we also need to make
3762 * sure that the abbreviation does not conflict with any other
3765 * We disallow "interesting" commits to be labeled by a string that
3766 * is a valid full-length hash, to ensure that we always can find an
3767 * abbreviation for any uninteresting commit's names that does not
3768 * clash with any other label.
3773 strbuf_reset(&state
->buf
);
3774 strbuf_grow(&state
->buf
, GIT_SHA1_HEXSZ
);
3775 label
= p
= state
->buf
.buf
;
3777 find_unique_abbrev_r(p
, oid
, default_abbrev
);
3780 * We may need to extend the abbreviated hash so that there is
3781 * no conflicting label.
3783 if (hashmap_get_from_hash(&state
->labels
, strihash(p
), p
)) {
3784 size_t i
= strlen(p
) + 1;
3786 oid_to_hex_r(p
, oid
);
3787 for (; i
< GIT_SHA1_HEXSZ
; i
++) {
3790 if (!hashmap_get_from_hash(&state
->labels
,
3796 } else if (((len
= strlen(label
)) == GIT_SHA1_RAWSZ
&&
3797 !get_oid_hex(label
, &dummy
)) ||
3798 (len
== 1 && *label
== '#') ||
3799 hashmap_get_from_hash(&state
->labels
,
3800 strihash(label
), label
)) {
3802 * If the label already exists, or if the label is a valid full
3803 * OID, or the label is a '#' (which we use as a separator
3804 * between merge heads and oneline), we append a dash and a
3805 * number to make it unique.
3807 struct strbuf
*buf
= &state
->buf
;
3810 strbuf_add(buf
, label
, len
);
3812 for (i
= 2; ; i
++) {
3813 strbuf_setlen(buf
, len
);
3814 strbuf_addf(buf
, "-%d", i
);
3815 if (!hashmap_get_from_hash(&state
->labels
,
3824 FLEX_ALLOC_STR(labels_entry
, label
, label
);
3825 hashmap_entry_init(labels_entry
, strihash(label
));
3826 hashmap_add(&state
->labels
, labels_entry
);
3828 FLEX_ALLOC_STR(string_entry
, string
, label
);
3829 oidcpy(&string_entry
->entry
.oid
, oid
);
3830 oidmap_put(&state
->commit2label
, string_entry
);
3832 return string_entry
->string
;
3835 static int make_script_with_merges(struct pretty_print_context
*pp
,
3836 struct rev_info
*revs
, FILE *out
,
3839 int keep_empty
= flags
& TODO_LIST_KEEP_EMPTY
;
3840 int rebase_cousins
= flags
& TODO_LIST_REBASE_COUSINS
;
3841 struct strbuf buf
= STRBUF_INIT
, oneline
= STRBUF_INIT
;
3842 struct strbuf label
= STRBUF_INIT
;
3843 struct commit_list
*commits
= NULL
, **tail
= &commits
, *iter
;
3844 struct commit_list
*tips
= NULL
, **tips_tail
= &tips
;
3845 struct commit
*commit
;
3846 struct oidmap commit2todo
= OIDMAP_INIT
;
3847 struct string_entry
*entry
;
3848 struct oidset interesting
= OIDSET_INIT
, child_seen
= OIDSET_INIT
,
3849 shown
= OIDSET_INIT
;
3850 struct label_state state
= { OIDMAP_INIT
, { NULL
}, STRBUF_INIT
};
3852 int abbr
= flags
& TODO_LIST_ABBREVIATE_CMDS
;
3853 const char *cmd_pick
= abbr
? "p" : "pick",
3854 *cmd_label
= abbr
? "l" : "label",
3855 *cmd_reset
= abbr
? "t" : "reset",
3856 *cmd_merge
= abbr
? "m" : "merge";
3858 oidmap_init(&commit2todo
, 0);
3859 oidmap_init(&state
.commit2label
, 0);
3860 hashmap_init(&state
.labels
, (hashmap_cmp_fn
) labels_cmp
, NULL
, 0);
3861 strbuf_init(&state
.buf
, 32);
3863 if (revs
->cmdline
.nr
&& (revs
->cmdline
.rev
[0].flags
& BOTTOM
)) {
3864 struct object_id
*oid
= &revs
->cmdline
.rev
[0].item
->oid
;
3865 FLEX_ALLOC_STR(entry
, string
, "onto");
3866 oidcpy(&entry
->entry
.oid
, oid
);
3867 oidmap_put(&state
.commit2label
, entry
);
3872 * - get onelines for all commits
3873 * - gather all branch tips (i.e. 2nd or later parents of merges)
3874 * - label all branch tips
3876 while ((commit
= get_revision(revs
))) {
3877 struct commit_list
*to_merge
;
3879 const char *p1
, *p2
;
3880 struct object_id
*oid
;
3883 tail
= &commit_list_insert(commit
, tail
)->next
;
3884 oidset_insert(&interesting
, &commit
->object
.oid
);
3886 is_empty
= is_original_commit_empty(commit
);
3887 if (!is_empty
&& (commit
->object
.flags
& PATCHSAME
))
3890 strbuf_reset(&oneline
);
3891 pretty_print_commit(pp
, commit
, &oneline
);
3893 to_merge
= commit
->parents
? commit
->parents
->next
: NULL
;
3895 /* non-merge commit: easy case */
3897 if (!keep_empty
&& is_empty
)
3898 strbuf_addf(&buf
, "%c ", comment_line_char
);
3899 strbuf_addf(&buf
, "%s %s %s", cmd_pick
,
3900 oid_to_hex(&commit
->object
.oid
),
3903 FLEX_ALLOC_STR(entry
, string
, buf
.buf
);
3904 oidcpy(&entry
->entry
.oid
, &commit
->object
.oid
);
3905 oidmap_put(&commit2todo
, entry
);
3910 is_octopus
= to_merge
&& to_merge
->next
;
3913 BUG("Octopus merges not yet supported");
3915 /* Create a label */
3916 strbuf_reset(&label
);
3917 if (skip_prefix(oneline
.buf
, "Merge ", &p1
) &&
3918 (p1
= strchr(p1
, '\'')) &&
3919 (p2
= strchr(++p1
, '\'')))
3920 strbuf_add(&label
, p1
, p2
- p1
);
3921 else if (skip_prefix(oneline
.buf
, "Merge pull request ",
3923 (p1
= strstr(p1
, " from ")))
3924 strbuf_addstr(&label
, p1
+ strlen(" from "));
3926 strbuf_addbuf(&label
, &oneline
);
3928 for (p1
= label
.buf
; *p1
; p1
++)
3933 strbuf_addf(&buf
, "%s -C %s",
3934 cmd_merge
, oid_to_hex(&commit
->object
.oid
));
3936 /* label the tip of merged branch */
3937 oid
= &to_merge
->item
->object
.oid
;
3938 strbuf_addch(&buf
, ' ');
3940 if (!oidset_contains(&interesting
, oid
))
3941 strbuf_addstr(&buf
, label_oid(oid
, NULL
, &state
));
3943 tips_tail
= &commit_list_insert(to_merge
->item
,
3946 strbuf_addstr(&buf
, label_oid(oid
, label
.buf
, &state
));
3948 strbuf_addf(&buf
, " # %s", oneline
.buf
);
3950 FLEX_ALLOC_STR(entry
, string
, buf
.buf
);
3951 oidcpy(&entry
->entry
.oid
, &commit
->object
.oid
);
3952 oidmap_put(&commit2todo
, entry
);
3957 * - label branch points
3958 * - add HEAD to the branch tips
3960 for (iter
= commits
; iter
; iter
= iter
->next
) {
3961 struct commit_list
*parent
= iter
->item
->parents
;
3962 for (; parent
; parent
= parent
->next
) {
3963 struct object_id
*oid
= &parent
->item
->object
.oid
;
3964 if (!oidset_contains(&interesting
, oid
))
3966 if (!oidset_contains(&child_seen
, oid
))
3967 oidset_insert(&child_seen
, oid
);
3969 label_oid(oid
, "branch-point", &state
);
3972 /* Add HEAD as implict "tip of branch" */
3974 tips_tail
= &commit_list_insert(iter
->item
,
3979 * Third phase: output the todo list. This is a bit tricky, as we
3980 * want to avoid jumping back and forth between revisions. To
3981 * accomplish that goal, we walk backwards from the branch tips,
3982 * gathering commits not yet shown, reversing the list on the fly,
3983 * then outputting that list (labeling revisions as needed).
3985 fprintf(out
, "%s onto\n", cmd_label
);
3986 for (iter
= tips
; iter
; iter
= iter
->next
) {
3987 struct commit_list
*list
= NULL
, *iter2
;
3989 commit
= iter
->item
;
3990 if (oidset_contains(&shown
, &commit
->object
.oid
))
3992 entry
= oidmap_get(&state
.commit2label
, &commit
->object
.oid
);
3995 fprintf(out
, "\n# Branch %s\n", entry
->string
);
3999 while (oidset_contains(&interesting
, &commit
->object
.oid
) &&
4000 !oidset_contains(&shown
, &commit
->object
.oid
)) {
4001 commit_list_insert(commit
, &list
);
4002 if (!commit
->parents
) {
4006 commit
= commit
->parents
->item
;
4010 fprintf(out
, "%s %s\n", cmd_reset
,
4011 rebase_cousins
? "onto" : "[new root]");
4013 const char *to
= NULL
;
4015 entry
= oidmap_get(&state
.commit2label
,
4016 &commit
->object
.oid
);
4019 else if (!rebase_cousins
)
4020 to
= label_oid(&commit
->object
.oid
, NULL
,
4023 if (!to
|| !strcmp(to
, "onto"))
4024 fprintf(out
, "%s onto\n", cmd_reset
);
4026 strbuf_reset(&oneline
);
4027 pretty_print_commit(pp
, commit
, &oneline
);
4028 fprintf(out
, "%s %s # %s\n",
4029 cmd_reset
, to
, oneline
.buf
);
4033 for (iter2
= list
; iter2
; iter2
= iter2
->next
) {
4034 struct object_id
*oid
= &iter2
->item
->object
.oid
;
4035 entry
= oidmap_get(&commit2todo
, oid
);
4036 /* only show if not already upstream */
4038 fprintf(out
, "%s\n", entry
->string
);
4039 entry
= oidmap_get(&state
.commit2label
, oid
);
4041 fprintf(out
, "%s %s\n",
4042 cmd_label
, entry
->string
);
4043 oidset_insert(&shown
, oid
);
4046 free_commit_list(list
);
4049 free_commit_list(commits
);
4050 free_commit_list(tips
);
4052 strbuf_release(&label
);
4053 strbuf_release(&oneline
);
4054 strbuf_release(&buf
);
4056 oidmap_free(&commit2todo
, 1);
4057 oidmap_free(&state
.commit2label
, 1);
4058 hashmap_free(&state
.labels
, 1);
4059 strbuf_release(&state
.buf
);
4064 int sequencer_make_script(FILE *out
, int argc
, const char **argv
,
4067 char *format
= NULL
;
4068 struct pretty_print_context pp
= {0};
4069 struct strbuf buf
= STRBUF_INIT
;
4070 struct rev_info revs
;
4071 struct commit
*commit
;
4072 int keep_empty
= flags
& TODO_LIST_KEEP_EMPTY
;
4073 const char *insn
= flags
& TODO_LIST_ABBREVIATE_CMDS
? "p" : "pick";
4074 int rebase_merges
= flags
& TODO_LIST_REBASE_MERGES
;
4076 init_revisions(&revs
, NULL
);
4077 revs
.verbose_header
= 1;
4079 revs
.max_parents
= 1;
4080 revs
.cherry_mark
= 1;
4083 revs
.right_only
= 1;
4084 revs
.sort_order
= REV_SORT_IN_GRAPH_ORDER
;
4085 revs
.topo_order
= 1;
4087 revs
.pretty_given
= 1;
4088 git_config_get_string("rebase.instructionFormat", &format
);
4089 if (!format
|| !*format
) {
4091 format
= xstrdup("%s");
4093 get_commit_format(format
, &revs
);
4095 pp
.fmt
= revs
.commit_format
;
4096 pp
.output_encoding
= get_log_output_encoding();
4098 if (setup_revisions(argc
, argv
, &revs
, NULL
) > 1)
4099 return error(_("make_script: unhandled options"));
4101 if (prepare_revision_walk(&revs
) < 0)
4102 return error(_("make_script: error preparing revisions"));
4105 return make_script_with_merges(&pp
, &revs
, out
, flags
);
4107 while ((commit
= get_revision(&revs
))) {
4108 int is_empty
= is_original_commit_empty(commit
);
4110 if (!is_empty
&& (commit
->object
.flags
& PATCHSAME
))
4113 if (!keep_empty
&& is_empty
)
4114 strbuf_addf(&buf
, "%c ", comment_line_char
);
4115 strbuf_addf(&buf
, "%s %s ", insn
,
4116 oid_to_hex(&commit
->object
.oid
));
4117 pretty_print_commit(&pp
, commit
, &buf
);
4118 strbuf_addch(&buf
, '\n');
4119 fputs(buf
.buf
, out
);
4121 strbuf_release(&buf
);
4126 * Add commands after pick and (series of) squash/fixup commands
4129 int sequencer_add_exec_commands(const char *commands
)
4131 const char *todo_file
= rebase_path_todo();
4132 struct todo_list todo_list
= TODO_LIST_INIT
;
4133 struct todo_item
*item
;
4134 struct strbuf
*buf
= &todo_list
.buf
;
4135 size_t offset
= 0, commands_len
= strlen(commands
);
4138 if (strbuf_read_file(&todo_list
.buf
, todo_file
, 0) < 0)
4139 return error(_("could not read '%s'."), todo_file
);
4141 if (parse_insn_buffer(todo_list
.buf
.buf
, &todo_list
)) {
4142 todo_list_release(&todo_list
);
4143 return error(_("unusable todo list: '%s'"), todo_file
);
4147 /* insert <commands> before every pick except the first one */
4148 for (item
= todo_list
.items
, i
= 0; i
< todo_list
.nr
; i
++, item
++) {
4149 if (item
->command
== TODO_PICK
&& !first
) {
4150 strbuf_insert(buf
, item
->offset_in_buf
+ offset
,
4151 commands
, commands_len
);
4152 offset
+= commands_len
;
4157 /* append final <commands> */
4158 strbuf_add(buf
, commands
, commands_len
);
4160 i
= write_message(buf
->buf
, buf
->len
, todo_file
, 0);
4161 todo_list_release(&todo_list
);
4165 int transform_todos(unsigned flags
)
4167 const char *todo_file
= rebase_path_todo();
4168 struct todo_list todo_list
= TODO_LIST_INIT
;
4169 struct strbuf buf
= STRBUF_INIT
;
4170 struct todo_item
*item
;
4173 if (strbuf_read_file(&todo_list
.buf
, todo_file
, 0) < 0)
4174 return error(_("could not read '%s'."), todo_file
);
4176 if (parse_insn_buffer(todo_list
.buf
.buf
, &todo_list
)) {
4177 todo_list_release(&todo_list
);
4178 return error(_("unusable todo list: '%s'"), todo_file
);
4181 for (item
= todo_list
.items
, i
= 0; i
< todo_list
.nr
; i
++, item
++) {
4182 /* if the item is not a command write it and continue */
4183 if (item
->command
>= TODO_COMMENT
) {
4184 strbuf_addf(&buf
, "%.*s\n", item
->arg_len
, item
->arg
);
4188 /* add command to the buffer */
4189 if (flags
& TODO_LIST_ABBREVIATE_CMDS
)
4190 strbuf_addch(&buf
, command_to_char(item
->command
));
4192 strbuf_addstr(&buf
, command_to_string(item
->command
));
4196 const char *oid
= flags
& TODO_LIST_SHORTEN_IDS
?
4197 short_commit_name(item
->commit
) :
4198 oid_to_hex(&item
->commit
->object
.oid
);
4200 if (item
->command
== TODO_MERGE
) {
4201 if (item
->flags
& TODO_EDIT_MERGE_MSG
)
4202 strbuf_addstr(&buf
, " -c");
4204 strbuf_addstr(&buf
, " -C");
4207 strbuf_addf(&buf
, " %s", oid
);
4210 /* add all the rest */
4212 strbuf_addch(&buf
, '\n');
4214 strbuf_addf(&buf
, " %.*s\n", item
->arg_len
, item
->arg
);
4217 i
= write_message(buf
.buf
, buf
.len
, todo_file
, 0);
4218 todo_list_release(&todo_list
);
4223 CHECK_IGNORE
= 0, CHECK_WARN
, CHECK_ERROR
4226 static enum check_level
get_missing_commit_check_level(void)
4230 if (git_config_get_value("rebase.missingcommitscheck", &value
) ||
4231 !strcasecmp("ignore", value
))
4232 return CHECK_IGNORE
;
4233 if (!strcasecmp("warn", value
))
4235 if (!strcasecmp("error", value
))
4237 warning(_("unrecognized setting %s for option "
4238 "rebase.missingCommitsCheck. Ignoring."), value
);
4239 return CHECK_IGNORE
;
4243 * Check if the user dropped some commits by mistake
4244 * Behaviour determined by rebase.missingCommitsCheck.
4245 * Check if there is an unrecognized command or a
4246 * bad SHA-1 in a command.
4248 int check_todo_list(void)
4250 enum check_level check_level
= get_missing_commit_check_level();
4251 struct strbuf todo_file
= STRBUF_INIT
;
4252 struct todo_list todo_list
= TODO_LIST_INIT
;
4253 struct strbuf missing
= STRBUF_INIT
;
4254 int advise_to_edit_todo
= 0, res
= 0, i
;
4256 strbuf_addstr(&todo_file
, rebase_path_todo());
4257 if (strbuf_read_file_or_whine(&todo_list
.buf
, todo_file
.buf
) < 0) {
4261 advise_to_edit_todo
= res
=
4262 parse_insn_buffer(todo_list
.buf
.buf
, &todo_list
);
4264 if (res
|| check_level
== CHECK_IGNORE
)
4267 /* Mark the commits in git-rebase-todo as seen */
4268 for (i
= 0; i
< todo_list
.nr
; i
++) {
4269 struct commit
*commit
= todo_list
.items
[i
].commit
;
4271 commit
->util
= (void *)1;
4274 todo_list_release(&todo_list
);
4275 strbuf_addstr(&todo_file
, ".backup");
4276 if (strbuf_read_file_or_whine(&todo_list
.buf
, todo_file
.buf
) < 0) {
4280 strbuf_release(&todo_file
);
4281 res
= !!parse_insn_buffer(todo_list
.buf
.buf
, &todo_list
);
4283 /* Find commits in git-rebase-todo.backup yet unseen */
4284 for (i
= todo_list
.nr
- 1; i
>= 0; i
--) {
4285 struct todo_item
*item
= todo_list
.items
+ i
;
4286 struct commit
*commit
= item
->commit
;
4287 if (commit
&& !commit
->util
) {
4288 strbuf_addf(&missing
, " - %s %.*s\n",
4289 short_commit_name(commit
),
4290 item
->arg_len
, item
->arg
);
4291 commit
->util
= (void *)1;
4295 /* Warn about missing commits */
4299 if (check_level
== CHECK_ERROR
)
4300 advise_to_edit_todo
= res
= 1;
4303 _("Warning: some commits may have been dropped accidentally.\n"
4304 "Dropped commits (newer to older):\n"));
4306 /* Make the list user-friendly and display */
4307 fputs(missing
.buf
, stderr
);
4308 strbuf_release(&missing
);
4310 fprintf(stderr
, _("To avoid this message, use \"drop\" to "
4311 "explicitly remove a commit.\n\n"
4312 "Use 'git config rebase.missingCommitsCheck' to change "
4313 "the level of warnings.\n"
4314 "The possible behaviours are: ignore, warn, error.\n\n"));
4317 strbuf_release(&todo_file
);
4318 todo_list_release(&todo_list
);
4320 if (advise_to_edit_todo
)
4322 _("You can fix this with 'git rebase --edit-todo' "
4323 "and then run 'git rebase --continue'.\n"
4324 "Or you can abort the rebase with 'git rebase"
4330 static int rewrite_file(const char *path
, const char *buf
, size_t len
)
4333 int fd
= open(path
, O_WRONLY
| O_TRUNC
);
4335 return error_errno(_("could not open '%s' for writing"), path
);
4336 if (write_in_full(fd
, buf
, len
) < 0)
4337 rc
= error_errno(_("could not write to '%s'"), path
);
4338 if (close(fd
) && !rc
)
4339 rc
= error_errno(_("could not close '%s'"), path
);
4343 /* skip picking commits whose parents are unchanged */
4344 int skip_unnecessary_picks(void)
4346 const char *todo_file
= rebase_path_todo();
4347 struct strbuf buf
= STRBUF_INIT
;
4348 struct todo_list todo_list
= TODO_LIST_INIT
;
4349 struct object_id onto_oid
, *oid
= &onto_oid
, *parent_oid
;
4352 if (!read_oneliner(&buf
, rebase_path_onto(), 0))
4353 return error(_("could not read 'onto'"));
4354 if (get_oid(buf
.buf
, &onto_oid
)) {
4355 strbuf_release(&buf
);
4356 return error(_("need a HEAD to fixup"));
4358 strbuf_release(&buf
);
4360 if (strbuf_read_file_or_whine(&todo_list
.buf
, todo_file
) < 0)
4362 if (parse_insn_buffer(todo_list
.buf
.buf
, &todo_list
) < 0) {
4363 todo_list_release(&todo_list
);
4367 for (i
= 0; i
< todo_list
.nr
; i
++) {
4368 struct todo_item
*item
= todo_list
.items
+ i
;
4370 if (item
->command
>= TODO_NOOP
)
4372 if (item
->command
!= TODO_PICK
)
4374 if (parse_commit(item
->commit
)) {
4375 todo_list_release(&todo_list
);
4376 return error(_("could not parse commit '%s'"),
4377 oid_to_hex(&item
->commit
->object
.oid
));
4379 if (!item
->commit
->parents
)
4380 break; /* root commit */
4381 if (item
->commit
->parents
->next
)
4382 break; /* merge commit */
4383 parent_oid
= &item
->commit
->parents
->item
->object
.oid
;
4384 if (hashcmp(parent_oid
->hash
, oid
->hash
))
4386 oid
= &item
->commit
->object
.oid
;
4389 int offset
= get_item_line_offset(&todo_list
, i
);
4390 const char *done_path
= rebase_path_done();
4392 fd
= open(done_path
, O_CREAT
| O_WRONLY
| O_APPEND
, 0666);
4394 error_errno(_("could not open '%s' for writing"),
4396 todo_list_release(&todo_list
);
4399 if (write_in_full(fd
, todo_list
.buf
.buf
, offset
) < 0) {
4400 error_errno(_("could not write to '%s'"), done_path
);
4401 todo_list_release(&todo_list
);
4407 if (rewrite_file(rebase_path_todo(), todo_list
.buf
.buf
+ offset
,
4408 todo_list
.buf
.len
- offset
) < 0) {
4409 todo_list_release(&todo_list
);
4413 todo_list
.current
= i
;
4414 if (is_fixup(peek_command(&todo_list
, 0)))
4415 record_in_rewritten(oid
, peek_command(&todo_list
, 0));
4418 todo_list_release(&todo_list
);
4419 printf("%s\n", oid_to_hex(oid
));
4424 struct subject2item_entry
{
4425 struct hashmap_entry entry
;
4427 char subject
[FLEX_ARRAY
];
4430 static int subject2item_cmp(const void *fndata
,
4431 const struct subject2item_entry
*a
,
4432 const struct subject2item_entry
*b
, const void *key
)
4434 return key
? strcmp(a
->subject
, key
) : strcmp(a
->subject
, b
->subject
);
4438 * Rearrange the todo list that has both "pick commit-id msg" and "pick
4439 * commit-id fixup!/squash! msg" in it so that the latter is put immediately
4440 * after the former, and change "pick" to "fixup"/"squash".
4442 * Note that if the config has specified a custom instruction format, each log
4443 * message will have to be retrieved from the commit (as the oneline in the
4444 * script cannot be trusted) in order to normalize the autosquash arrangement.
4446 int rearrange_squash(void)
4448 const char *todo_file
= rebase_path_todo();
4449 struct todo_list todo_list
= TODO_LIST_INIT
;
4450 struct hashmap subject2item
;
4451 int res
= 0, rearranged
= 0, *next
, *tail
, i
;
4454 if (strbuf_read_file_or_whine(&todo_list
.buf
, todo_file
) < 0)
4456 if (parse_insn_buffer(todo_list
.buf
.buf
, &todo_list
) < 0) {
4457 todo_list_release(&todo_list
);
4462 * The hashmap maps onelines to the respective todo list index.
4464 * If any items need to be rearranged, the next[i] value will indicate
4465 * which item was moved directly after the i'th.
4467 * In that case, last[i] will indicate the index of the latest item to
4468 * be moved to appear after the i'th.
4470 hashmap_init(&subject2item
, (hashmap_cmp_fn
) subject2item_cmp
,
4471 NULL
, todo_list
.nr
);
4472 ALLOC_ARRAY(next
, todo_list
.nr
);
4473 ALLOC_ARRAY(tail
, todo_list
.nr
);
4474 ALLOC_ARRAY(subjects
, todo_list
.nr
);
4475 for (i
= 0; i
< todo_list
.nr
; i
++) {
4476 struct strbuf buf
= STRBUF_INIT
;
4477 struct todo_item
*item
= todo_list
.items
+ i
;
4478 const char *commit_buffer
, *subject
, *p
;
4481 struct subject2item_entry
*entry
;
4483 next
[i
] = tail
[i
] = -1;
4484 if (!item
->commit
|| item
->command
== TODO_DROP
) {
4489 if (is_fixup(item
->command
)) {
4490 todo_list_release(&todo_list
);
4491 return error(_("the script was already rearranged."));
4494 item
->commit
->util
= item
;
4496 parse_commit(item
->commit
);
4497 commit_buffer
= get_commit_buffer(item
->commit
, NULL
);
4498 find_commit_subject(commit_buffer
, &subject
);
4499 format_subject(&buf
, subject
, " ");
4500 subject
= subjects
[i
] = strbuf_detach(&buf
, &subject_len
);
4501 unuse_commit_buffer(item
->commit
, commit_buffer
);
4502 if ((skip_prefix(subject
, "fixup! ", &p
) ||
4503 skip_prefix(subject
, "squash! ", &p
))) {
4504 struct commit
*commit2
;
4509 if (!skip_prefix(p
, "fixup! ", &p
) &&
4510 !skip_prefix(p
, "squash! ", &p
))
4514 if ((entry
= hashmap_get_from_hash(&subject2item
,
4516 /* found by title */
4518 else if (!strchr(p
, ' ') &&
4520 lookup_commit_reference_by_name(p
)) &&
4522 /* found by commit name */
4523 i2
= (struct todo_item
*)commit2
->util
4526 /* copy can be a prefix of the commit subject */
4527 for (i2
= 0; i2
< i
; i2
++)
4529 starts_with(subjects
[i2
], p
))
4537 todo_list
.items
[i
].command
=
4538 starts_with(subject
, "fixup!") ?
4539 TODO_FIXUP
: TODO_SQUASH
;
4545 } else if (!hashmap_get_from_hash(&subject2item
,
4546 strhash(subject
), subject
)) {
4547 FLEX_ALLOC_MEM(entry
, subject
, subject
, subject_len
);
4549 hashmap_entry_init(entry
, strhash(entry
->subject
));
4550 hashmap_put(&subject2item
, entry
);
4555 struct strbuf buf
= STRBUF_INIT
;
4557 for (i
= 0; i
< todo_list
.nr
; i
++) {
4558 enum todo_command command
= todo_list
.items
[i
].command
;
4562 * Initially, all commands are 'pick's. If it is a
4563 * fixup or a squash now, we have rearranged it.
4565 if (is_fixup(command
))
4570 get_item_line(&todo_list
, cur
);
4572 get_item_line(&todo_list
, cur
+ 1);
4574 /* replace 'pick', by 'fixup' or 'squash' */
4575 command
= todo_list
.items
[cur
].command
;
4576 if (is_fixup(command
)) {
4578 todo_command_info
[command
].str
);
4579 bol
+= strcspn(bol
, " \t");
4582 strbuf_add(&buf
, bol
, eol
- bol
);
4588 res
= rewrite_file(todo_file
, buf
.buf
, buf
.len
);
4589 strbuf_release(&buf
);
4594 for (i
= 0; i
< todo_list
.nr
; i
++)
4597 hashmap_free(&subject2item
, 1);
4598 todo_list_release(&todo_list
);