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"
30 #include "commit-slab.h"
33 #define GIT_REFLOG_ACTION "GIT_REFLOG_ACTION"
35 const char sign_off_header
[] = "Signed-off-by: ";
36 static const char cherry_picked_prefix
[] = "(cherry picked from commit ";
38 GIT_PATH_FUNC(git_path_commit_editmsg
, "COMMIT_EDITMSG")
40 GIT_PATH_FUNC(git_path_seq_dir
, "sequencer")
42 static GIT_PATH_FUNC(git_path_todo_file
, "sequencer/todo")
43 static GIT_PATH_FUNC(git_path_opts_file
, "sequencer/opts")
44 static GIT_PATH_FUNC(git_path_head_file
, "sequencer/head")
45 static GIT_PATH_FUNC(git_path_abort_safety_file
, "sequencer/abort-safety")
47 static GIT_PATH_FUNC(rebase_path
, "rebase-merge")
49 * The file containing rebase commands, comments, and empty lines.
50 * This file is created by "git rebase -i" then edited by the user. As
51 * the lines are processed, they are removed from the front of this
52 * file and written to the tail of 'done'.
54 static GIT_PATH_FUNC(rebase_path_todo
, "rebase-merge/git-rebase-todo")
56 * The rebase command lines that have already been processed. A line
57 * is moved here when it is first handled, before any associated user
60 static GIT_PATH_FUNC(rebase_path_done
, "rebase-merge/done")
62 * The file to keep track of how many commands were already processed (e.g.
65 static GIT_PATH_FUNC(rebase_path_msgnum
, "rebase-merge/msgnum");
67 * The file to keep track of how many commands are to be processed in total
68 * (e.g. for the prompt).
70 static GIT_PATH_FUNC(rebase_path_msgtotal
, "rebase-merge/end");
72 * The commit message that is planned to be used for any changes that
73 * need to be committed following a user interaction.
75 static GIT_PATH_FUNC(rebase_path_message
, "rebase-merge/message")
77 * The file into which is accumulated the suggested commit message for
78 * squash/fixup commands. When the first of a series of squash/fixups
79 * is seen, the file is created and the commit message from the
80 * previous commit and from the first squash/fixup commit are written
81 * to it. The commit message for each subsequent squash/fixup commit
82 * is appended to the file as it is processed.
84 static GIT_PATH_FUNC(rebase_path_squash_msg
, "rebase-merge/message-squash")
86 * If the current series of squash/fixups has not yet included a squash
87 * command, then this file exists and holds the commit message of the
88 * original "pick" commit. (If the series ends without a "squash"
89 * command, then this can be used as the commit message of the combined
90 * commit without opening the editor.)
92 static GIT_PATH_FUNC(rebase_path_fixup_msg
, "rebase-merge/message-fixup")
94 * This file contains the list fixup/squash commands that have been
95 * accumulated into message-fixup or message-squash so far.
97 static GIT_PATH_FUNC(rebase_path_current_fixups
, "rebase-merge/current-fixups")
99 * A script to set the GIT_AUTHOR_NAME, GIT_AUTHOR_EMAIL, and
100 * GIT_AUTHOR_DATE that will be used for the commit that is currently
103 static GIT_PATH_FUNC(rebase_path_author_script
, "rebase-merge/author-script")
105 * When an "edit" rebase command is being processed, the SHA1 of the
106 * commit to be edited is recorded in this file. When "git rebase
107 * --continue" is executed, if there are any staged changes then they
108 * will be amended to the HEAD commit, but only provided the HEAD
109 * commit is still the commit to be edited. When any other rebase
110 * command is processed, this file is deleted.
112 static GIT_PATH_FUNC(rebase_path_amend
, "rebase-merge/amend")
114 * When we stop at a given patch via the "edit" command, this file contains
115 * the abbreviated commit name of the corresponding patch.
117 static GIT_PATH_FUNC(rebase_path_stopped_sha
, "rebase-merge/stopped-sha")
119 * For the post-rewrite hook, we make a list of rewritten commits and
120 * their new sha1s. The rewritten-pending list keeps the sha1s of
121 * commits that have been processed, but not committed yet,
122 * e.g. because they are waiting for a 'squash' command.
124 static GIT_PATH_FUNC(rebase_path_rewritten_list
, "rebase-merge/rewritten-list")
125 static GIT_PATH_FUNC(rebase_path_rewritten_pending
,
126 "rebase-merge/rewritten-pending")
129 * The path of the file containig the OID of the "squash onto" commit, i.e.
130 * the dummy commit used for `reset [new root]`.
132 static GIT_PATH_FUNC(rebase_path_squash_onto
, "rebase-merge/squash-onto")
135 * The path of the file listing refs that need to be deleted after the rebase
136 * finishes. This is used by the `label` command to record the need for cleanup.
138 static GIT_PATH_FUNC(rebase_path_refs_to_delete
, "rebase-merge/refs-to-delete")
141 * The following files are written by git-rebase just after parsing the
142 * command-line (and are only consumed, not modified, by the sequencer).
144 static GIT_PATH_FUNC(rebase_path_gpg_sign_opt
, "rebase-merge/gpg_sign_opt")
145 static GIT_PATH_FUNC(rebase_path_orig_head
, "rebase-merge/orig-head")
146 static GIT_PATH_FUNC(rebase_path_verbose
, "rebase-merge/verbose")
147 static GIT_PATH_FUNC(rebase_path_signoff
, "rebase-merge/signoff")
148 static GIT_PATH_FUNC(rebase_path_head_name
, "rebase-merge/head-name")
149 static GIT_PATH_FUNC(rebase_path_onto
, "rebase-merge/onto")
150 static GIT_PATH_FUNC(rebase_path_autostash
, "rebase-merge/autostash")
151 static GIT_PATH_FUNC(rebase_path_strategy
, "rebase-merge/strategy")
152 static GIT_PATH_FUNC(rebase_path_strategy_opts
, "rebase-merge/strategy_opts")
153 static GIT_PATH_FUNC(rebase_path_allow_rerere_autoupdate
, "rebase-merge/allow_rerere_autoupdate")
155 static int git_sequencer_config(const char *k
, const char *v
, void *cb
)
157 struct replay_opts
*opts
= cb
;
160 if (!strcmp(k
, "commit.cleanup")) {
163 status
= git_config_string(&s
, k
, v
);
167 if (!strcmp(s
, "verbatim"))
168 opts
->default_msg_cleanup
= COMMIT_MSG_CLEANUP_NONE
;
169 else if (!strcmp(s
, "whitespace"))
170 opts
->default_msg_cleanup
= COMMIT_MSG_CLEANUP_SPACE
;
171 else if (!strcmp(s
, "strip"))
172 opts
->default_msg_cleanup
= COMMIT_MSG_CLEANUP_ALL
;
173 else if (!strcmp(s
, "scissors"))
174 opts
->default_msg_cleanup
= COMMIT_MSG_CLEANUP_SPACE
;
176 warning(_("invalid commit message cleanup mode '%s'"),
183 if (!strcmp(k
, "commit.gpgsign")) {
184 opts
->gpg_sign
= git_config_bool(k
, v
) ? xstrdup("") : NULL
;
188 status
= git_gpg_config(k
, v
, NULL
);
192 return git_diff_basic_config(k
, v
, NULL
);
195 void sequencer_init_config(struct replay_opts
*opts
)
197 opts
->default_msg_cleanup
= COMMIT_MSG_CLEANUP_NONE
;
198 git_config(git_sequencer_config
, opts
);
201 static inline int is_rebase_i(const struct replay_opts
*opts
)
203 return opts
->action
== REPLAY_INTERACTIVE_REBASE
;
206 static const char *get_dir(const struct replay_opts
*opts
)
208 if (is_rebase_i(opts
))
209 return rebase_path();
210 return git_path_seq_dir();
213 static const char *get_todo_path(const struct replay_opts
*opts
)
215 if (is_rebase_i(opts
))
216 return rebase_path_todo();
217 return git_path_todo_file();
221 * Returns 0 for non-conforming footer
222 * Returns 1 for conforming footer
223 * Returns 2 when sob exists within conforming footer
224 * Returns 3 when sob exists within conforming footer as last entry
226 static int has_conforming_footer(struct strbuf
*sb
, struct strbuf
*sob
,
229 struct trailer_info info
;
231 int found_sob
= 0, found_sob_last
= 0;
233 trailer_info_get(&info
, sb
->buf
);
235 if (info
.trailer_start
== info
.trailer_end
)
238 for (i
= 0; i
< info
.trailer_nr
; i
++)
239 if (sob
&& !strncmp(info
.trailers
[i
], sob
->buf
, sob
->len
)) {
241 if (i
== info
.trailer_nr
- 1)
245 trailer_info_release(&info
);
254 static const char *gpg_sign_opt_quoted(struct replay_opts
*opts
)
256 static struct strbuf buf
= STRBUF_INIT
;
260 sq_quotef(&buf
, "-S%s", opts
->gpg_sign
);
264 int sequencer_remove_state(struct replay_opts
*opts
)
266 struct strbuf buf
= STRBUF_INIT
;
269 if (is_rebase_i(opts
) &&
270 strbuf_read_file(&buf
, rebase_path_refs_to_delete(), 0) > 0) {
273 char *eol
= strchr(p
, '\n');
276 if (delete_ref("(rebase -i) cleanup", p
, NULL
, 0) < 0)
277 warning(_("could not delete '%s'"), p
);
284 free(opts
->gpg_sign
);
285 free(opts
->strategy
);
286 for (i
= 0; i
< opts
->xopts_nr
; i
++)
287 free(opts
->xopts
[i
]);
289 strbuf_release(&opts
->current_fixups
);
292 strbuf_addstr(&buf
, get_dir(opts
));
293 remove_dir_recursively(&buf
, 0);
294 strbuf_release(&buf
);
299 static const char *action_name(const struct replay_opts
*opts
)
301 switch (opts
->action
) {
305 return N_("cherry-pick");
306 case REPLAY_INTERACTIVE_REBASE
:
307 return N_("rebase -i");
309 die(_("unknown action: %d"), opts
->action
);
312 struct commit_message
{
319 static const char *short_commit_name(struct commit
*commit
)
321 return find_unique_abbrev(&commit
->object
.oid
, DEFAULT_ABBREV
);
324 static int get_message(struct commit
*commit
, struct commit_message
*out
)
326 const char *abbrev
, *subject
;
329 out
->message
= logmsg_reencode(commit
, NULL
, get_commit_output_encoding());
330 abbrev
= short_commit_name(commit
);
332 subject_len
= find_commit_subject(out
->message
, &subject
);
334 out
->subject
= xmemdupz(subject
, subject_len
);
335 out
->label
= xstrfmt("%s... %s", abbrev
, out
->subject
);
336 out
->parent_label
= xstrfmt("parent of %s", out
->label
);
341 static void free_message(struct commit
*commit
, struct commit_message
*msg
)
343 free(msg
->parent_label
);
346 unuse_commit_buffer(commit
, msg
->message
);
349 static void print_advice(int show_hint
, struct replay_opts
*opts
)
351 char *msg
= getenv("GIT_CHERRY_PICK_HELP");
354 fprintf(stderr
, "%s\n", msg
);
356 * A conflict has occurred but the porcelain
357 * (typically rebase --interactive) wants to take care
358 * of the commit itself so remove CHERRY_PICK_HEAD
360 unlink(git_path_cherry_pick_head());
366 advise(_("after resolving the conflicts, mark the corrected paths\n"
367 "with 'git add <paths>' or 'git rm <paths>'"));
369 advise(_("after resolving the conflicts, mark the corrected paths\n"
370 "with 'git add <paths>' or 'git rm <paths>'\n"
371 "and commit the result with 'git commit'"));
375 static int write_message(const void *buf
, size_t len
, const char *filename
,
378 struct lock_file msg_file
= LOCK_INIT
;
380 int msg_fd
= hold_lock_file_for_update(&msg_file
, filename
, 0);
382 return error_errno(_("could not lock '%s'"), filename
);
383 if (write_in_full(msg_fd
, buf
, len
) < 0) {
384 error_errno(_("could not write to '%s'"), filename
);
385 rollback_lock_file(&msg_file
);
388 if (append_eol
&& write(msg_fd
, "\n", 1) < 0) {
389 error_errno(_("could not write eol to '%s'"), filename
);
390 rollback_lock_file(&msg_file
);
393 if (commit_lock_file(&msg_file
) < 0)
394 return error(_("failed to finalize '%s'"), filename
);
400 * Reads a file that was presumably written by a shell script, i.e. with an
401 * end-of-line marker that needs to be stripped.
403 * Note that only the last end-of-line marker is stripped, consistent with the
404 * behavior of "$(cat path)" in a shell script.
406 * Returns 1 if the file was read, 0 if it could not be read or does not exist.
408 static int read_oneliner(struct strbuf
*buf
,
409 const char *path
, int skip_if_empty
)
411 int orig_len
= buf
->len
;
413 if (!file_exists(path
))
416 if (strbuf_read_file(buf
, path
, 0) < 0) {
417 warning_errno(_("could not read '%s'"), path
);
421 if (buf
->len
> orig_len
&& buf
->buf
[buf
->len
- 1] == '\n') {
422 if (--buf
->len
> orig_len
&& buf
->buf
[buf
->len
- 1] == '\r')
424 buf
->buf
[buf
->len
] = '\0';
427 if (skip_if_empty
&& buf
->len
== orig_len
)
433 static struct tree
*empty_tree(void)
435 return lookup_tree(the_hash_algo
->empty_tree
);
438 static int error_dirty_index(struct replay_opts
*opts
)
440 if (read_cache_unmerged())
441 return error_resolve_conflict(_(action_name(opts
)));
443 error(_("your local changes would be overwritten by %s."),
444 _(action_name(opts
)));
446 if (advice_commit_before_merge
)
447 advise(_("commit your changes or stash them to proceed."));
451 static void update_abort_safety_file(void)
453 struct object_id head
;
455 /* Do nothing on a single-pick */
456 if (!file_exists(git_path_seq_dir()))
459 if (!get_oid("HEAD", &head
))
460 write_file(git_path_abort_safety_file(), "%s", oid_to_hex(&head
));
462 write_file(git_path_abort_safety_file(), "%s", "");
465 static int fast_forward_to(const struct object_id
*to
, const struct object_id
*from
,
466 int unborn
, struct replay_opts
*opts
)
468 struct ref_transaction
*transaction
;
469 struct strbuf sb
= STRBUF_INIT
;
470 struct strbuf err
= STRBUF_INIT
;
473 if (checkout_fast_forward(from
, to
, 1))
474 return -1; /* the callee should have complained already */
476 strbuf_addf(&sb
, _("%s: fast-forward"), _(action_name(opts
)));
478 transaction
= ref_transaction_begin(&err
);
480 ref_transaction_update(transaction
, "HEAD",
481 to
, unborn
&& !is_rebase_i(opts
) ?
484 ref_transaction_commit(transaction
, &err
)) {
485 ref_transaction_free(transaction
);
486 error("%s", err
.buf
);
488 strbuf_release(&err
);
493 strbuf_release(&err
);
494 ref_transaction_free(transaction
);
495 update_abort_safety_file();
499 void append_conflicts_hint(struct strbuf
*msgbuf
)
503 strbuf_addch(msgbuf
, '\n');
504 strbuf_commented_addf(msgbuf
, "Conflicts:\n");
505 for (i
= 0; i
< active_nr
;) {
506 const struct cache_entry
*ce
= active_cache
[i
++];
508 strbuf_commented_addf(msgbuf
, "\t%s\n", ce
->name
);
509 while (i
< active_nr
&& !strcmp(ce
->name
,
510 active_cache
[i
]->name
))
516 static int do_recursive_merge(struct commit
*base
, struct commit
*next
,
517 const char *base_label
, const char *next_label
,
518 struct object_id
*head
, struct strbuf
*msgbuf
,
519 struct replay_opts
*opts
)
521 struct merge_options o
;
522 struct tree
*result
, *next_tree
, *base_tree
, *head_tree
;
525 struct lock_file index_lock
= LOCK_INIT
;
527 if (hold_locked_index(&index_lock
, LOCK_REPORT_ON_ERROR
) < 0)
532 init_merge_options(&o
);
533 o
.ancestor
= base
? base_label
: "(empty tree)";
535 o
.branch2
= next
? next_label
: "(empty tree)";
536 if (is_rebase_i(opts
))
538 o
.show_rename_progress
= 1;
540 head_tree
= parse_tree_indirect(head
);
541 next_tree
= next
? get_commit_tree(next
) : empty_tree();
542 base_tree
= base
? get_commit_tree(base
) : empty_tree();
544 for (xopt
= opts
->xopts
; xopt
!= opts
->xopts
+ opts
->xopts_nr
; xopt
++)
545 parse_merge_opt(&o
, *xopt
);
547 clean
= merge_trees(&o
,
549 next_tree
, base_tree
, &result
);
550 if (is_rebase_i(opts
) && clean
<= 0)
551 fputs(o
.obuf
.buf
, stdout
);
552 strbuf_release(&o
.obuf
);
553 diff_warn_rename_limit("merge.renamelimit", o
.needed_rename_limit
, 0);
555 rollback_lock_file(&index_lock
);
559 if (write_locked_index(&the_index
, &index_lock
,
560 COMMIT_LOCK
| SKIP_IF_UNCHANGED
))
562 * TRANSLATORS: %s will be "revert", "cherry-pick" or
565 return error(_("%s: Unable to write new index file"),
566 _(action_name(opts
)));
569 append_conflicts_hint(msgbuf
);
574 static struct object_id
*get_cache_tree_oid(void)
576 if (!active_cache_tree
)
577 active_cache_tree
= cache_tree();
579 if (!cache_tree_fully_valid(active_cache_tree
))
580 if (cache_tree_update(&the_index
, 0)) {
581 error(_("unable to update cache tree"));
585 return &active_cache_tree
->oid
;
588 static int is_index_unchanged(void)
590 struct object_id head_oid
, *cache_tree_oid
;
591 struct commit
*head_commit
;
593 if (!resolve_ref_unsafe("HEAD", RESOLVE_REF_READING
, &head_oid
, NULL
))
594 return error(_("could not resolve HEAD commit"));
596 head_commit
= lookup_commit(&head_oid
);
599 * If head_commit is NULL, check_commit, called from
600 * lookup_commit, would have indicated that head_commit is not
601 * a commit object already. parse_commit() will return failure
602 * without further complaints in such a case. Otherwise, if
603 * the commit is invalid, parse_commit() will complain. So
604 * there is nothing for us to say here. Just return failure.
606 if (parse_commit(head_commit
))
609 if (!(cache_tree_oid
= get_cache_tree_oid()))
612 return !oidcmp(cache_tree_oid
, get_commit_tree_oid(head_commit
));
615 static int write_author_script(const char *message
)
617 struct strbuf buf
= STRBUF_INIT
;
622 if (!*message
|| starts_with(message
, "\n")) {
624 /* Missing 'author' line? */
625 unlink(rebase_path_author_script());
627 } else if (skip_prefix(message
, "author ", &message
))
629 else if ((eol
= strchr(message
, '\n')))
634 strbuf_addstr(&buf
, "GIT_AUTHOR_NAME='");
635 while (*message
&& *message
!= '\n' && *message
!= '\r')
636 if (skip_prefix(message
, " <", &message
))
638 else if (*message
!= '\'')
639 strbuf_addch(&buf
, *(message
++));
641 strbuf_addf(&buf
, "'\\\\%c'", *(message
++));
642 strbuf_addstr(&buf
, "'\nGIT_AUTHOR_EMAIL='");
643 while (*message
&& *message
!= '\n' && *message
!= '\r')
644 if (skip_prefix(message
, "> ", &message
))
646 else if (*message
!= '\'')
647 strbuf_addch(&buf
, *(message
++));
649 strbuf_addf(&buf
, "'\\\\%c'", *(message
++));
650 strbuf_addstr(&buf
, "'\nGIT_AUTHOR_DATE='@");
651 while (*message
&& *message
!= '\n' && *message
!= '\r')
652 if (*message
!= '\'')
653 strbuf_addch(&buf
, *(message
++));
655 strbuf_addf(&buf
, "'\\\\%c'", *(message
++));
656 res
= write_message(buf
.buf
, buf
.len
, rebase_path_author_script(), 1);
657 strbuf_release(&buf
);
662 * Read a list of environment variable assignments (such as the author-script
663 * file) into an environment block. Returns -1 on error, 0 otherwise.
665 static int read_env_script(struct argv_array
*env
)
667 struct strbuf script
= STRBUF_INIT
;
671 if (strbuf_read_file(&script
, rebase_path_author_script(), 256) <= 0)
674 for (p
= script
.buf
; *p
; p
++)
675 if (skip_prefix(p
, "'\\\\''", (const char **)&p2
))
676 strbuf_splice(&script
, p
- script
.buf
, p2
- p
, "'", 1);
678 strbuf_splice(&script
, p
-- - script
.buf
, 1, "", 0);
679 else if (*p
== '\n') {
684 for (i
= 0, p
= script
.buf
; i
< count
; i
++) {
685 argv_array_push(env
, p
);
692 static char *get_author(const char *message
)
697 a
= find_commit_header(message
, "author", &len
);
699 return xmemdupz(a
, len
);
704 /* Read author-script and return an ident line (author <email> timestamp) */
705 static const char *read_author_ident(struct strbuf
*buf
)
707 const char *keys
[] = {
708 "GIT_AUTHOR_NAME=", "GIT_AUTHOR_EMAIL=", "GIT_AUTHOR_DATE="
710 char *in
, *out
, *eol
;
713 if (strbuf_read_file(buf
, rebase_path_author_script(), 256) <= 0)
716 /* dequote values and construct ident line in-place */
717 for (in
= out
= buf
->buf
; i
< 3 && in
- buf
->buf
< buf
->len
; i
++) {
718 if (!skip_prefix(in
, keys
[i
], (const char **)&in
)) {
719 warning(_("could not parse '%s' (looking for '%s'"),
720 rebase_path_author_script(), keys
[i
]);
724 eol
= strchrnul(in
, '\n');
729 if (i
> 0) /* separate values by spaces */
731 if (i
== 1) /* email needs to be surrounded by <...> */
733 memmove(out
, in
, len
);
735 if (i
== 1) /* email needs to be surrounded by <...> */
741 warning(_("could not parse '%s' (looking for '%s')"),
742 rebase_path_author_script(), keys
[i
]);
746 buf
->len
= out
- buf
->buf
;
750 static const char staged_changes_advice
[] =
751 N_("you have staged changes in your working tree\n"
752 "If these changes are meant to be squashed into the previous commit, run:\n"
754 " git commit --amend %s\n"
756 "If they are meant to go into a new commit, run:\n"
760 "In both cases, once you're done, continue with:\n"
762 " git rebase --continue\n");
764 #define ALLOW_EMPTY (1<<0)
765 #define EDIT_MSG (1<<1)
766 #define AMEND_MSG (1<<2)
767 #define CLEANUP_MSG (1<<3)
768 #define VERIFY_MSG (1<<4)
769 #define CREATE_ROOT_COMMIT (1<<5)
772 * If we are cherry-pick, and if the merge did not result in
773 * hand-editing, we will hit this commit and inherit the original
774 * author date and name.
776 * If we are revert, or if our cherry-pick results in a hand merge,
777 * we had better say that the current user is responsible for that.
779 * An exception is when run_git_commit() is called during an
780 * interactive rebase: in that case, we will want to retain the
783 static int run_git_commit(const char *defmsg
, struct replay_opts
*opts
,
786 struct child_process cmd
= CHILD_PROCESS_INIT
;
789 if ((flags
& CREATE_ROOT_COMMIT
) && !(flags
& AMEND_MSG
)) {
790 struct strbuf msg
= STRBUF_INIT
, script
= STRBUF_INIT
;
791 const char *author
= is_rebase_i(opts
) ?
792 read_author_ident(&script
) : NULL
;
793 struct object_id root_commit
, *cache_tree_oid
;
797 BUG("root commit without message");
799 if (!(cache_tree_oid
= get_cache_tree_oid()))
803 res
= strbuf_read_file(&msg
, defmsg
, 0);
806 res
= error_errno(_("could not read '%s'"), defmsg
);
808 res
= commit_tree(msg
.buf
, msg
.len
, cache_tree_oid
,
809 NULL
, &root_commit
, author
,
812 strbuf_release(&msg
);
813 strbuf_release(&script
);
815 update_ref(NULL
, "CHERRY_PICK_HEAD", &root_commit
, NULL
,
816 REF_NO_DEREF
, UPDATE_REFS_MSG_ON_ERR
);
817 res
= update_ref(NULL
, "HEAD", &root_commit
, NULL
, 0,
818 UPDATE_REFS_MSG_ON_ERR
);
820 return res
< 0 ? error(_("writing root commit")) : 0;
825 if (is_rebase_i(opts
)) {
826 if (!(flags
& EDIT_MSG
)) {
827 cmd
.stdout_to_stderr
= 1;
831 if (read_env_script(&cmd
.env_array
)) {
832 const char *gpg_opt
= gpg_sign_opt_quoted(opts
);
834 return error(_(staged_changes_advice
),
839 argv_array_push(&cmd
.args
, "commit");
841 if (!(flags
& VERIFY_MSG
))
842 argv_array_push(&cmd
.args
, "-n");
843 if ((flags
& AMEND_MSG
))
844 argv_array_push(&cmd
.args
, "--amend");
846 argv_array_pushf(&cmd
.args
, "-S%s", opts
->gpg_sign
);
848 argv_array_pushl(&cmd
.args
, "-F", defmsg
, NULL
);
849 else if (!(flags
& EDIT_MSG
))
850 argv_array_pushl(&cmd
.args
, "-C", "HEAD", NULL
);
851 if ((flags
& CLEANUP_MSG
))
852 argv_array_push(&cmd
.args
, "--cleanup=strip");
853 if ((flags
& EDIT_MSG
))
854 argv_array_push(&cmd
.args
, "-e");
855 else if (!(flags
& CLEANUP_MSG
) &&
856 !opts
->signoff
&& !opts
->record_origin
&&
857 git_config_get_value("commit.cleanup", &value
))
858 argv_array_push(&cmd
.args
, "--cleanup=verbatim");
860 if ((flags
& ALLOW_EMPTY
))
861 argv_array_push(&cmd
.args
, "--allow-empty");
863 if (opts
->allow_empty_message
)
864 argv_array_push(&cmd
.args
, "--allow-empty-message");
867 /* hide stderr on success */
868 struct strbuf buf
= STRBUF_INIT
;
869 int rc
= pipe_command(&cmd
,
871 /* stdout is already redirected */
875 fputs(buf
.buf
, stderr
);
876 strbuf_release(&buf
);
880 return run_command(&cmd
);
883 static int rest_is_empty(const struct strbuf
*sb
, int start
)
888 /* Check if the rest is just whitespace and Signed-off-by's. */
889 for (i
= start
; i
< sb
->len
; i
++) {
890 nl
= memchr(sb
->buf
+ i
, '\n', sb
->len
- i
);
896 if (strlen(sign_off_header
) <= eol
- i
&&
897 starts_with(sb
->buf
+ i
, sign_off_header
)) {
902 if (!isspace(sb
->buf
[i
++]))
910 * Find out if the message in the strbuf contains only whitespace and
911 * Signed-off-by lines.
913 int message_is_empty(const struct strbuf
*sb
,
914 enum commit_msg_cleanup_mode cleanup_mode
)
916 if (cleanup_mode
== COMMIT_MSG_CLEANUP_NONE
&& sb
->len
)
918 return rest_is_empty(sb
, 0);
922 * See if the user edited the message in the editor or left what
923 * was in the template intact
925 int template_untouched(const struct strbuf
*sb
, const char *template_file
,
926 enum commit_msg_cleanup_mode cleanup_mode
)
928 struct strbuf tmpl
= STRBUF_INIT
;
931 if (cleanup_mode
== COMMIT_MSG_CLEANUP_NONE
&& sb
->len
)
934 if (!template_file
|| strbuf_read_file(&tmpl
, template_file
, 0) <= 0)
937 strbuf_stripspace(&tmpl
, cleanup_mode
== COMMIT_MSG_CLEANUP_ALL
);
938 if (!skip_prefix(sb
->buf
, tmpl
.buf
, &start
))
940 strbuf_release(&tmpl
);
941 return rest_is_empty(sb
, start
- sb
->buf
);
944 int update_head_with_reflog(const struct commit
*old_head
,
945 const struct object_id
*new_head
,
946 const char *action
, const struct strbuf
*msg
,
949 struct ref_transaction
*transaction
;
950 struct strbuf sb
= STRBUF_INIT
;
955 strbuf_addstr(&sb
, action
);
956 strbuf_addstr(&sb
, ": ");
959 nl
= strchr(msg
->buf
, '\n');
961 strbuf_add(&sb
, msg
->buf
, nl
+ 1 - msg
->buf
);
963 strbuf_addbuf(&sb
, msg
);
964 strbuf_addch(&sb
, '\n');
967 transaction
= ref_transaction_begin(err
);
969 ref_transaction_update(transaction
, "HEAD", new_head
,
970 old_head
? &old_head
->object
.oid
: &null_oid
,
972 ref_transaction_commit(transaction
, err
)) {
975 ref_transaction_free(transaction
);
981 static int run_rewrite_hook(const struct object_id
*oldoid
,
982 const struct object_id
*newoid
)
984 struct child_process proc
= CHILD_PROCESS_INIT
;
987 struct strbuf sb
= STRBUF_INIT
;
989 argv
[0] = find_hook("post-rewrite");
998 proc
.stdout_to_stderr
= 1;
1000 code
= start_command(&proc
);
1003 strbuf_addf(&sb
, "%s %s\n", oid_to_hex(oldoid
), oid_to_hex(newoid
));
1004 sigchain_push(SIGPIPE
, SIG_IGN
);
1005 write_in_full(proc
.in
, sb
.buf
, sb
.len
);
1007 strbuf_release(&sb
);
1008 sigchain_pop(SIGPIPE
);
1009 return finish_command(&proc
);
1012 void commit_post_rewrite(const struct commit
*old_head
,
1013 const struct object_id
*new_head
)
1015 struct notes_rewrite_cfg
*cfg
;
1017 cfg
= init_copy_notes_for_rewrite("amend");
1019 /* we are amending, so old_head is not NULL */
1020 copy_note_for_rewrite(cfg
, &old_head
->object
.oid
, new_head
);
1021 finish_copy_notes_for_rewrite(cfg
, "Notes added by 'git commit --amend'");
1023 run_rewrite_hook(&old_head
->object
.oid
, new_head
);
1026 static int run_prepare_commit_msg_hook(struct strbuf
*msg
, const char *commit
)
1028 struct argv_array hook_env
= ARGV_ARRAY_INIT
;
1032 name
= git_path_commit_editmsg();
1033 if (write_message(msg
->buf
, msg
->len
, name
, 0))
1036 argv_array_pushf(&hook_env
, "GIT_INDEX_FILE=%s", get_index_file());
1037 argv_array_push(&hook_env
, "GIT_EDITOR=:");
1039 ret
= run_hook_le(hook_env
.argv
, "prepare-commit-msg", name
,
1040 "commit", commit
, NULL
);
1042 ret
= run_hook_le(hook_env
.argv
, "prepare-commit-msg", name
,
1045 ret
= error(_("'prepare-commit-msg' hook failed"));
1046 argv_array_clear(&hook_env
);
1051 static const char implicit_ident_advice_noconfig
[] =
1052 N_("Your name and email address were configured automatically based\n"
1053 "on your username and hostname. Please check that they are accurate.\n"
1054 "You can suppress this message by setting them explicitly. Run the\n"
1055 "following command and follow the instructions in your editor to edit\n"
1056 "your configuration file:\n"
1058 " git config --global --edit\n"
1060 "After doing this, you may fix the identity used for this commit with:\n"
1062 " git commit --amend --reset-author\n");
1064 static const char implicit_ident_advice_config
[] =
1065 N_("Your name and email address were configured automatically based\n"
1066 "on your username and hostname. Please check that they are accurate.\n"
1067 "You can suppress this message by setting them explicitly:\n"
1069 " git config --global user.name \"Your Name\"\n"
1070 " git config --global user.email you@example.com\n"
1072 "After doing this, you may fix the identity used for this commit with:\n"
1074 " git commit --amend --reset-author\n");
1076 static const char *implicit_ident_advice(void)
1078 char *user_config
= expand_user_path("~/.gitconfig", 0);
1079 char *xdg_config
= xdg_config_home("config");
1080 int config_exists
= file_exists(user_config
) || file_exists(xdg_config
);
1086 return _(implicit_ident_advice_config
);
1088 return _(implicit_ident_advice_noconfig
);
1092 void print_commit_summary(const char *prefix
, const struct object_id
*oid
,
1095 struct rev_info rev
;
1096 struct commit
*commit
;
1097 struct strbuf format
= STRBUF_INIT
;
1099 struct pretty_print_context pctx
= {0};
1100 struct strbuf author_ident
= STRBUF_INIT
;
1101 struct strbuf committer_ident
= STRBUF_INIT
;
1103 commit
= lookup_commit(oid
);
1105 die(_("couldn't look up newly created commit"));
1106 if (parse_commit(commit
))
1107 die(_("could not parse newly created commit"));
1109 strbuf_addstr(&format
, "format:%h] %s");
1111 format_commit_message(commit
, "%an <%ae>", &author_ident
, &pctx
);
1112 format_commit_message(commit
, "%cn <%ce>", &committer_ident
, &pctx
);
1113 if (strbuf_cmp(&author_ident
, &committer_ident
)) {
1114 strbuf_addstr(&format
, "\n Author: ");
1115 strbuf_addbuf_percentquote(&format
, &author_ident
);
1117 if (flags
& SUMMARY_SHOW_AUTHOR_DATE
) {
1118 struct strbuf date
= STRBUF_INIT
;
1120 format_commit_message(commit
, "%ad", &date
, &pctx
);
1121 strbuf_addstr(&format
, "\n Date: ");
1122 strbuf_addbuf_percentquote(&format
, &date
);
1123 strbuf_release(&date
);
1125 if (!committer_ident_sufficiently_given()) {
1126 strbuf_addstr(&format
, "\n Committer: ");
1127 strbuf_addbuf_percentquote(&format
, &committer_ident
);
1128 if (advice_implicit_identity
) {
1129 strbuf_addch(&format
, '\n');
1130 strbuf_addstr(&format
, implicit_ident_advice());
1133 strbuf_release(&author_ident
);
1134 strbuf_release(&committer_ident
);
1136 init_revisions(&rev
, prefix
);
1137 setup_revisions(0, NULL
, &rev
, NULL
);
1140 rev
.diffopt
.output_format
=
1141 DIFF_FORMAT_SHORTSTAT
| DIFF_FORMAT_SUMMARY
;
1143 rev
.verbose_header
= 1;
1144 rev
.show_root_diff
= 1;
1145 get_commit_format(format
.buf
, &rev
);
1146 rev
.always_show_header
= 0;
1147 rev
.diffopt
.detect_rename
= DIFF_DETECT_RENAME
;
1148 rev
.diffopt
.break_opt
= 0;
1149 diff_setup_done(&rev
.diffopt
);
1151 head
= resolve_ref_unsafe("HEAD", 0, NULL
, NULL
);
1153 die_errno(_("unable to resolve HEAD after creating commit"));
1154 if (!strcmp(head
, "HEAD"))
1155 head
= _("detached HEAD");
1157 skip_prefix(head
, "refs/heads/", &head
);
1158 printf("[%s%s ", head
, (flags
& SUMMARY_INITIAL_COMMIT
) ?
1159 _(" (root-commit)") : "");
1161 if (!log_tree_commit(&rev
, commit
)) {
1162 rev
.always_show_header
= 1;
1163 rev
.use_terminator
= 1;
1164 log_tree_commit(&rev
, commit
);
1167 strbuf_release(&format
);
1170 static int parse_head(struct commit
**head
)
1172 struct commit
*current_head
;
1173 struct object_id oid
;
1175 if (get_oid("HEAD", &oid
)) {
1176 current_head
= NULL
;
1178 current_head
= lookup_commit_reference(&oid
);
1180 return error(_("could not parse HEAD"));
1181 if (oidcmp(&oid
, ¤t_head
->object
.oid
)) {
1182 warning(_("HEAD %s is not a commit!"),
1185 if (parse_commit(current_head
))
1186 return error(_("could not parse HEAD commit"));
1188 *head
= current_head
;
1194 * Try to commit without forking 'git commit'. In some cases we need
1195 * to run 'git commit' to display an error message
1198 * -1 - error unable to commit
1200 * 1 - run 'git commit'
1202 static int try_to_commit(struct strbuf
*msg
, const char *author
,
1203 struct replay_opts
*opts
, unsigned int flags
,
1204 struct object_id
*oid
)
1206 struct object_id tree
;
1207 struct commit
*current_head
;
1208 struct commit_list
*parents
= NULL
;
1209 struct commit_extra_header
*extra
= NULL
;
1210 struct strbuf err
= STRBUF_INIT
;
1211 struct strbuf commit_msg
= STRBUF_INIT
;
1212 char *amend_author
= NULL
;
1213 const char *hook_commit
= NULL
;
1214 enum commit_msg_cleanup_mode cleanup
;
1217 if (parse_head(¤t_head
))
1220 if (flags
& AMEND_MSG
) {
1221 const char *exclude_gpgsig
[] = { "gpgsig", NULL
};
1222 const char *out_enc
= get_commit_output_encoding();
1223 const char *message
= logmsg_reencode(current_head
, NULL
,
1227 const char *orig_message
= NULL
;
1229 find_commit_subject(message
, &orig_message
);
1231 strbuf_addstr(msg
, orig_message
);
1232 hook_commit
= "HEAD";
1234 author
= amend_author
= get_author(message
);
1235 unuse_commit_buffer(current_head
, message
);
1237 res
= error(_("unable to parse commit author"));
1240 parents
= copy_commit_list(current_head
->parents
);
1241 extra
= read_commit_extra_headers(current_head
, exclude_gpgsig
);
1242 } else if (current_head
) {
1243 commit_list_insert(current_head
, &parents
);
1246 if (write_cache_as_tree(&tree
, 0, NULL
)) {
1247 res
= error(_("git write-tree failed to write a tree"));
1251 if (!(flags
& ALLOW_EMPTY
) && !oidcmp(current_head
?
1252 get_commit_tree_oid(current_head
) :
1253 the_hash_algo
->empty_tree
, &tree
)) {
1254 res
= 1; /* run 'git commit' to display error message */
1258 if (find_hook("prepare-commit-msg")) {
1259 res
= run_prepare_commit_msg_hook(msg
, hook_commit
);
1262 if (strbuf_read_file(&commit_msg
, git_path_commit_editmsg(),
1264 res
= error_errno(_("unable to read commit message "
1266 git_path_commit_editmsg());
1272 cleanup
= (flags
& CLEANUP_MSG
) ? COMMIT_MSG_CLEANUP_ALL
:
1273 opts
->default_msg_cleanup
;
1275 if (cleanup
!= COMMIT_MSG_CLEANUP_NONE
)
1276 strbuf_stripspace(msg
, cleanup
== COMMIT_MSG_CLEANUP_ALL
);
1277 if (!opts
->allow_empty_message
&& message_is_empty(msg
, cleanup
)) {
1278 res
= 1; /* run 'git commit' to display error message */
1284 if (commit_tree_extended(msg
->buf
, msg
->len
, &tree
, parents
,
1285 oid
, author
, opts
->gpg_sign
, extra
)) {
1286 res
= error(_("failed to write commit object"));
1290 if (update_head_with_reflog(current_head
, oid
,
1291 getenv("GIT_REFLOG_ACTION"), msg
, &err
)) {
1292 res
= error("%s", err
.buf
);
1296 if (flags
& AMEND_MSG
)
1297 commit_post_rewrite(current_head
, oid
);
1300 free_commit_extra_headers(extra
);
1301 strbuf_release(&err
);
1302 strbuf_release(&commit_msg
);
1308 static int do_commit(const char *msg_file
, const char *author
,
1309 struct replay_opts
*opts
, unsigned int flags
)
1313 if (!(flags
& EDIT_MSG
) && !(flags
& VERIFY_MSG
) &&
1314 !(flags
& CREATE_ROOT_COMMIT
)) {
1315 struct object_id oid
;
1316 struct strbuf sb
= STRBUF_INIT
;
1318 if (msg_file
&& strbuf_read_file(&sb
, msg_file
, 2048) < 0)
1319 return error_errno(_("unable to read commit message "
1323 res
= try_to_commit(msg_file
? &sb
: NULL
, author
, opts
, flags
,
1325 strbuf_release(&sb
);
1327 unlink(git_path_cherry_pick_head());
1328 unlink(git_path_merge_msg());
1329 if (!is_rebase_i(opts
))
1330 print_commit_summary(NULL
, &oid
,
1331 SUMMARY_SHOW_AUTHOR_DATE
);
1336 return run_git_commit(msg_file
, opts
, flags
);
1341 static int is_original_commit_empty(struct commit
*commit
)
1343 const struct object_id
*ptree_oid
;
1345 if (parse_commit(commit
))
1346 return error(_("could not parse commit %s"),
1347 oid_to_hex(&commit
->object
.oid
));
1348 if (commit
->parents
) {
1349 struct commit
*parent
= commit
->parents
->item
;
1350 if (parse_commit(parent
))
1351 return error(_("could not parse parent commit %s"),
1352 oid_to_hex(&parent
->object
.oid
));
1353 ptree_oid
= get_commit_tree_oid(parent
);
1355 ptree_oid
= the_hash_algo
->empty_tree
; /* commit is root */
1358 return !oidcmp(ptree_oid
, get_commit_tree_oid(commit
));
1362 * Do we run "git commit" with "--allow-empty"?
1364 static int allow_empty(struct replay_opts
*opts
, struct commit
*commit
)
1366 int index_unchanged
, empty_commit
;
1371 * (1) we do not allow empty at all and error out.
1373 * (2) we allow ones that were initially empty, but
1374 * forbid the ones that become empty;
1376 * (3) we allow both.
1378 if (!opts
->allow_empty
)
1379 return 0; /* let "git commit" barf as necessary */
1381 index_unchanged
= is_index_unchanged();
1382 if (index_unchanged
< 0)
1383 return index_unchanged
;
1384 if (!index_unchanged
)
1385 return 0; /* we do not have to say --allow-empty */
1387 if (opts
->keep_redundant_commits
)
1390 empty_commit
= is_original_commit_empty(commit
);
1391 if (empty_commit
< 0)
1392 return empty_commit
;
1400 * Note that ordering matters in this enum. Not only must it match the mapping
1401 * below, it is also divided into several sections that matter. When adding
1402 * new commands, make sure you add it in the right section.
1405 /* commands that handle commits */
1412 /* commands that do something else than handling a single commit */
1417 /* commands that do nothing but are counted for reporting progress */
1420 /* comments (not counted for reporting progress) */
1427 } todo_command_info
[] = {
1443 static const char *command_to_string(const enum todo_command command
)
1445 if (command
< TODO_COMMENT
)
1446 return todo_command_info
[command
].str
;
1447 die(_("unknown command: %d"), command
);
1450 static char command_to_char(const enum todo_command command
)
1452 if (command
< TODO_COMMENT
&& todo_command_info
[command
].c
)
1453 return todo_command_info
[command
].c
;
1454 return comment_line_char
;
1457 static int is_noop(const enum todo_command command
)
1459 return TODO_NOOP
<= command
;
1462 static int is_fixup(enum todo_command command
)
1464 return command
== TODO_FIXUP
|| command
== TODO_SQUASH
;
1467 /* Does this command create a (non-merge) commit? */
1468 static int is_pick_or_similar(enum todo_command command
)
1483 static int update_squash_messages(enum todo_command command
,
1484 struct commit
*commit
, struct replay_opts
*opts
)
1486 struct strbuf buf
= STRBUF_INIT
;
1488 const char *message
, *body
;
1490 if (opts
->current_fixup_count
> 0) {
1491 struct strbuf header
= STRBUF_INIT
;
1494 if (strbuf_read_file(&buf
, rebase_path_squash_msg(), 9) <= 0)
1495 return error(_("could not read '%s'"),
1496 rebase_path_squash_msg());
1498 eol
= buf
.buf
[0] != comment_line_char
?
1499 buf
.buf
: strchrnul(buf
.buf
, '\n');
1501 strbuf_addf(&header
, "%c ", comment_line_char
);
1502 strbuf_addf(&header
, _("This is a combination of %d commits."),
1503 opts
->current_fixup_count
+ 2);
1504 strbuf_splice(&buf
, 0, eol
- buf
.buf
, header
.buf
, header
.len
);
1505 strbuf_release(&header
);
1507 struct object_id head
;
1508 struct commit
*head_commit
;
1509 const char *head_message
, *body
;
1511 if (get_oid("HEAD", &head
))
1512 return error(_("need a HEAD to fixup"));
1513 if (!(head_commit
= lookup_commit_reference(&head
)))
1514 return error(_("could not read HEAD"));
1515 if (!(head_message
= get_commit_buffer(head_commit
, NULL
)))
1516 return error(_("could not read HEAD's commit message"));
1518 find_commit_subject(head_message
, &body
);
1519 if (write_message(body
, strlen(body
),
1520 rebase_path_fixup_msg(), 0)) {
1521 unuse_commit_buffer(head_commit
, head_message
);
1522 return error(_("cannot write '%s'"),
1523 rebase_path_fixup_msg());
1526 strbuf_addf(&buf
, "%c ", comment_line_char
);
1527 strbuf_addf(&buf
, _("This is a combination of %d commits."), 2);
1528 strbuf_addf(&buf
, "\n%c ", comment_line_char
);
1529 strbuf_addstr(&buf
, _("This is the 1st commit message:"));
1530 strbuf_addstr(&buf
, "\n\n");
1531 strbuf_addstr(&buf
, body
);
1533 unuse_commit_buffer(head_commit
, head_message
);
1536 if (!(message
= get_commit_buffer(commit
, NULL
)))
1537 return error(_("could not read commit message of %s"),
1538 oid_to_hex(&commit
->object
.oid
));
1539 find_commit_subject(message
, &body
);
1541 if (command
== TODO_SQUASH
) {
1542 unlink(rebase_path_fixup_msg());
1543 strbuf_addf(&buf
, "\n%c ", comment_line_char
);
1544 strbuf_addf(&buf
, _("This is the commit message #%d:"),
1545 ++opts
->current_fixup_count
);
1546 strbuf_addstr(&buf
, "\n\n");
1547 strbuf_addstr(&buf
, body
);
1548 } else if (command
== TODO_FIXUP
) {
1549 strbuf_addf(&buf
, "\n%c ", comment_line_char
);
1550 strbuf_addf(&buf
, _("The commit message #%d will be skipped:"),
1551 ++opts
->current_fixup_count
);
1552 strbuf_addstr(&buf
, "\n\n");
1553 strbuf_add_commented_lines(&buf
, body
, strlen(body
));
1555 return error(_("unknown command: %d"), command
);
1556 unuse_commit_buffer(commit
, message
);
1558 res
= write_message(buf
.buf
, buf
.len
, rebase_path_squash_msg(), 0);
1559 strbuf_release(&buf
);
1562 strbuf_addf(&opts
->current_fixups
, "%s%s %s",
1563 opts
->current_fixups
.len
? "\n" : "",
1564 command_to_string(command
),
1565 oid_to_hex(&commit
->object
.oid
));
1566 res
= write_message(opts
->current_fixups
.buf
,
1567 opts
->current_fixups
.len
,
1568 rebase_path_current_fixups(), 0);
1574 static void flush_rewritten_pending(void) {
1575 struct strbuf buf
= STRBUF_INIT
;
1576 struct object_id newoid
;
1579 if (strbuf_read_file(&buf
, rebase_path_rewritten_pending(), (GIT_MAX_HEXSZ
+ 1) * 2) > 0 &&
1580 !get_oid("HEAD", &newoid
) &&
1581 (out
= fopen_or_warn(rebase_path_rewritten_list(), "a"))) {
1582 char *bol
= buf
.buf
, *eol
;
1585 eol
= strchrnul(bol
, '\n');
1586 fprintf(out
, "%.*s %s\n", (int)(eol
- bol
),
1587 bol
, oid_to_hex(&newoid
));
1593 unlink(rebase_path_rewritten_pending());
1595 strbuf_release(&buf
);
1598 static void record_in_rewritten(struct object_id
*oid
,
1599 enum todo_command next_command
) {
1600 FILE *out
= fopen_or_warn(rebase_path_rewritten_pending(), "a");
1605 fprintf(out
, "%s\n", oid_to_hex(oid
));
1608 if (!is_fixup(next_command
))
1609 flush_rewritten_pending();
1612 static int do_pick_commit(enum todo_command command
, struct commit
*commit
,
1613 struct replay_opts
*opts
, int final_fixup
)
1615 unsigned int flags
= opts
->edit
? EDIT_MSG
: 0;
1616 const char *msg_file
= opts
->edit
? NULL
: git_path_merge_msg();
1617 struct object_id head
;
1618 struct commit
*base
, *next
, *parent
;
1619 const char *base_label
, *next_label
;
1620 char *author
= NULL
;
1621 struct commit_message msg
= { NULL
, NULL
, NULL
, NULL
};
1622 struct strbuf msgbuf
= STRBUF_INIT
;
1623 int res
, unborn
= 0, allow
;
1625 if (opts
->no_commit
) {
1627 * We do not intend to commit immediately. We just want to
1628 * merge the differences in, so let's compute the tree
1629 * that represents the "current" state for merge-recursive
1632 if (write_cache_as_tree(&head
, 0, NULL
))
1633 return error(_("your index file is unmerged."));
1635 unborn
= get_oid("HEAD", &head
);
1636 /* Do we want to generate a root commit? */
1637 if (is_pick_or_similar(command
) && opts
->have_squash_onto
&&
1638 !oidcmp(&head
, &opts
->squash_onto
)) {
1639 if (is_fixup(command
))
1640 return error(_("cannot fixup root commit"));
1641 flags
|= CREATE_ROOT_COMMIT
;
1644 oidcpy(&head
, the_hash_algo
->empty_tree
);
1645 if (index_differs_from(unborn
? empty_tree_oid_hex() : "HEAD",
1647 return error_dirty_index(opts
);
1651 if (!commit
->parents
)
1653 else if (commit
->parents
->next
) {
1654 /* Reverting or cherry-picking a merge commit */
1656 struct commit_list
*p
;
1658 if (!opts
->mainline
)
1659 return error(_("commit %s is a merge but no -m option was given."),
1660 oid_to_hex(&commit
->object
.oid
));
1662 for (cnt
= 1, p
= commit
->parents
;
1663 cnt
!= opts
->mainline
&& p
;
1666 if (cnt
!= opts
->mainline
|| !p
)
1667 return error(_("commit %s does not have parent %d"),
1668 oid_to_hex(&commit
->object
.oid
), opts
->mainline
);
1670 } else if (0 < opts
->mainline
)
1671 return error(_("mainline was specified but commit %s is not a merge."),
1672 oid_to_hex(&commit
->object
.oid
));
1674 parent
= commit
->parents
->item
;
1676 if (get_message(commit
, &msg
) != 0)
1677 return error(_("cannot get commit message for %s"),
1678 oid_to_hex(&commit
->object
.oid
));
1680 if (opts
->allow_ff
&& !is_fixup(command
) &&
1681 ((parent
&& !oidcmp(&parent
->object
.oid
, &head
)) ||
1682 (!parent
&& unborn
))) {
1683 if (is_rebase_i(opts
))
1684 write_author_script(msg
.message
);
1685 res
= fast_forward_to(&commit
->object
.oid
, &head
, unborn
,
1687 if (res
|| command
!= TODO_REWORD
)
1689 flags
|= EDIT_MSG
| AMEND_MSG
| VERIFY_MSG
;
1691 goto fast_forward_edit
;
1693 if (parent
&& parse_commit(parent
) < 0)
1694 /* TRANSLATORS: The first %s will be a "todo" command like
1695 "revert" or "pick", the second %s a SHA1. */
1696 return error(_("%s: cannot parse parent commit %s"),
1697 command_to_string(command
),
1698 oid_to_hex(&parent
->object
.oid
));
1701 * "commit" is an existing commit. We would want to apply
1702 * the difference it introduces since its first parent "prev"
1703 * on top of the current HEAD if we are cherry-pick. Or the
1704 * reverse of it if we are revert.
1707 if (command
== TODO_REVERT
) {
1709 base_label
= msg
.label
;
1711 next_label
= msg
.parent_label
;
1712 strbuf_addstr(&msgbuf
, "Revert \"");
1713 strbuf_addstr(&msgbuf
, msg
.subject
);
1714 strbuf_addstr(&msgbuf
, "\"\n\nThis reverts commit ");
1715 strbuf_addstr(&msgbuf
, oid_to_hex(&commit
->object
.oid
));
1717 if (commit
->parents
&& commit
->parents
->next
) {
1718 strbuf_addstr(&msgbuf
, ", reversing\nchanges made to ");
1719 strbuf_addstr(&msgbuf
, oid_to_hex(&parent
->object
.oid
));
1721 strbuf_addstr(&msgbuf
, ".\n");
1726 base_label
= msg
.parent_label
;
1728 next_label
= msg
.label
;
1730 /* Append the commit log message to msgbuf. */
1731 if (find_commit_subject(msg
.message
, &p
))
1732 strbuf_addstr(&msgbuf
, p
);
1734 if (opts
->record_origin
) {
1735 strbuf_complete_line(&msgbuf
);
1736 if (!has_conforming_footer(&msgbuf
, NULL
, 0))
1737 strbuf_addch(&msgbuf
, '\n');
1738 strbuf_addstr(&msgbuf
, cherry_picked_prefix
);
1739 strbuf_addstr(&msgbuf
, oid_to_hex(&commit
->object
.oid
));
1740 strbuf_addstr(&msgbuf
, ")\n");
1742 if (!is_fixup(command
))
1743 author
= get_author(msg
.message
);
1746 if (command
== TODO_REWORD
)
1747 flags
|= EDIT_MSG
| VERIFY_MSG
;
1748 else if (is_fixup(command
)) {
1749 if (update_squash_messages(command
, commit
, opts
))
1753 msg_file
= rebase_path_squash_msg();
1754 else if (file_exists(rebase_path_fixup_msg())) {
1755 flags
|= CLEANUP_MSG
;
1756 msg_file
= rebase_path_fixup_msg();
1758 const char *dest
= git_path_squash_msg();
1760 if (copy_file(dest
, rebase_path_squash_msg(), 0666))
1761 return error(_("could not rename '%s' to '%s'"),
1762 rebase_path_squash_msg(), dest
);
1763 unlink(git_path_merge_msg());
1769 if (opts
->signoff
&& !is_fixup(command
))
1770 append_signoff(&msgbuf
, 0, 0);
1772 if (is_rebase_i(opts
) && write_author_script(msg
.message
) < 0)
1774 else if (!opts
->strategy
|| !strcmp(opts
->strategy
, "recursive") || command
== TODO_REVERT
) {
1775 res
= do_recursive_merge(base
, next
, base_label
, next_label
,
1776 &head
, &msgbuf
, opts
);
1780 res
|= write_message(msgbuf
.buf
, msgbuf
.len
,
1781 git_path_merge_msg(), 0);
1783 struct commit_list
*common
= NULL
;
1784 struct commit_list
*remotes
= NULL
;
1786 res
= write_message(msgbuf
.buf
, msgbuf
.len
,
1787 git_path_merge_msg(), 0);
1789 commit_list_insert(base
, &common
);
1790 commit_list_insert(next
, &remotes
);
1791 res
|= try_merge_command(opts
->strategy
,
1792 opts
->xopts_nr
, (const char **)opts
->xopts
,
1793 common
, oid_to_hex(&head
), remotes
);
1794 free_commit_list(common
);
1795 free_commit_list(remotes
);
1797 strbuf_release(&msgbuf
);
1800 * If the merge was clean or if it failed due to conflict, we write
1801 * CHERRY_PICK_HEAD for the subsequent invocation of commit to use.
1802 * However, if the merge did not even start, then we don't want to
1805 if (command
== TODO_PICK
&& !opts
->no_commit
&& (res
== 0 || res
== 1) &&
1806 update_ref(NULL
, "CHERRY_PICK_HEAD", &commit
->object
.oid
, NULL
,
1807 REF_NO_DEREF
, UPDATE_REFS_MSG_ON_ERR
))
1809 if (command
== TODO_REVERT
&& ((opts
->no_commit
&& res
== 0) || res
== 1) &&
1810 update_ref(NULL
, "REVERT_HEAD", &commit
->object
.oid
, NULL
,
1811 REF_NO_DEREF
, UPDATE_REFS_MSG_ON_ERR
))
1815 error(command
== TODO_REVERT
1816 ? _("could not revert %s... %s")
1817 : _("could not apply %s... %s"),
1818 short_commit_name(commit
), msg
.subject
);
1819 print_advice(res
== 1, opts
);
1820 rerere(opts
->allow_rerere_auto
);
1824 allow
= allow_empty(opts
, commit
);
1829 flags
|= ALLOW_EMPTY
;
1830 if (!opts
->no_commit
) {
1832 if (author
|| command
== TODO_REVERT
|| (flags
& AMEND_MSG
))
1833 res
= do_commit(msg_file
, author
, opts
, flags
);
1835 res
= error(_("unable to parse commit author"));
1838 if (!res
&& final_fixup
) {
1839 unlink(rebase_path_fixup_msg());
1840 unlink(rebase_path_squash_msg());
1841 unlink(rebase_path_current_fixups());
1842 strbuf_reset(&opts
->current_fixups
);
1843 opts
->current_fixup_count
= 0;
1847 free_message(commit
, &msg
);
1849 update_abort_safety_file();
1854 static int prepare_revs(struct replay_opts
*opts
)
1857 * picking (but not reverting) ranges (but not individual revisions)
1858 * should be done in reverse
1860 if (opts
->action
== REPLAY_PICK
&& !opts
->revs
->no_walk
)
1861 opts
->revs
->reverse
^= 1;
1863 if (prepare_revision_walk(opts
->revs
))
1864 return error(_("revision walk setup failed"));
1866 if (!opts
->revs
->commits
)
1867 return error(_("empty commit set passed"));
1871 static int read_and_refresh_cache(struct replay_opts
*opts
)
1873 struct lock_file index_lock
= LOCK_INIT
;
1874 int index_fd
= hold_locked_index(&index_lock
, 0);
1875 if (read_index_preload(&the_index
, NULL
) < 0) {
1876 rollback_lock_file(&index_lock
);
1877 return error(_("git %s: failed to read the index"),
1878 _(action_name(opts
)));
1880 refresh_index(&the_index
, REFRESH_QUIET
|REFRESH_UNMERGED
, NULL
, NULL
, NULL
);
1881 if (index_fd
>= 0) {
1882 if (write_locked_index(&the_index
, &index_lock
,
1883 COMMIT_LOCK
| SKIP_IF_UNCHANGED
)) {
1884 return error(_("git %s: failed to refresh the index"),
1885 _(action_name(opts
)));
1891 enum todo_item_flags
{
1892 TODO_EDIT_MERGE_MSG
= 1
1896 enum todo_command command
;
1897 struct commit
*commit
;
1901 size_t offset_in_buf
;
1906 struct todo_item
*items
;
1907 int nr
, alloc
, current
;
1908 int done_nr
, total_nr
;
1909 struct stat_data stat
;
1912 #define TODO_LIST_INIT { STRBUF_INIT }
1914 static void todo_list_release(struct todo_list
*todo_list
)
1916 strbuf_release(&todo_list
->buf
);
1917 FREE_AND_NULL(todo_list
->items
);
1918 todo_list
->nr
= todo_list
->alloc
= 0;
1921 static struct todo_item
*append_new_todo(struct todo_list
*todo_list
)
1923 ALLOC_GROW(todo_list
->items
, todo_list
->nr
+ 1, todo_list
->alloc
);
1924 return todo_list
->items
+ todo_list
->nr
++;
1927 static int parse_insn_line(struct todo_item
*item
, const char *bol
, char *eol
)
1929 struct object_id commit_oid
;
1930 char *end_of_object_name
;
1931 int i
, saved
, status
, padding
;
1936 bol
+= strspn(bol
, " \t");
1938 if (bol
== eol
|| *bol
== '\r' || *bol
== comment_line_char
) {
1939 item
->command
= TODO_COMMENT
;
1940 item
->commit
= NULL
;
1942 item
->arg_len
= eol
- bol
;
1946 for (i
= 0; i
< TODO_COMMENT
; i
++)
1947 if (skip_prefix(bol
, todo_command_info
[i
].str
, &bol
)) {
1950 } else if (bol
[1] == ' ' && *bol
== todo_command_info
[i
].c
) {
1955 if (i
>= TODO_COMMENT
)
1958 /* Eat up extra spaces/ tabs before object name */
1959 padding
= strspn(bol
, " \t");
1962 if (item
->command
== TODO_NOOP
) {
1964 return error(_("%s does not accept arguments: '%s'"),
1965 command_to_string(item
->command
), bol
);
1966 item
->commit
= NULL
;
1968 item
->arg_len
= eol
- bol
;
1973 return error(_("missing arguments for %s"),
1974 command_to_string(item
->command
));
1976 if (item
->command
== TODO_EXEC
|| item
->command
== TODO_LABEL
||
1977 item
->command
== TODO_RESET
) {
1978 item
->commit
= NULL
;
1980 item
->arg_len
= (int)(eol
- bol
);
1984 if (item
->command
== TODO_MERGE
) {
1985 if (skip_prefix(bol
, "-C", &bol
))
1986 bol
+= strspn(bol
, " \t");
1987 else if (skip_prefix(bol
, "-c", &bol
)) {
1988 bol
+= strspn(bol
, " \t");
1989 item
->flags
|= TODO_EDIT_MERGE_MSG
;
1991 item
->flags
|= TODO_EDIT_MERGE_MSG
;
1992 item
->commit
= NULL
;
1994 item
->arg_len
= (int)(eol
- bol
);
1999 end_of_object_name
= (char *) bol
+ strcspn(bol
, " \t\n");
2000 saved
= *end_of_object_name
;
2001 *end_of_object_name
= '\0';
2002 status
= get_oid(bol
, &commit_oid
);
2003 *end_of_object_name
= saved
;
2005 item
->arg
= end_of_object_name
+ strspn(end_of_object_name
, " \t");
2006 item
->arg_len
= (int)(eol
- item
->arg
);
2011 item
->commit
= lookup_commit_reference(&commit_oid
);
2012 return !item
->commit
;
2015 static int parse_insn_buffer(char *buf
, struct todo_list
*todo_list
)
2017 struct todo_item
*item
;
2018 char *p
= buf
, *next_p
;
2019 int i
, res
= 0, fixup_okay
= file_exists(rebase_path_done());
2021 for (i
= 1; *p
; i
++, p
= next_p
) {
2022 char *eol
= strchrnul(p
, '\n');
2024 next_p
= *eol
? eol
+ 1 /* skip LF */ : eol
;
2026 if (p
!= eol
&& eol
[-1] == '\r')
2027 eol
--; /* strip Carriage Return */
2029 item
= append_new_todo(todo_list
);
2030 item
->offset_in_buf
= p
- todo_list
->buf
.buf
;
2031 if (parse_insn_line(item
, p
, eol
)) {
2032 res
= error(_("invalid line %d: %.*s"),
2033 i
, (int)(eol
- p
), p
);
2034 item
->command
= TODO_NOOP
;
2039 else if (is_fixup(item
->command
))
2040 return error(_("cannot '%s' without a previous commit"),
2041 command_to_string(item
->command
));
2042 else if (!is_noop(item
->command
))
2049 static int count_commands(struct todo_list
*todo_list
)
2053 for (i
= 0; i
< todo_list
->nr
; i
++)
2054 if (todo_list
->items
[i
].command
!= TODO_COMMENT
)
2060 static int get_item_line_offset(struct todo_list
*todo_list
, int index
)
2062 return index
< todo_list
->nr
?
2063 todo_list
->items
[index
].offset_in_buf
: todo_list
->buf
.len
;
2066 static const char *get_item_line(struct todo_list
*todo_list
, int index
)
2068 return todo_list
->buf
.buf
+ get_item_line_offset(todo_list
, index
);
2071 static int get_item_line_length(struct todo_list
*todo_list
, int index
)
2073 return get_item_line_offset(todo_list
, index
+ 1)
2074 - get_item_line_offset(todo_list
, index
);
2077 static ssize_t
strbuf_read_file_or_whine(struct strbuf
*sb
, const char *path
)
2082 fd
= open(path
, O_RDONLY
);
2084 return error_errno(_("could not open '%s'"), path
);
2085 len
= strbuf_read(sb
, fd
, 0);
2088 return error(_("could not read '%s'."), path
);
2092 static int read_populate_todo(struct todo_list
*todo_list
,
2093 struct replay_opts
*opts
)
2096 const char *todo_file
= get_todo_path(opts
);
2099 strbuf_reset(&todo_list
->buf
);
2100 if (strbuf_read_file_or_whine(&todo_list
->buf
, todo_file
) < 0)
2103 res
= stat(todo_file
, &st
);
2105 return error(_("could not stat '%s'"), todo_file
);
2106 fill_stat_data(&todo_list
->stat
, &st
);
2108 res
= parse_insn_buffer(todo_list
->buf
.buf
, todo_list
);
2110 if (is_rebase_i(opts
))
2111 return error(_("please fix this using "
2112 "'git rebase --edit-todo'."));
2113 return error(_("unusable instruction sheet: '%s'"), todo_file
);
2116 if (!todo_list
->nr
&&
2117 (!is_rebase_i(opts
) || !file_exists(rebase_path_done())))
2118 return error(_("no commits parsed."));
2120 if (!is_rebase_i(opts
)) {
2121 enum todo_command valid
=
2122 opts
->action
== REPLAY_PICK
? TODO_PICK
: TODO_REVERT
;
2125 for (i
= 0; i
< todo_list
->nr
; i
++)
2126 if (valid
== todo_list
->items
[i
].command
)
2128 else if (valid
== TODO_PICK
)
2129 return error(_("cannot cherry-pick during a revert."));
2131 return error(_("cannot revert during a cherry-pick."));
2134 if (is_rebase_i(opts
)) {
2135 struct todo_list done
= TODO_LIST_INIT
;
2136 FILE *f
= fopen_or_warn(rebase_path_msgtotal(), "w");
2138 if (strbuf_read_file(&done
.buf
, rebase_path_done(), 0) > 0 &&
2139 !parse_insn_buffer(done
.buf
.buf
, &done
))
2140 todo_list
->done_nr
= count_commands(&done
);
2142 todo_list
->done_nr
= 0;
2144 todo_list
->total_nr
= todo_list
->done_nr
2145 + count_commands(todo_list
);
2146 todo_list_release(&done
);
2149 fprintf(f
, "%d\n", todo_list
->total_nr
);
2157 static int git_config_string_dup(char **dest
,
2158 const char *var
, const char *value
)
2161 return config_error_nonbool(var
);
2163 *dest
= xstrdup(value
);
2167 static int populate_opts_cb(const char *key
, const char *value
, void *data
)
2169 struct replay_opts
*opts
= data
;
2174 else if (!strcmp(key
, "options.no-commit"))
2175 opts
->no_commit
= git_config_bool_or_int(key
, value
, &error_flag
);
2176 else if (!strcmp(key
, "options.edit"))
2177 opts
->edit
= git_config_bool_or_int(key
, value
, &error_flag
);
2178 else if (!strcmp(key
, "options.signoff"))
2179 opts
->signoff
= git_config_bool_or_int(key
, value
, &error_flag
);
2180 else if (!strcmp(key
, "options.record-origin"))
2181 opts
->record_origin
= git_config_bool_or_int(key
, value
, &error_flag
);
2182 else if (!strcmp(key
, "options.allow-ff"))
2183 opts
->allow_ff
= git_config_bool_or_int(key
, value
, &error_flag
);
2184 else if (!strcmp(key
, "options.mainline"))
2185 opts
->mainline
= git_config_int(key
, value
);
2186 else if (!strcmp(key
, "options.strategy"))
2187 git_config_string_dup(&opts
->strategy
, key
, value
);
2188 else if (!strcmp(key
, "options.gpg-sign"))
2189 git_config_string_dup(&opts
->gpg_sign
, key
, value
);
2190 else if (!strcmp(key
, "options.strategy-option")) {
2191 ALLOC_GROW(opts
->xopts
, opts
->xopts_nr
+ 1, opts
->xopts_alloc
);
2192 opts
->xopts
[opts
->xopts_nr
++] = xstrdup(value
);
2193 } else if (!strcmp(key
, "options.allow-rerere-auto"))
2194 opts
->allow_rerere_auto
=
2195 git_config_bool_or_int(key
, value
, &error_flag
) ?
2196 RERERE_AUTOUPDATE
: RERERE_NOAUTOUPDATE
;
2198 return error(_("invalid key: %s"), key
);
2201 return error(_("invalid value for %s: %s"), key
, value
);
2206 static void read_strategy_opts(struct replay_opts
*opts
, struct strbuf
*buf
)
2211 if (!read_oneliner(buf
, rebase_path_strategy(), 0))
2213 opts
->strategy
= strbuf_detach(buf
, NULL
);
2214 if (!read_oneliner(buf
, rebase_path_strategy_opts(), 0))
2217 opts
->xopts_nr
= split_cmdline(buf
->buf
, (const char ***)&opts
->xopts
);
2218 for (i
= 0; i
< opts
->xopts_nr
; i
++) {
2219 const char *arg
= opts
->xopts
[i
];
2221 skip_prefix(arg
, "--", &arg
);
2222 opts
->xopts
[i
] = xstrdup(arg
);
2226 static int read_populate_opts(struct replay_opts
*opts
)
2228 if (is_rebase_i(opts
)) {
2229 struct strbuf buf
= STRBUF_INIT
;
2231 if (read_oneliner(&buf
, rebase_path_gpg_sign_opt(), 1)) {
2232 if (!starts_with(buf
.buf
, "-S"))
2235 free(opts
->gpg_sign
);
2236 opts
->gpg_sign
= xstrdup(buf
.buf
+ 2);
2241 if (read_oneliner(&buf
, rebase_path_allow_rerere_autoupdate(), 1)) {
2242 if (!strcmp(buf
.buf
, "--rerere-autoupdate"))
2243 opts
->allow_rerere_auto
= RERERE_AUTOUPDATE
;
2244 else if (!strcmp(buf
.buf
, "--no-rerere-autoupdate"))
2245 opts
->allow_rerere_auto
= RERERE_NOAUTOUPDATE
;
2249 if (file_exists(rebase_path_verbose()))
2252 if (file_exists(rebase_path_signoff())) {
2257 read_strategy_opts(opts
, &buf
);
2258 strbuf_release(&buf
);
2260 if (read_oneliner(&opts
->current_fixups
,
2261 rebase_path_current_fixups(), 1)) {
2262 const char *p
= opts
->current_fixups
.buf
;
2263 opts
->current_fixup_count
= 1;
2264 while ((p
= strchr(p
, '\n'))) {
2265 opts
->current_fixup_count
++;
2270 if (read_oneliner(&buf
, rebase_path_squash_onto(), 0)) {
2271 if (get_oid_hex(buf
.buf
, &opts
->squash_onto
) < 0)
2272 return error(_("unusable squash-onto"));
2273 opts
->have_squash_onto
= 1;
2279 if (!file_exists(git_path_opts_file()))
2282 * The function git_parse_source(), called from git_config_from_file(),
2283 * may die() in case of a syntactically incorrect file. We do not care
2284 * about this case, though, because we wrote that file ourselves, so we
2285 * are pretty certain that it is syntactically correct.
2287 if (git_config_from_file(populate_opts_cb
, git_path_opts_file(), opts
) < 0)
2288 return error(_("malformed options sheet: '%s'"),
2289 git_path_opts_file());
2293 static int walk_revs_populate_todo(struct todo_list
*todo_list
,
2294 struct replay_opts
*opts
)
2296 enum todo_command command
= opts
->action
== REPLAY_PICK
?
2297 TODO_PICK
: TODO_REVERT
;
2298 const char *command_string
= todo_command_info
[command
].str
;
2299 struct commit
*commit
;
2301 if (prepare_revs(opts
))
2304 while ((commit
= get_revision(opts
->revs
))) {
2305 struct todo_item
*item
= append_new_todo(todo_list
);
2306 const char *commit_buffer
= get_commit_buffer(commit
, NULL
);
2307 const char *subject
;
2310 item
->command
= command
;
2311 item
->commit
= commit
;
2314 item
->offset_in_buf
= todo_list
->buf
.len
;
2315 subject_len
= find_commit_subject(commit_buffer
, &subject
);
2316 strbuf_addf(&todo_list
->buf
, "%s %s %.*s\n", command_string
,
2317 short_commit_name(commit
), subject_len
, subject
);
2318 unuse_commit_buffer(commit
, commit_buffer
);
2323 static int create_seq_dir(void)
2325 if (file_exists(git_path_seq_dir())) {
2326 error(_("a cherry-pick or revert is already in progress"));
2327 advise(_("try \"git cherry-pick (--continue | --quit | --abort)\""));
2329 } else if (mkdir(git_path_seq_dir(), 0777) < 0)
2330 return error_errno(_("could not create sequencer directory '%s'"),
2331 git_path_seq_dir());
2335 static int save_head(const char *head
)
2337 struct lock_file head_lock
= LOCK_INIT
;
2338 struct strbuf buf
= STRBUF_INIT
;
2342 fd
= hold_lock_file_for_update(&head_lock
, git_path_head_file(), 0);
2344 return error_errno(_("could not lock HEAD"));
2345 strbuf_addf(&buf
, "%s\n", head
);
2346 written
= write_in_full(fd
, buf
.buf
, buf
.len
);
2347 strbuf_release(&buf
);
2349 error_errno(_("could not write to '%s'"), git_path_head_file());
2350 rollback_lock_file(&head_lock
);
2353 if (commit_lock_file(&head_lock
) < 0)
2354 return error(_("failed to finalize '%s'"), git_path_head_file());
2358 static int rollback_is_safe(void)
2360 struct strbuf sb
= STRBUF_INIT
;
2361 struct object_id expected_head
, actual_head
;
2363 if (strbuf_read_file(&sb
, git_path_abort_safety_file(), 0) >= 0) {
2365 if (get_oid_hex(sb
.buf
, &expected_head
)) {
2366 strbuf_release(&sb
);
2367 die(_("could not parse %s"), git_path_abort_safety_file());
2369 strbuf_release(&sb
);
2371 else if (errno
== ENOENT
)
2372 oidclr(&expected_head
);
2374 die_errno(_("could not read '%s'"), git_path_abort_safety_file());
2376 if (get_oid("HEAD", &actual_head
))
2377 oidclr(&actual_head
);
2379 return !oidcmp(&actual_head
, &expected_head
);
2382 static int reset_for_rollback(const struct object_id
*oid
)
2384 const char *argv
[4]; /* reset --merge <arg> + NULL */
2387 argv
[1] = "--merge";
2388 argv
[2] = oid_to_hex(oid
);
2390 return run_command_v_opt(argv
, RUN_GIT_CMD
);
2393 static int rollback_single_pick(void)
2395 struct object_id head_oid
;
2397 if (!file_exists(git_path_cherry_pick_head()) &&
2398 !file_exists(git_path_revert_head()))
2399 return error(_("no cherry-pick or revert in progress"));
2400 if (read_ref_full("HEAD", 0, &head_oid
, NULL
))
2401 return error(_("cannot resolve HEAD"));
2402 if (is_null_oid(&head_oid
))
2403 return error(_("cannot abort from a branch yet to be born"));
2404 return reset_for_rollback(&head_oid
);
2407 int sequencer_rollback(struct replay_opts
*opts
)
2410 struct object_id oid
;
2411 struct strbuf buf
= STRBUF_INIT
;
2414 f
= fopen(git_path_head_file(), "r");
2415 if (!f
&& errno
== ENOENT
) {
2417 * There is no multiple-cherry-pick in progress.
2418 * If CHERRY_PICK_HEAD or REVERT_HEAD indicates
2419 * a single-cherry-pick in progress, abort that.
2421 return rollback_single_pick();
2424 return error_errno(_("cannot open '%s'"), git_path_head_file());
2425 if (strbuf_getline_lf(&buf
, f
)) {
2426 error(_("cannot read '%s': %s"), git_path_head_file(),
2427 ferror(f
) ? strerror(errno
) : _("unexpected end of file"));
2432 if (parse_oid_hex(buf
.buf
, &oid
, &p
) || *p
!= '\0') {
2433 error(_("stored pre-cherry-pick HEAD file '%s' is corrupt"),
2434 git_path_head_file());
2437 if (is_null_oid(&oid
)) {
2438 error(_("cannot abort from a branch yet to be born"));
2442 if (!rollback_is_safe()) {
2443 /* Do not error, just do not rollback */
2444 warning(_("You seem to have moved HEAD. "
2445 "Not rewinding, check your HEAD!"));
2447 if (reset_for_rollback(&oid
))
2449 strbuf_release(&buf
);
2450 return sequencer_remove_state(opts
);
2452 strbuf_release(&buf
);
2456 static int save_todo(struct todo_list
*todo_list
, struct replay_opts
*opts
)
2458 struct lock_file todo_lock
= LOCK_INIT
;
2459 const char *todo_path
= get_todo_path(opts
);
2460 int next
= todo_list
->current
, offset
, fd
;
2463 * rebase -i writes "git-rebase-todo" without the currently executing
2464 * command, appending it to "done" instead.
2466 if (is_rebase_i(opts
))
2469 fd
= hold_lock_file_for_update(&todo_lock
, todo_path
, 0);
2471 return error_errno(_("could not lock '%s'"), todo_path
);
2472 offset
= get_item_line_offset(todo_list
, next
);
2473 if (write_in_full(fd
, todo_list
->buf
.buf
+ offset
,
2474 todo_list
->buf
.len
- offset
) < 0)
2475 return error_errno(_("could not write to '%s'"), todo_path
);
2476 if (commit_lock_file(&todo_lock
) < 0)
2477 return error(_("failed to finalize '%s'"), todo_path
);
2479 if (is_rebase_i(opts
) && next
> 0) {
2480 const char *done
= rebase_path_done();
2481 int fd
= open(done
, O_CREAT
| O_WRONLY
| O_APPEND
, 0666);
2486 if (write_in_full(fd
, get_item_line(todo_list
, next
- 1),
2487 get_item_line_length(todo_list
, next
- 1))
2489 ret
= error_errno(_("could not write to '%s'"), done
);
2491 ret
= error_errno(_("failed to finalize '%s'"), done
);
2497 static int save_opts(struct replay_opts
*opts
)
2499 const char *opts_file
= git_path_opts_file();
2502 if (opts
->no_commit
)
2503 res
|= git_config_set_in_file_gently(opts_file
, "options.no-commit", "true");
2505 res
|= git_config_set_in_file_gently(opts_file
, "options.edit", "true");
2507 res
|= git_config_set_in_file_gently(opts_file
, "options.signoff", "true");
2508 if (opts
->record_origin
)
2509 res
|= git_config_set_in_file_gently(opts_file
, "options.record-origin", "true");
2511 res
|= git_config_set_in_file_gently(opts_file
, "options.allow-ff", "true");
2512 if (opts
->mainline
) {
2513 struct strbuf buf
= STRBUF_INIT
;
2514 strbuf_addf(&buf
, "%d", opts
->mainline
);
2515 res
|= git_config_set_in_file_gently(opts_file
, "options.mainline", buf
.buf
);
2516 strbuf_release(&buf
);
2519 res
|= git_config_set_in_file_gently(opts_file
, "options.strategy", opts
->strategy
);
2521 res
|= git_config_set_in_file_gently(opts_file
, "options.gpg-sign", opts
->gpg_sign
);
2524 for (i
= 0; i
< opts
->xopts_nr
; i
++)
2525 res
|= git_config_set_multivar_in_file_gently(opts_file
,
2526 "options.strategy-option",
2527 opts
->xopts
[i
], "^$", 0);
2529 if (opts
->allow_rerere_auto
)
2530 res
|= git_config_set_in_file_gently(opts_file
, "options.allow-rerere-auto",
2531 opts
->allow_rerere_auto
== RERERE_AUTOUPDATE
?
2536 static int make_patch(struct commit
*commit
, struct replay_opts
*opts
)
2538 struct strbuf buf
= STRBUF_INIT
;
2539 struct rev_info log_tree_opt
;
2540 const char *subject
, *p
;
2543 p
= short_commit_name(commit
);
2544 if (write_message(p
, strlen(p
), rebase_path_stopped_sha(), 1) < 0)
2546 if (update_ref("rebase", "REBASE_HEAD", &commit
->object
.oid
,
2547 NULL
, REF_NO_DEREF
, UPDATE_REFS_MSG_ON_ERR
))
2548 res
|= error(_("could not update %s"), "REBASE_HEAD");
2550 strbuf_addf(&buf
, "%s/patch", get_dir(opts
));
2551 memset(&log_tree_opt
, 0, sizeof(log_tree_opt
));
2552 init_revisions(&log_tree_opt
, NULL
);
2553 log_tree_opt
.abbrev
= 0;
2554 log_tree_opt
.diff
= 1;
2555 log_tree_opt
.diffopt
.output_format
= DIFF_FORMAT_PATCH
;
2556 log_tree_opt
.disable_stdin
= 1;
2557 log_tree_opt
.no_commit_id
= 1;
2558 log_tree_opt
.diffopt
.file
= fopen(buf
.buf
, "w");
2559 log_tree_opt
.diffopt
.use_color
= GIT_COLOR_NEVER
;
2560 if (!log_tree_opt
.diffopt
.file
)
2561 res
|= error_errno(_("could not open '%s'"), buf
.buf
);
2563 res
|= log_tree_commit(&log_tree_opt
, commit
);
2564 fclose(log_tree_opt
.diffopt
.file
);
2568 strbuf_addf(&buf
, "%s/message", get_dir(opts
));
2569 if (!file_exists(buf
.buf
)) {
2570 const char *commit_buffer
= get_commit_buffer(commit
, NULL
);
2571 find_commit_subject(commit_buffer
, &subject
);
2572 res
|= write_message(subject
, strlen(subject
), buf
.buf
, 1);
2573 unuse_commit_buffer(commit
, commit_buffer
);
2575 strbuf_release(&buf
);
2580 static int intend_to_amend(void)
2582 struct object_id head
;
2585 if (get_oid("HEAD", &head
))
2586 return error(_("cannot read HEAD"));
2588 p
= oid_to_hex(&head
);
2589 return write_message(p
, strlen(p
), rebase_path_amend(), 1);
2592 static int error_with_patch(struct commit
*commit
,
2593 const char *subject
, int subject_len
,
2594 struct replay_opts
*opts
, int exit_code
, int to_amend
)
2596 if (make_patch(commit
, opts
))
2600 if (intend_to_amend())
2604 _("You can amend the commit now, with\n"
2606 " git commit --amend %s\n"
2608 "Once you are satisfied with your changes, run\n"
2610 " git rebase --continue\n"),
2611 gpg_sign_opt_quoted(opts
));
2612 } else if (exit_code
)
2613 fprintf_ln(stderr
, _("Could not apply %s... %.*s"),
2614 short_commit_name(commit
), subject_len
, subject
);
2619 static int error_failed_squash(struct commit
*commit
,
2620 struct replay_opts
*opts
, int subject_len
, const char *subject
)
2622 if (copy_file(rebase_path_message(), rebase_path_squash_msg(), 0666))
2623 return error(_("could not copy '%s' to '%s'"),
2624 rebase_path_squash_msg(), rebase_path_message());
2625 unlink(git_path_merge_msg());
2626 if (copy_file(git_path_merge_msg(), rebase_path_message(), 0666))
2627 return error(_("could not copy '%s' to '%s'"),
2628 rebase_path_message(), git_path_merge_msg());
2629 return error_with_patch(commit
, subject
, subject_len
, opts
, 1, 0);
2632 static int do_exec(const char *command_line
)
2634 struct argv_array child_env
= ARGV_ARRAY_INIT
;
2635 const char *child_argv
[] = { NULL
, NULL
};
2638 fprintf(stderr
, "Executing: %s\n", command_line
);
2639 child_argv
[0] = command_line
;
2640 argv_array_pushf(&child_env
, "GIT_DIR=%s", absolute_path(get_git_dir()));
2641 status
= run_command_v_opt_cd_env(child_argv
, RUN_USING_SHELL
, NULL
,
2644 /* force re-reading of the cache */
2645 if (discard_cache() < 0 || read_cache() < 0)
2646 return error(_("could not read index"));
2648 dirty
= require_clean_work_tree("rebase", NULL
, 1, 1);
2651 warning(_("execution failed: %s\n%s"
2652 "You can fix the problem, and then run\n"
2654 " git rebase --continue\n"
2657 dirty
? N_("and made changes to the index and/or the "
2658 "working tree\n") : "");
2660 /* command not found */
2663 warning(_("execution succeeded: %s\nbut "
2664 "left changes to the index and/or the working tree\n"
2665 "Commit or stash your changes, and then run\n"
2667 " git rebase --continue\n"
2668 "\n"), command_line
);
2672 argv_array_clear(&child_env
);
2677 static int safe_append(const char *filename
, const char *fmt
, ...)
2680 struct lock_file lock
= LOCK_INIT
;
2681 int fd
= hold_lock_file_for_update(&lock
, filename
,
2682 LOCK_REPORT_ON_ERROR
);
2683 struct strbuf buf
= STRBUF_INIT
;
2688 if (strbuf_read_file(&buf
, filename
, 0) < 0 && errno
!= ENOENT
) {
2689 error_errno(_("could not read '%s'"), filename
);
2690 rollback_lock_file(&lock
);
2693 strbuf_complete(&buf
, '\n');
2695 strbuf_vaddf(&buf
, fmt
, ap
);
2698 if (write_in_full(fd
, buf
.buf
, buf
.len
) < 0) {
2699 error_errno(_("could not write to '%s'"), filename
);
2700 strbuf_release(&buf
);
2701 rollback_lock_file(&lock
);
2704 if (commit_lock_file(&lock
) < 0) {
2705 strbuf_release(&buf
);
2706 rollback_lock_file(&lock
);
2707 return error(_("failed to finalize '%s'"), filename
);
2710 strbuf_release(&buf
);
2714 static int do_label(const char *name
, int len
)
2716 struct ref_store
*refs
= get_main_ref_store(the_repository
);
2717 struct ref_transaction
*transaction
;
2718 struct strbuf ref_name
= STRBUF_INIT
, err
= STRBUF_INIT
;
2719 struct strbuf msg
= STRBUF_INIT
;
2721 struct object_id head_oid
;
2723 if (len
== 1 && *name
== '#')
2724 return error(_("illegal label name: '%.*s'"), len
, name
);
2726 strbuf_addf(&ref_name
, "refs/rewritten/%.*s", len
, name
);
2727 strbuf_addf(&msg
, "rebase -i (label) '%.*s'", len
, name
);
2729 transaction
= ref_store_transaction_begin(refs
, &err
);
2731 error("%s", err
.buf
);
2733 } else if (get_oid("HEAD", &head_oid
)) {
2734 error(_("could not read HEAD"));
2736 } else if (ref_transaction_update(transaction
, ref_name
.buf
, &head_oid
,
2737 NULL
, 0, msg
.buf
, &err
) < 0 ||
2738 ref_transaction_commit(transaction
, &err
)) {
2739 error("%s", err
.buf
);
2742 ref_transaction_free(transaction
);
2743 strbuf_release(&err
);
2744 strbuf_release(&msg
);
2747 ret
= safe_append(rebase_path_refs_to_delete(),
2748 "%s\n", ref_name
.buf
);
2749 strbuf_release(&ref_name
);
2754 static const char *reflog_message(struct replay_opts
*opts
,
2755 const char *sub_action
, const char *fmt
, ...);
2757 static int do_reset(const char *name
, int len
, struct replay_opts
*opts
)
2759 struct strbuf ref_name
= STRBUF_INIT
;
2760 struct object_id oid
;
2761 struct lock_file lock
= LOCK_INIT
;
2762 struct tree_desc desc
;
2764 struct unpack_trees_options unpack_tree_opts
;
2767 if (hold_locked_index(&lock
, LOCK_REPORT_ON_ERROR
) < 0)
2770 if (len
== 10 && !strncmp("[new root]", name
, len
)) {
2771 if (!opts
->have_squash_onto
) {
2773 if (commit_tree("", 0, the_hash_algo
->empty_tree
,
2774 NULL
, &opts
->squash_onto
,
2776 return error(_("writing fake root commit"));
2777 opts
->have_squash_onto
= 1;
2778 hex
= oid_to_hex(&opts
->squash_onto
);
2779 if (write_message(hex
, strlen(hex
),
2780 rebase_path_squash_onto(), 0))
2781 return error(_("writing squash-onto"));
2783 oidcpy(&oid
, &opts
->squash_onto
);
2785 /* Determine the length of the label */
2786 for (i
= 0; i
< len
; i
++)
2787 if (isspace(name
[i
]))
2790 strbuf_addf(&ref_name
, "refs/rewritten/%.*s", len
, name
);
2791 if (get_oid(ref_name
.buf
, &oid
) &&
2792 get_oid(ref_name
.buf
+ strlen("refs/rewritten/"), &oid
)) {
2793 error(_("could not read '%s'"), ref_name
.buf
);
2794 rollback_lock_file(&lock
);
2795 strbuf_release(&ref_name
);
2800 memset(&unpack_tree_opts
, 0, sizeof(unpack_tree_opts
));
2801 setup_unpack_trees_porcelain(&unpack_tree_opts
, "reset");
2802 unpack_tree_opts
.head_idx
= 1;
2803 unpack_tree_opts
.src_index
= &the_index
;
2804 unpack_tree_opts
.dst_index
= &the_index
;
2805 unpack_tree_opts
.fn
= oneway_merge
;
2806 unpack_tree_opts
.merge
= 1;
2807 unpack_tree_opts
.update
= 1;
2809 if (read_cache_unmerged()) {
2810 rollback_lock_file(&lock
);
2811 strbuf_release(&ref_name
);
2812 return error_resolve_conflict(_(action_name(opts
)));
2815 if (!fill_tree_descriptor(&desc
, &oid
)) {
2816 error(_("failed to find tree of %s"), oid_to_hex(&oid
));
2817 rollback_lock_file(&lock
);
2818 free((void *)desc
.buffer
);
2819 strbuf_release(&ref_name
);
2823 if (unpack_trees(1, &desc
, &unpack_tree_opts
)) {
2824 rollback_lock_file(&lock
);
2825 free((void *)desc
.buffer
);
2826 strbuf_release(&ref_name
);
2830 tree
= parse_tree_indirect(&oid
);
2831 prime_cache_tree(&the_index
, tree
);
2833 if (write_locked_index(&the_index
, &lock
, COMMIT_LOCK
) < 0)
2834 ret
= error(_("could not write index"));
2835 free((void *)desc
.buffer
);
2838 ret
= update_ref(reflog_message(opts
, "reset", "'%.*s'",
2839 len
, name
), "HEAD", &oid
,
2840 NULL
, 0, UPDATE_REFS_MSG_ON_ERR
);
2842 strbuf_release(&ref_name
);
2846 static int do_merge(struct commit
*commit
, const char *arg
, int arg_len
,
2847 int flags
, struct replay_opts
*opts
)
2849 int run_commit_flags
= (flags
& TODO_EDIT_MERGE_MSG
) ?
2850 EDIT_MSG
| VERIFY_MSG
: 0;
2851 struct strbuf ref_name
= STRBUF_INIT
;
2852 struct commit
*head_commit
, *merge_commit
, *i
;
2853 struct commit_list
*bases
, *j
, *reversed
= NULL
;
2854 struct merge_options o
;
2855 int merge_arg_len
, oneline_offset
, can_fast_forward
, ret
;
2856 static struct lock_file lock
;
2859 if (hold_locked_index(&lock
, LOCK_REPORT_ON_ERROR
) < 0) {
2864 head_commit
= lookup_commit_reference_by_name("HEAD");
2866 ret
= error(_("cannot merge without a current revision"));
2870 oneline_offset
= arg_len
;
2871 merge_arg_len
= strcspn(arg
, " \t\n");
2872 p
= arg
+ merge_arg_len
;
2873 p
+= strspn(p
, " \t\n");
2874 if (*p
== '#' && (!p
[1] || isspace(p
[1]))) {
2875 p
+= 1 + strspn(p
+ 1, " \t\n");
2876 oneline_offset
= p
- arg
;
2877 } else if (p
- arg
< arg_len
)
2878 BUG("octopus merges are not supported yet: '%s'", p
);
2880 strbuf_addf(&ref_name
, "refs/rewritten/%.*s", merge_arg_len
, arg
);
2881 merge_commit
= lookup_commit_reference_by_name(ref_name
.buf
);
2882 if (!merge_commit
) {
2883 /* fall back to non-rewritten ref or commit */
2884 strbuf_splice(&ref_name
, 0, strlen("refs/rewritten/"), "", 0);
2885 merge_commit
= lookup_commit_reference_by_name(ref_name
.buf
);
2888 if (!merge_commit
) {
2889 ret
= error(_("could not resolve '%s'"), ref_name
.buf
);
2893 if (opts
->have_squash_onto
&&
2894 !oidcmp(&head_commit
->object
.oid
, &opts
->squash_onto
)) {
2896 * When the user tells us to "merge" something into a
2897 * "[new root]", let's simply fast-forward to the merge head.
2899 rollback_lock_file(&lock
);
2900 ret
= fast_forward_to(&merge_commit
->object
.oid
,
2901 &head_commit
->object
.oid
, 0, opts
);
2906 const char *message
= get_commit_buffer(commit
, NULL
);
2911 ret
= error(_("could not get commit message of '%s'"),
2912 oid_to_hex(&commit
->object
.oid
));
2915 write_author_script(message
);
2916 find_commit_subject(message
, &body
);
2918 ret
= write_message(body
, len
, git_path_merge_msg(), 0);
2919 unuse_commit_buffer(commit
, message
);
2921 error_errno(_("could not write '%s'"),
2922 git_path_merge_msg());
2926 struct strbuf buf
= STRBUF_INIT
;
2929 strbuf_addf(&buf
, "author %s", git_author_info(0));
2930 write_author_script(buf
.buf
);
2933 if (oneline_offset
< arg_len
) {
2934 p
= arg
+ oneline_offset
;
2935 len
= arg_len
- oneline_offset
;
2937 strbuf_addf(&buf
, "Merge branch '%.*s'",
2938 merge_arg_len
, arg
);
2943 ret
= write_message(p
, len
, git_path_merge_msg(), 0);
2944 strbuf_release(&buf
);
2946 error_errno(_("could not write '%s'"),
2947 git_path_merge_msg());
2953 * If HEAD is not identical to the first parent of the original merge
2954 * commit, we cannot fast-forward.
2956 can_fast_forward
= opts
->allow_ff
&& commit
&& commit
->parents
&&
2957 !oidcmp(&commit
->parents
->item
->object
.oid
,
2958 &head_commit
->object
.oid
);
2961 * If the merge head is different from the original one, we cannot
2964 if (can_fast_forward
) {
2965 struct commit_list
*second_parent
= commit
->parents
->next
;
2967 if (second_parent
&& !second_parent
->next
&&
2968 oidcmp(&merge_commit
->object
.oid
,
2969 &second_parent
->item
->object
.oid
))
2970 can_fast_forward
= 0;
2973 if (can_fast_forward
&& commit
->parents
->next
&&
2974 !commit
->parents
->next
->next
&&
2975 !oidcmp(&commit
->parents
->next
->item
->object
.oid
,
2976 &merge_commit
->object
.oid
)) {
2977 rollback_lock_file(&lock
);
2978 ret
= fast_forward_to(&commit
->object
.oid
,
2979 &head_commit
->object
.oid
, 0, opts
);
2983 write_message(oid_to_hex(&merge_commit
->object
.oid
), GIT_SHA1_HEXSZ
,
2984 git_path_merge_head(), 0);
2985 write_message("no-ff", 5, git_path_merge_mode(), 0);
2987 bases
= get_merge_bases(head_commit
, merge_commit
);
2988 if (bases
&& !oidcmp(&merge_commit
->object
.oid
,
2989 &bases
->item
->object
.oid
)) {
2991 /* skip merging an ancestor of HEAD */
2995 for (j
= bases
; j
; j
= j
->next
)
2996 commit_list_insert(j
->item
, &reversed
);
2997 free_commit_list(bases
);
3000 init_merge_options(&o
);
3002 o
.branch2
= ref_name
.buf
;
3003 o
.buffer_output
= 2;
3005 ret
= merge_recursive(&o
, head_commit
, merge_commit
, reversed
, &i
);
3007 fputs(o
.obuf
.buf
, stdout
);
3008 strbuf_release(&o
.obuf
);
3010 error(_("could not even attempt to merge '%.*s'"),
3011 merge_arg_len
, arg
);
3015 * The return value of merge_recursive() is 1 on clean, and 0 on
3018 * Let's reverse that, so that do_merge() returns 0 upon success and
3019 * 1 upon failed merge (keeping the return value -1 for the cases where
3020 * we will want to reschedule the `merge` command).
3024 if (active_cache_changed
&&
3025 write_locked_index(&the_index
, &lock
, COMMIT_LOCK
)) {
3026 ret
= error(_("merge: Unable to write new index file"));
3030 rollback_lock_file(&lock
);
3032 rerere(opts
->allow_rerere_auto
);
3035 * In case of problems, we now want to return a positive
3036 * value (a negative one would indicate that the `merge`
3037 * command needs to be rescheduled).
3039 ret
= !!run_git_commit(git_path_merge_msg(), opts
,
3043 strbuf_release(&ref_name
);
3044 rollback_lock_file(&lock
);
3048 static int is_final_fixup(struct todo_list
*todo_list
)
3050 int i
= todo_list
->current
;
3052 if (!is_fixup(todo_list
->items
[i
].command
))
3055 while (++i
< todo_list
->nr
)
3056 if (is_fixup(todo_list
->items
[i
].command
))
3058 else if (!is_noop(todo_list
->items
[i
].command
))
3063 static enum todo_command
peek_command(struct todo_list
*todo_list
, int offset
)
3067 for (i
= todo_list
->current
+ offset
; i
< todo_list
->nr
; i
++)
3068 if (!is_noop(todo_list
->items
[i
].command
))
3069 return todo_list
->items
[i
].command
;
3074 static int apply_autostash(struct replay_opts
*opts
)
3076 struct strbuf stash_sha1
= STRBUF_INIT
;
3077 struct child_process child
= CHILD_PROCESS_INIT
;
3080 if (!read_oneliner(&stash_sha1
, rebase_path_autostash(), 1)) {
3081 strbuf_release(&stash_sha1
);
3084 strbuf_trim(&stash_sha1
);
3087 child
.no_stdout
= 1;
3088 child
.no_stderr
= 1;
3089 argv_array_push(&child
.args
, "stash");
3090 argv_array_push(&child
.args
, "apply");
3091 argv_array_push(&child
.args
, stash_sha1
.buf
);
3092 if (!run_command(&child
))
3093 fprintf(stderr
, _("Applied autostash.\n"));
3095 struct child_process store
= CHILD_PROCESS_INIT
;
3098 argv_array_push(&store
.args
, "stash");
3099 argv_array_push(&store
.args
, "store");
3100 argv_array_push(&store
.args
, "-m");
3101 argv_array_push(&store
.args
, "autostash");
3102 argv_array_push(&store
.args
, "-q");
3103 argv_array_push(&store
.args
, stash_sha1
.buf
);
3104 if (run_command(&store
))
3105 ret
= error(_("cannot store %s"), stash_sha1
.buf
);
3108 _("Applying autostash resulted in conflicts.\n"
3109 "Your changes are safe in the stash.\n"
3110 "You can run \"git stash pop\" or"
3111 " \"git stash drop\" at any time.\n"));
3114 strbuf_release(&stash_sha1
);
3118 static const char *reflog_message(struct replay_opts
*opts
,
3119 const char *sub_action
, const char *fmt
, ...)
3122 static struct strbuf buf
= STRBUF_INIT
;
3126 strbuf_addstr(&buf
, action_name(opts
));
3128 strbuf_addf(&buf
, " (%s)", sub_action
);
3130 strbuf_addstr(&buf
, ": ");
3131 strbuf_vaddf(&buf
, fmt
, ap
);
3138 static const char rescheduled_advice
[] =
3139 N_("Could not execute the todo command\n"
3143 "It has been rescheduled; To edit the command before continuing, please\n"
3144 "edit the todo list first:\n"
3146 " git rebase --edit-todo\n"
3147 " git rebase --continue\n");
3149 static int pick_commits(struct todo_list
*todo_list
, struct replay_opts
*opts
)
3151 int res
= 0, reschedule
= 0;
3153 setenv(GIT_REFLOG_ACTION
, action_name(opts
), 0);
3155 assert(!(opts
->signoff
|| opts
->no_commit
||
3156 opts
->record_origin
|| opts
->edit
));
3157 if (read_and_refresh_cache(opts
))
3160 while (todo_list
->current
< todo_list
->nr
) {
3161 struct todo_item
*item
= todo_list
->items
+ todo_list
->current
;
3162 if (save_todo(todo_list
, opts
))
3164 if (is_rebase_i(opts
)) {
3165 if (item
->command
!= TODO_COMMENT
) {
3166 FILE *f
= fopen(rebase_path_msgnum(), "w");
3168 todo_list
->done_nr
++;
3171 fprintf(f
, "%d\n", todo_list
->done_nr
);
3174 fprintf(stderr
, "Rebasing (%d/%d)%s",
3176 todo_list
->total_nr
,
3177 opts
->verbose
? "\n" : "\r");
3179 unlink(rebase_path_message());
3180 unlink(rebase_path_author_script());
3181 unlink(rebase_path_stopped_sha());
3182 unlink(rebase_path_amend());
3183 delete_ref(NULL
, "REBASE_HEAD", NULL
, REF_NO_DEREF
);
3185 if (item
->command
<= TODO_SQUASH
) {
3186 if (is_rebase_i(opts
))
3187 setenv("GIT_REFLOG_ACTION", reflog_message(opts
,
3188 command_to_string(item
->command
), NULL
),
3190 res
= do_pick_commit(item
->command
, item
->commit
,
3191 opts
, is_final_fixup(todo_list
));
3192 if (is_rebase_i(opts
) && res
< 0) {
3194 advise(_(rescheduled_advice
),
3195 get_item_line_length(todo_list
,
3196 todo_list
->current
),
3197 get_item_line(todo_list
,
3198 todo_list
->current
));
3199 todo_list
->current
--;
3200 if (save_todo(todo_list
, opts
))
3203 if (item
->command
== TODO_EDIT
) {
3204 struct commit
*commit
= item
->commit
;
3207 _("Stopped at %s... %.*s\n"),
3208 short_commit_name(commit
),
3209 item
->arg_len
, item
->arg
);
3210 return error_with_patch(commit
,
3211 item
->arg
, item
->arg_len
, opts
, res
,
3214 if (is_rebase_i(opts
) && !res
)
3215 record_in_rewritten(&item
->commit
->object
.oid
,
3216 peek_command(todo_list
, 1));
3217 if (res
&& is_fixup(item
->command
)) {
3220 return error_failed_squash(item
->commit
, opts
,
3221 item
->arg_len
, item
->arg
);
3222 } else if (res
&& is_rebase_i(opts
) && item
->commit
)
3223 return res
| error_with_patch(item
->commit
,
3224 item
->arg
, item
->arg_len
, opts
, res
,
3225 item
->command
== TODO_REWORD
);
3226 } else if (item
->command
== TODO_EXEC
) {
3227 char *end_of_arg
= (char *)(item
->arg
+ item
->arg_len
);
3228 int saved
= *end_of_arg
;
3232 res
= do_exec(item
->arg
);
3233 *end_of_arg
= saved
;
3235 /* Reread the todo file if it has changed. */
3237 ; /* fall through */
3238 else if (stat(get_todo_path(opts
), &st
))
3239 res
= error_errno(_("could not stat '%s'"),
3240 get_todo_path(opts
));
3241 else if (match_stat_data(&todo_list
->stat
, &st
)) {
3242 todo_list_release(todo_list
);
3243 if (read_populate_todo(todo_list
, opts
))
3244 res
= -1; /* message was printed */
3245 /* `current` will be incremented below */
3246 todo_list
->current
= -1;
3248 } else if (item
->command
== TODO_LABEL
) {
3249 if ((res
= do_label(item
->arg
, item
->arg_len
)))
3251 } else if (item
->command
== TODO_RESET
) {
3252 if ((res
= do_reset(item
->arg
, item
->arg_len
, opts
)))
3254 } else if (item
->command
== TODO_MERGE
) {
3255 if ((res
= do_merge(item
->commit
,
3256 item
->arg
, item
->arg_len
,
3257 item
->flags
, opts
)) < 0)
3259 else if (item
->commit
)
3260 record_in_rewritten(&item
->commit
->object
.oid
,
3261 peek_command(todo_list
, 1));
3263 /* failed with merge conflicts */
3264 return error_with_patch(item
->commit
,
3266 item
->arg_len
, opts
,
3268 } else if (!is_noop(item
->command
))
3269 return error(_("unknown command %d"), item
->command
);
3272 advise(_(rescheduled_advice
),
3273 get_item_line_length(todo_list
,
3274 todo_list
->current
),
3275 get_item_line(todo_list
, todo_list
->current
));
3276 todo_list
->current
--;
3277 if (save_todo(todo_list
, opts
))
3280 return error_with_patch(item
->commit
,
3282 item
->arg_len
, opts
,
3286 todo_list
->current
++;
3291 if (is_rebase_i(opts
)) {
3292 struct strbuf head_ref
= STRBUF_INIT
, buf
= STRBUF_INIT
;
3295 /* Stopped in the middle, as planned? */
3296 if (todo_list
->current
< todo_list
->nr
)
3299 if (read_oneliner(&head_ref
, rebase_path_head_name(), 0) &&
3300 starts_with(head_ref
.buf
, "refs/")) {
3302 struct object_id head
, orig
;
3305 if (get_oid("HEAD", &head
)) {
3306 res
= error(_("cannot read HEAD"));
3308 strbuf_release(&head_ref
);
3309 strbuf_release(&buf
);
3312 if (!read_oneliner(&buf
, rebase_path_orig_head(), 0) ||
3313 get_oid_hex(buf
.buf
, &orig
)) {
3314 res
= error(_("could not read orig-head"));
3315 goto cleanup_head_ref
;
3318 if (!read_oneliner(&buf
, rebase_path_onto(), 0)) {
3319 res
= error(_("could not read 'onto'"));
3320 goto cleanup_head_ref
;
3322 msg
= reflog_message(opts
, "finish", "%s onto %s",
3323 head_ref
.buf
, buf
.buf
);
3324 if (update_ref(msg
, head_ref
.buf
, &head
, &orig
,
3325 REF_NO_DEREF
, UPDATE_REFS_MSG_ON_ERR
)) {
3326 res
= error(_("could not update %s"),
3328 goto cleanup_head_ref
;
3330 msg
= reflog_message(opts
, "finish", "returning to %s",
3332 if (create_symref("HEAD", head_ref
.buf
, msg
)) {
3333 res
= error(_("could not update HEAD to %s"),
3335 goto cleanup_head_ref
;
3340 if (opts
->verbose
) {
3341 struct rev_info log_tree_opt
;
3342 struct object_id orig
, head
;
3344 memset(&log_tree_opt
, 0, sizeof(log_tree_opt
));
3345 init_revisions(&log_tree_opt
, NULL
);
3346 log_tree_opt
.diff
= 1;
3347 log_tree_opt
.diffopt
.output_format
=
3348 DIFF_FORMAT_DIFFSTAT
;
3349 log_tree_opt
.disable_stdin
= 1;
3351 if (read_oneliner(&buf
, rebase_path_orig_head(), 0) &&
3352 !get_oid(buf
.buf
, &orig
) &&
3353 !get_oid("HEAD", &head
)) {
3354 diff_tree_oid(&orig
, &head
, "",
3355 &log_tree_opt
.diffopt
);
3356 log_tree_diff_flush(&log_tree_opt
);
3359 flush_rewritten_pending();
3360 if (!stat(rebase_path_rewritten_list(), &st
) &&
3362 struct child_process child
= CHILD_PROCESS_INIT
;
3363 const char *post_rewrite_hook
=
3364 find_hook("post-rewrite");
3366 child
.in
= open(rebase_path_rewritten_list(), O_RDONLY
);
3368 argv_array_push(&child
.args
, "notes");
3369 argv_array_push(&child
.args
, "copy");
3370 argv_array_push(&child
.args
, "--for-rewrite=rebase");
3371 /* we don't care if this copying failed */
3372 run_command(&child
);
3374 if (post_rewrite_hook
) {
3375 struct child_process hook
= CHILD_PROCESS_INIT
;
3377 hook
.in
= open(rebase_path_rewritten_list(),
3379 hook
.stdout_to_stderr
= 1;
3380 argv_array_push(&hook
.args
, post_rewrite_hook
);
3381 argv_array_push(&hook
.args
, "rebase");
3382 /* we don't care if this hook failed */
3386 apply_autostash(opts
);
3388 fprintf(stderr
, "Successfully rebased and updated %s.\n",
3391 strbuf_release(&buf
);
3392 strbuf_release(&head_ref
);
3396 * Sequence of picks finished successfully; cleanup by
3397 * removing the .git/sequencer directory
3399 return sequencer_remove_state(opts
);
3402 static int continue_single_pick(void)
3404 const char *argv
[] = { "commit", NULL
};
3406 if (!file_exists(git_path_cherry_pick_head()) &&
3407 !file_exists(git_path_revert_head()))
3408 return error(_("no cherry-pick or revert in progress"));
3409 return run_command_v_opt(argv
, RUN_GIT_CMD
);
3412 static int commit_staged_changes(struct replay_opts
*opts
,
3413 struct todo_list
*todo_list
)
3415 unsigned int flags
= ALLOW_EMPTY
| EDIT_MSG
;
3416 unsigned int final_fixup
= 0, is_clean
;
3418 if (has_unstaged_changes(1))
3419 return error(_("cannot rebase: You have unstaged changes."));
3421 is_clean
= !has_uncommitted_changes(0);
3423 if (file_exists(rebase_path_amend())) {
3424 struct strbuf rev
= STRBUF_INIT
;
3425 struct object_id head
, to_amend
;
3427 if (get_oid("HEAD", &head
))
3428 return error(_("cannot amend non-existing commit"));
3429 if (!read_oneliner(&rev
, rebase_path_amend(), 0))
3430 return error(_("invalid file: '%s'"), rebase_path_amend());
3431 if (get_oid_hex(rev
.buf
, &to_amend
))
3432 return error(_("invalid contents: '%s'"),
3433 rebase_path_amend());
3434 if (!is_clean
&& oidcmp(&head
, &to_amend
))
3435 return error(_("\nYou have uncommitted changes in your "
3436 "working tree. Please, commit them\n"
3437 "first and then run 'git rebase "
3438 "--continue' again."));
3440 * When skipping a failed fixup/squash, we need to edit the
3441 * commit message, the current fixup list and count, and if it
3442 * was the last fixup/squash in the chain, we need to clean up
3443 * the commit message and if there was a squash, let the user
3446 if (is_clean
&& !oidcmp(&head
, &to_amend
) &&
3447 opts
->current_fixup_count
> 0 &&
3448 file_exists(rebase_path_stopped_sha())) {
3449 const char *p
= opts
->current_fixups
.buf
;
3450 int len
= opts
->current_fixups
.len
;
3452 opts
->current_fixup_count
--;
3454 BUG("Incorrect current_fixups:\n%s", p
);
3455 while (len
&& p
[len
- 1] != '\n')
3457 strbuf_setlen(&opts
->current_fixups
, len
);
3458 if (write_message(p
, len
, rebase_path_current_fixups(),
3460 return error(_("could not write file: '%s'"),
3461 rebase_path_current_fixups());
3464 * If a fixup/squash in a fixup/squash chain failed, the
3465 * commit message is already correct, no need to commit
3468 * Only if it is the final command in the fixup/squash
3469 * chain, and only if the chain is longer than a single
3470 * fixup/squash command (which was just skipped), do we
3471 * actually need to re-commit with a cleaned up commit
3474 if (opts
->current_fixup_count
> 0 &&
3475 !is_fixup(peek_command(todo_list
, 0))) {
3478 * If there was not a single "squash" in the
3479 * chain, we only need to clean up the commit
3480 * message, no need to bother the user with
3481 * opening the commit message in the editor.
3483 if (!starts_with(p
, "squash ") &&
3484 !strstr(p
, "\nsquash "))
3485 flags
= (flags
& ~EDIT_MSG
) | CLEANUP_MSG
;
3486 } else if (is_fixup(peek_command(todo_list
, 0))) {
3488 * We need to update the squash message to skip
3489 * the latest commit message.
3491 struct commit
*commit
;
3492 const char *path
= rebase_path_squash_msg();
3494 if (parse_head(&commit
) ||
3495 !(p
= get_commit_buffer(commit
, NULL
)) ||
3496 write_message(p
, strlen(p
), path
, 0)) {
3497 unuse_commit_buffer(commit
, p
);
3498 return error(_("could not write file: "
3501 unuse_commit_buffer(commit
, p
);
3505 strbuf_release(&rev
);
3510 const char *cherry_pick_head
= git_path_cherry_pick_head();
3512 if (file_exists(cherry_pick_head
) && unlink(cherry_pick_head
))
3513 return error(_("could not remove CHERRY_PICK_HEAD"));
3518 if (run_git_commit(final_fixup
? NULL
: rebase_path_message(),
3520 return error(_("could not commit staged changes."));
3521 unlink(rebase_path_amend());
3523 unlink(rebase_path_fixup_msg());
3524 unlink(rebase_path_squash_msg());
3526 if (opts
->current_fixup_count
> 0) {
3528 * Whether final fixup or not, we just cleaned up the commit
3531 unlink(rebase_path_current_fixups());
3532 strbuf_reset(&opts
->current_fixups
);
3533 opts
->current_fixup_count
= 0;
3538 int sequencer_continue(struct replay_opts
*opts
)
3540 struct todo_list todo_list
= TODO_LIST_INIT
;
3543 if (read_and_refresh_cache(opts
))
3546 if (read_populate_opts(opts
))
3548 if (is_rebase_i(opts
)) {
3549 if ((res
= read_populate_todo(&todo_list
, opts
)))
3550 goto release_todo_list
;
3551 if (commit_staged_changes(opts
, &todo_list
))
3553 } else if (!file_exists(get_todo_path(opts
)))
3554 return continue_single_pick();
3555 else if ((res
= read_populate_todo(&todo_list
, opts
)))
3556 goto release_todo_list
;
3558 if (!is_rebase_i(opts
)) {
3559 /* Verify that the conflict has been resolved */
3560 if (file_exists(git_path_cherry_pick_head()) ||
3561 file_exists(git_path_revert_head())) {
3562 res
= continue_single_pick();
3564 goto release_todo_list
;
3566 if (index_differs_from("HEAD", NULL
, 0)) {
3567 res
= error_dirty_index(opts
);
3568 goto release_todo_list
;
3570 todo_list
.current
++;
3571 } else if (file_exists(rebase_path_stopped_sha())) {
3572 struct strbuf buf
= STRBUF_INIT
;
3573 struct object_id oid
;
3575 if (read_oneliner(&buf
, rebase_path_stopped_sha(), 1) &&
3576 !get_oid_committish(buf
.buf
, &oid
))
3577 record_in_rewritten(&oid
, peek_command(&todo_list
, 0));
3578 strbuf_release(&buf
);
3581 res
= pick_commits(&todo_list
, opts
);
3583 todo_list_release(&todo_list
);
3587 static int single_pick(struct commit
*cmit
, struct replay_opts
*opts
)
3589 setenv(GIT_REFLOG_ACTION
, action_name(opts
), 0);
3590 return do_pick_commit(opts
->action
== REPLAY_PICK
?
3591 TODO_PICK
: TODO_REVERT
, cmit
, opts
, 0);
3594 int sequencer_pick_revisions(struct replay_opts
*opts
)
3596 struct todo_list todo_list
= TODO_LIST_INIT
;
3597 struct object_id oid
;
3601 if (read_and_refresh_cache(opts
))
3604 for (i
= 0; i
< opts
->revs
->pending
.nr
; i
++) {
3605 struct object_id oid
;
3606 const char *name
= opts
->revs
->pending
.objects
[i
].name
;
3608 /* This happens when using --stdin. */
3612 if (!get_oid(name
, &oid
)) {
3613 if (!lookup_commit_reference_gently(&oid
, 1)) {
3614 enum object_type type
= oid_object_info(the_repository
,
3617 return error(_("%s: can't cherry-pick a %s"),
3618 name
, type_name(type
));
3621 return error(_("%s: bad revision"), name
);
3625 * If we were called as "git cherry-pick <commit>", just
3626 * cherry-pick/revert it, set CHERRY_PICK_HEAD /
3627 * REVERT_HEAD, and don't touch the sequencer state.
3628 * This means it is possible to cherry-pick in the middle
3629 * of a cherry-pick sequence.
3631 if (opts
->revs
->cmdline
.nr
== 1 &&
3632 opts
->revs
->cmdline
.rev
->whence
== REV_CMD_REV
&&
3633 opts
->revs
->no_walk
&&
3634 !opts
->revs
->cmdline
.rev
->flags
) {
3635 struct commit
*cmit
;
3636 if (prepare_revision_walk(opts
->revs
))
3637 return error(_("revision walk setup failed"));
3638 cmit
= get_revision(opts
->revs
);
3639 if (!cmit
|| get_revision(opts
->revs
))
3640 return error("BUG: expected exactly one commit from walk");
3641 return single_pick(cmit
, opts
);
3645 * Start a new cherry-pick/ revert sequence; but
3646 * first, make sure that an existing one isn't in
3650 if (walk_revs_populate_todo(&todo_list
, opts
) ||
3651 create_seq_dir() < 0)
3653 if (get_oid("HEAD", &oid
) && (opts
->action
== REPLAY_REVERT
))
3654 return error(_("can't revert as initial commit"));
3655 if (save_head(oid_to_hex(&oid
)))
3657 if (save_opts(opts
))
3659 update_abort_safety_file();
3660 res
= pick_commits(&todo_list
, opts
);
3661 todo_list_release(&todo_list
);
3665 void append_signoff(struct strbuf
*msgbuf
, int ignore_footer
, unsigned flag
)
3667 unsigned no_dup_sob
= flag
& APPEND_SIGNOFF_DEDUP
;
3668 struct strbuf sob
= STRBUF_INIT
;
3671 strbuf_addstr(&sob
, sign_off_header
);
3672 strbuf_addstr(&sob
, fmt_name(getenv("GIT_COMMITTER_NAME"),
3673 getenv("GIT_COMMITTER_EMAIL")));
3674 strbuf_addch(&sob
, '\n');
3677 strbuf_complete_line(msgbuf
);
3680 * If the whole message buffer is equal to the sob, pretend that we
3681 * found a conforming footer with a matching sob
3683 if (msgbuf
->len
- ignore_footer
== sob
.len
&&
3684 !strncmp(msgbuf
->buf
, sob
.buf
, sob
.len
))
3687 has_footer
= has_conforming_footer(msgbuf
, &sob
, ignore_footer
);
3690 const char *append_newlines
= NULL
;
3691 size_t len
= msgbuf
->len
- ignore_footer
;
3695 * The buffer is completely empty. Leave foom for
3696 * the title and body to be filled in by the user.
3698 append_newlines
= "\n\n";
3699 } else if (len
== 1) {
3701 * Buffer contains a single newline. Add another
3702 * so that we leave room for the title and body.
3704 append_newlines
= "\n";
3705 } else if (msgbuf
->buf
[len
- 2] != '\n') {
3707 * Buffer ends with a single newline. Add another
3708 * so that there is an empty line between the message
3711 append_newlines
= "\n";
3712 } /* else, the buffer already ends with two newlines. */
3714 if (append_newlines
)
3715 strbuf_splice(msgbuf
, msgbuf
->len
- ignore_footer
, 0,
3716 append_newlines
, strlen(append_newlines
));
3719 if (has_footer
!= 3 && (!no_dup_sob
|| has_footer
!= 2))
3720 strbuf_splice(msgbuf
, msgbuf
->len
- ignore_footer
, 0,
3723 strbuf_release(&sob
);
3726 struct labels_entry
{
3727 struct hashmap_entry entry
;
3728 char label
[FLEX_ARRAY
];
3731 static int labels_cmp(const void *fndata
, const struct labels_entry
*a
,
3732 const struct labels_entry
*b
, const void *key
)
3734 return key
? strcmp(a
->label
, key
) : strcmp(a
->label
, b
->label
);
3737 struct string_entry
{
3738 struct oidmap_entry entry
;
3739 char string
[FLEX_ARRAY
];
3742 struct label_state
{
3743 struct oidmap commit2label
;
3744 struct hashmap labels
;
3748 static const char *label_oid(struct object_id
*oid
, const char *label
,
3749 struct label_state
*state
)
3751 struct labels_entry
*labels_entry
;
3752 struct string_entry
*string_entry
;
3753 struct object_id dummy
;
3757 string_entry
= oidmap_get(&state
->commit2label
, oid
);
3759 return string_entry
->string
;
3762 * For "uninteresting" commits, i.e. commits that are not to be
3763 * rebased, and which can therefore not be labeled, we use a unique
3764 * abbreviation of the commit name. This is slightly more complicated
3765 * than calling find_unique_abbrev() because we also need to make
3766 * sure that the abbreviation does not conflict with any other
3769 * We disallow "interesting" commits to be labeled by a string that
3770 * is a valid full-length hash, to ensure that we always can find an
3771 * abbreviation for any uninteresting commit's names that does not
3772 * clash with any other label.
3777 strbuf_reset(&state
->buf
);
3778 strbuf_grow(&state
->buf
, GIT_SHA1_HEXSZ
);
3779 label
= p
= state
->buf
.buf
;
3781 find_unique_abbrev_r(p
, oid
, default_abbrev
);
3784 * We may need to extend the abbreviated hash so that there is
3785 * no conflicting label.
3787 if (hashmap_get_from_hash(&state
->labels
, strihash(p
), p
)) {
3788 size_t i
= strlen(p
) + 1;
3790 oid_to_hex_r(p
, oid
);
3791 for (; i
< GIT_SHA1_HEXSZ
; i
++) {
3794 if (!hashmap_get_from_hash(&state
->labels
,
3800 } else if (((len
= strlen(label
)) == the_hash_algo
->hexsz
&&
3801 !get_oid_hex(label
, &dummy
)) ||
3802 (len
== 1 && *label
== '#') ||
3803 hashmap_get_from_hash(&state
->labels
,
3804 strihash(label
), label
)) {
3806 * If the label already exists, or if the label is a valid full
3807 * OID, or the label is a '#' (which we use as a separator
3808 * between merge heads and oneline), we append a dash and a
3809 * number to make it unique.
3811 struct strbuf
*buf
= &state
->buf
;
3814 strbuf_add(buf
, label
, len
);
3816 for (i
= 2; ; i
++) {
3817 strbuf_setlen(buf
, len
);
3818 strbuf_addf(buf
, "-%d", i
);
3819 if (!hashmap_get_from_hash(&state
->labels
,
3828 FLEX_ALLOC_STR(labels_entry
, label
, label
);
3829 hashmap_entry_init(labels_entry
, strihash(label
));
3830 hashmap_add(&state
->labels
, labels_entry
);
3832 FLEX_ALLOC_STR(string_entry
, string
, label
);
3833 oidcpy(&string_entry
->entry
.oid
, oid
);
3834 oidmap_put(&state
->commit2label
, string_entry
);
3836 return string_entry
->string
;
3839 static int make_script_with_merges(struct pretty_print_context
*pp
,
3840 struct rev_info
*revs
, FILE *out
,
3843 int keep_empty
= flags
& TODO_LIST_KEEP_EMPTY
;
3844 int rebase_cousins
= flags
& TODO_LIST_REBASE_COUSINS
;
3845 struct strbuf buf
= STRBUF_INIT
, oneline
= STRBUF_INIT
;
3846 struct strbuf label
= STRBUF_INIT
;
3847 struct commit_list
*commits
= NULL
, **tail
= &commits
, *iter
;
3848 struct commit_list
*tips
= NULL
, **tips_tail
= &tips
;
3849 struct commit
*commit
;
3850 struct oidmap commit2todo
= OIDMAP_INIT
;
3851 struct string_entry
*entry
;
3852 struct oidset interesting
= OIDSET_INIT
, child_seen
= OIDSET_INIT
,
3853 shown
= OIDSET_INIT
;
3854 struct label_state state
= { OIDMAP_INIT
, { NULL
}, STRBUF_INIT
};
3856 int abbr
= flags
& TODO_LIST_ABBREVIATE_CMDS
;
3857 const char *cmd_pick
= abbr
? "p" : "pick",
3858 *cmd_label
= abbr
? "l" : "label",
3859 *cmd_reset
= abbr
? "t" : "reset",
3860 *cmd_merge
= abbr
? "m" : "merge";
3862 oidmap_init(&commit2todo
, 0);
3863 oidmap_init(&state
.commit2label
, 0);
3864 hashmap_init(&state
.labels
, (hashmap_cmp_fn
) labels_cmp
, NULL
, 0);
3865 strbuf_init(&state
.buf
, 32);
3867 if (revs
->cmdline
.nr
&& (revs
->cmdline
.rev
[0].flags
& BOTTOM
)) {
3868 struct object_id
*oid
= &revs
->cmdline
.rev
[0].item
->oid
;
3869 FLEX_ALLOC_STR(entry
, string
, "onto");
3870 oidcpy(&entry
->entry
.oid
, oid
);
3871 oidmap_put(&state
.commit2label
, entry
);
3876 * - get onelines for all commits
3877 * - gather all branch tips (i.e. 2nd or later parents of merges)
3878 * - label all branch tips
3880 while ((commit
= get_revision(revs
))) {
3881 struct commit_list
*to_merge
;
3883 const char *p1
, *p2
;
3884 struct object_id
*oid
;
3887 tail
= &commit_list_insert(commit
, tail
)->next
;
3888 oidset_insert(&interesting
, &commit
->object
.oid
);
3890 is_empty
= is_original_commit_empty(commit
);
3891 if (!is_empty
&& (commit
->object
.flags
& PATCHSAME
))
3894 strbuf_reset(&oneline
);
3895 pretty_print_commit(pp
, commit
, &oneline
);
3897 to_merge
= commit
->parents
? commit
->parents
->next
: NULL
;
3899 /* non-merge commit: easy case */
3901 if (!keep_empty
&& is_empty
)
3902 strbuf_addf(&buf
, "%c ", comment_line_char
);
3903 strbuf_addf(&buf
, "%s %s %s", cmd_pick
,
3904 oid_to_hex(&commit
->object
.oid
),
3907 FLEX_ALLOC_STR(entry
, string
, buf
.buf
);
3908 oidcpy(&entry
->entry
.oid
, &commit
->object
.oid
);
3909 oidmap_put(&commit2todo
, entry
);
3914 is_octopus
= to_merge
&& to_merge
->next
;
3917 BUG("Octopus merges not yet supported");
3919 /* Create a label */
3920 strbuf_reset(&label
);
3921 if (skip_prefix(oneline
.buf
, "Merge ", &p1
) &&
3922 (p1
= strchr(p1
, '\'')) &&
3923 (p2
= strchr(++p1
, '\'')))
3924 strbuf_add(&label
, p1
, p2
- p1
);
3925 else if (skip_prefix(oneline
.buf
, "Merge pull request ",
3927 (p1
= strstr(p1
, " from ")))
3928 strbuf_addstr(&label
, p1
+ strlen(" from "));
3930 strbuf_addbuf(&label
, &oneline
);
3932 for (p1
= label
.buf
; *p1
; p1
++)
3937 strbuf_addf(&buf
, "%s -C %s",
3938 cmd_merge
, oid_to_hex(&commit
->object
.oid
));
3940 /* label the tip of merged branch */
3941 oid
= &to_merge
->item
->object
.oid
;
3942 strbuf_addch(&buf
, ' ');
3944 if (!oidset_contains(&interesting
, oid
))
3945 strbuf_addstr(&buf
, label_oid(oid
, NULL
, &state
));
3947 tips_tail
= &commit_list_insert(to_merge
->item
,
3950 strbuf_addstr(&buf
, label_oid(oid
, label
.buf
, &state
));
3952 strbuf_addf(&buf
, " # %s", oneline
.buf
);
3954 FLEX_ALLOC_STR(entry
, string
, buf
.buf
);
3955 oidcpy(&entry
->entry
.oid
, &commit
->object
.oid
);
3956 oidmap_put(&commit2todo
, entry
);
3961 * - label branch points
3962 * - add HEAD to the branch tips
3964 for (iter
= commits
; iter
; iter
= iter
->next
) {
3965 struct commit_list
*parent
= iter
->item
->parents
;
3966 for (; parent
; parent
= parent
->next
) {
3967 struct object_id
*oid
= &parent
->item
->object
.oid
;
3968 if (!oidset_contains(&interesting
, oid
))
3970 if (!oidset_contains(&child_seen
, oid
))
3971 oidset_insert(&child_seen
, oid
);
3973 label_oid(oid
, "branch-point", &state
);
3976 /* Add HEAD as implict "tip of branch" */
3978 tips_tail
= &commit_list_insert(iter
->item
,
3983 * Third phase: output the todo list. This is a bit tricky, as we
3984 * want to avoid jumping back and forth between revisions. To
3985 * accomplish that goal, we walk backwards from the branch tips,
3986 * gathering commits not yet shown, reversing the list on the fly,
3987 * then outputting that list (labeling revisions as needed).
3989 fprintf(out
, "%s onto\n", cmd_label
);
3990 for (iter
= tips
; iter
; iter
= iter
->next
) {
3991 struct commit_list
*list
= NULL
, *iter2
;
3993 commit
= iter
->item
;
3994 if (oidset_contains(&shown
, &commit
->object
.oid
))
3996 entry
= oidmap_get(&state
.commit2label
, &commit
->object
.oid
);
3999 fprintf(out
, "\n# Branch %s\n", entry
->string
);
4003 while (oidset_contains(&interesting
, &commit
->object
.oid
) &&
4004 !oidset_contains(&shown
, &commit
->object
.oid
)) {
4005 commit_list_insert(commit
, &list
);
4006 if (!commit
->parents
) {
4010 commit
= commit
->parents
->item
;
4014 fprintf(out
, "%s %s\n", cmd_reset
,
4015 rebase_cousins
? "onto" : "[new root]");
4017 const char *to
= NULL
;
4019 entry
= oidmap_get(&state
.commit2label
,
4020 &commit
->object
.oid
);
4023 else if (!rebase_cousins
)
4024 to
= label_oid(&commit
->object
.oid
, NULL
,
4027 if (!to
|| !strcmp(to
, "onto"))
4028 fprintf(out
, "%s onto\n", cmd_reset
);
4030 strbuf_reset(&oneline
);
4031 pretty_print_commit(pp
, commit
, &oneline
);
4032 fprintf(out
, "%s %s # %s\n",
4033 cmd_reset
, to
, oneline
.buf
);
4037 for (iter2
= list
; iter2
; iter2
= iter2
->next
) {
4038 struct object_id
*oid
= &iter2
->item
->object
.oid
;
4039 entry
= oidmap_get(&commit2todo
, oid
);
4040 /* only show if not already upstream */
4042 fprintf(out
, "%s\n", entry
->string
);
4043 entry
= oidmap_get(&state
.commit2label
, oid
);
4045 fprintf(out
, "%s %s\n",
4046 cmd_label
, entry
->string
);
4047 oidset_insert(&shown
, oid
);
4050 free_commit_list(list
);
4053 free_commit_list(commits
);
4054 free_commit_list(tips
);
4056 strbuf_release(&label
);
4057 strbuf_release(&oneline
);
4058 strbuf_release(&buf
);
4060 oidmap_free(&commit2todo
, 1);
4061 oidmap_free(&state
.commit2label
, 1);
4062 hashmap_free(&state
.labels
, 1);
4063 strbuf_release(&state
.buf
);
4068 int sequencer_make_script(FILE *out
, int argc
, const char **argv
,
4071 char *format
= NULL
;
4072 struct pretty_print_context pp
= {0};
4073 struct strbuf buf
= STRBUF_INIT
;
4074 struct rev_info revs
;
4075 struct commit
*commit
;
4076 int keep_empty
= flags
& TODO_LIST_KEEP_EMPTY
;
4077 const char *insn
= flags
& TODO_LIST_ABBREVIATE_CMDS
? "p" : "pick";
4078 int rebase_merges
= flags
& TODO_LIST_REBASE_MERGES
;
4080 init_revisions(&revs
, NULL
);
4081 revs
.verbose_header
= 1;
4083 revs
.max_parents
= 1;
4084 revs
.cherry_mark
= 1;
4087 revs
.right_only
= 1;
4088 revs
.sort_order
= REV_SORT_IN_GRAPH_ORDER
;
4089 revs
.topo_order
= 1;
4091 revs
.pretty_given
= 1;
4092 git_config_get_string("rebase.instructionFormat", &format
);
4093 if (!format
|| !*format
) {
4095 format
= xstrdup("%s");
4097 get_commit_format(format
, &revs
);
4099 pp
.fmt
= revs
.commit_format
;
4100 pp
.output_encoding
= get_log_output_encoding();
4102 if (setup_revisions(argc
, argv
, &revs
, NULL
) > 1)
4103 return error(_("make_script: unhandled options"));
4105 if (prepare_revision_walk(&revs
) < 0)
4106 return error(_("make_script: error preparing revisions"));
4109 return make_script_with_merges(&pp
, &revs
, out
, flags
);
4111 while ((commit
= get_revision(&revs
))) {
4112 int is_empty
= is_original_commit_empty(commit
);
4114 if (!is_empty
&& (commit
->object
.flags
& PATCHSAME
))
4117 if (!keep_empty
&& is_empty
)
4118 strbuf_addf(&buf
, "%c ", comment_line_char
);
4119 strbuf_addf(&buf
, "%s %s ", insn
,
4120 oid_to_hex(&commit
->object
.oid
));
4121 pretty_print_commit(&pp
, commit
, &buf
);
4122 strbuf_addch(&buf
, '\n');
4123 fputs(buf
.buf
, out
);
4125 strbuf_release(&buf
);
4130 * Add commands after pick and (series of) squash/fixup commands
4133 int sequencer_add_exec_commands(const char *commands
)
4135 const char *todo_file
= rebase_path_todo();
4136 struct todo_list todo_list
= TODO_LIST_INIT
;
4137 struct todo_item
*item
;
4138 struct strbuf
*buf
= &todo_list
.buf
;
4139 size_t offset
= 0, commands_len
= strlen(commands
);
4142 if (strbuf_read_file(&todo_list
.buf
, todo_file
, 0) < 0)
4143 return error(_("could not read '%s'."), todo_file
);
4145 if (parse_insn_buffer(todo_list
.buf
.buf
, &todo_list
)) {
4146 todo_list_release(&todo_list
);
4147 return error(_("unusable todo list: '%s'"), todo_file
);
4151 /* insert <commands> before every pick except the first one */
4152 for (item
= todo_list
.items
, i
= 0; i
< todo_list
.nr
; i
++, item
++) {
4153 if (item
->command
== TODO_PICK
&& !first
) {
4154 strbuf_insert(buf
, item
->offset_in_buf
+ offset
,
4155 commands
, commands_len
);
4156 offset
+= commands_len
;
4161 /* append final <commands> */
4162 strbuf_add(buf
, commands
, commands_len
);
4164 i
= write_message(buf
->buf
, buf
->len
, todo_file
, 0);
4165 todo_list_release(&todo_list
);
4169 int transform_todos(unsigned flags
)
4171 const char *todo_file
= rebase_path_todo();
4172 struct todo_list todo_list
= TODO_LIST_INIT
;
4173 struct strbuf buf
= STRBUF_INIT
;
4174 struct todo_item
*item
;
4177 if (strbuf_read_file(&todo_list
.buf
, todo_file
, 0) < 0)
4178 return error(_("could not read '%s'."), todo_file
);
4180 if (parse_insn_buffer(todo_list
.buf
.buf
, &todo_list
)) {
4181 todo_list_release(&todo_list
);
4182 return error(_("unusable todo list: '%s'"), todo_file
);
4185 for (item
= todo_list
.items
, i
= 0; i
< todo_list
.nr
; i
++, item
++) {
4186 /* if the item is not a command write it and continue */
4187 if (item
->command
>= TODO_COMMENT
) {
4188 strbuf_addf(&buf
, "%.*s\n", item
->arg_len
, item
->arg
);
4192 /* add command to the buffer */
4193 if (flags
& TODO_LIST_ABBREVIATE_CMDS
)
4194 strbuf_addch(&buf
, command_to_char(item
->command
));
4196 strbuf_addstr(&buf
, command_to_string(item
->command
));
4200 const char *oid
= flags
& TODO_LIST_SHORTEN_IDS
?
4201 short_commit_name(item
->commit
) :
4202 oid_to_hex(&item
->commit
->object
.oid
);
4204 if (item
->command
== TODO_MERGE
) {
4205 if (item
->flags
& TODO_EDIT_MERGE_MSG
)
4206 strbuf_addstr(&buf
, " -c");
4208 strbuf_addstr(&buf
, " -C");
4211 strbuf_addf(&buf
, " %s", oid
);
4214 /* add all the rest */
4216 strbuf_addch(&buf
, '\n');
4218 strbuf_addf(&buf
, " %.*s\n", item
->arg_len
, item
->arg
);
4221 i
= write_message(buf
.buf
, buf
.len
, todo_file
, 0);
4222 todo_list_release(&todo_list
);
4227 CHECK_IGNORE
= 0, CHECK_WARN
, CHECK_ERROR
4230 static enum check_level
get_missing_commit_check_level(void)
4234 if (git_config_get_value("rebase.missingcommitscheck", &value
) ||
4235 !strcasecmp("ignore", value
))
4236 return CHECK_IGNORE
;
4237 if (!strcasecmp("warn", value
))
4239 if (!strcasecmp("error", value
))
4241 warning(_("unrecognized setting %s for option "
4242 "rebase.missingCommitsCheck. Ignoring."), value
);
4243 return CHECK_IGNORE
;
4246 define_commit_slab(commit_seen
, unsigned char);
4248 * Check if the user dropped some commits by mistake
4249 * Behaviour determined by rebase.missingCommitsCheck.
4250 * Check if there is an unrecognized command or a
4251 * bad SHA-1 in a command.
4253 int check_todo_list(void)
4255 enum check_level check_level
= get_missing_commit_check_level();
4256 struct strbuf todo_file
= STRBUF_INIT
;
4257 struct todo_list todo_list
= TODO_LIST_INIT
;
4258 struct strbuf missing
= STRBUF_INIT
;
4259 int advise_to_edit_todo
= 0, res
= 0, i
;
4260 struct commit_seen commit_seen
;
4262 init_commit_seen(&commit_seen
);
4264 strbuf_addstr(&todo_file
, rebase_path_todo());
4265 if (strbuf_read_file_or_whine(&todo_list
.buf
, todo_file
.buf
) < 0) {
4269 advise_to_edit_todo
= res
=
4270 parse_insn_buffer(todo_list
.buf
.buf
, &todo_list
);
4272 if (res
|| check_level
== CHECK_IGNORE
)
4275 /* Mark the commits in git-rebase-todo as seen */
4276 for (i
= 0; i
< todo_list
.nr
; i
++) {
4277 struct commit
*commit
= todo_list
.items
[i
].commit
;
4279 *commit_seen_at(&commit_seen
, commit
) = 1;
4282 todo_list_release(&todo_list
);
4283 strbuf_addstr(&todo_file
, ".backup");
4284 if (strbuf_read_file_or_whine(&todo_list
.buf
, todo_file
.buf
) < 0) {
4288 strbuf_release(&todo_file
);
4289 res
= !!parse_insn_buffer(todo_list
.buf
.buf
, &todo_list
);
4291 /* Find commits in git-rebase-todo.backup yet unseen */
4292 for (i
= todo_list
.nr
- 1; i
>= 0; i
--) {
4293 struct todo_item
*item
= todo_list
.items
+ i
;
4294 struct commit
*commit
= item
->commit
;
4295 if (commit
&& !*commit_seen_at(&commit_seen
, commit
)) {
4296 strbuf_addf(&missing
, " - %s %.*s\n",
4297 short_commit_name(commit
),
4298 item
->arg_len
, item
->arg
);
4299 *commit_seen_at(&commit_seen
, commit
) = 1;
4303 /* Warn about missing commits */
4307 if (check_level
== CHECK_ERROR
)
4308 advise_to_edit_todo
= res
= 1;
4311 _("Warning: some commits may have been dropped accidentally.\n"
4312 "Dropped commits (newer to older):\n"));
4314 /* Make the list user-friendly and display */
4315 fputs(missing
.buf
, stderr
);
4316 strbuf_release(&missing
);
4318 fprintf(stderr
, _("To avoid this message, use \"drop\" to "
4319 "explicitly remove a commit.\n\n"
4320 "Use 'git config rebase.missingCommitsCheck' to change "
4321 "the level of warnings.\n"
4322 "The possible behaviours are: ignore, warn, error.\n\n"));
4325 clear_commit_seen(&commit_seen
);
4326 strbuf_release(&todo_file
);
4327 todo_list_release(&todo_list
);
4329 if (advise_to_edit_todo
)
4331 _("You can fix this with 'git rebase --edit-todo' "
4332 "and then run 'git rebase --continue'.\n"
4333 "Or you can abort the rebase with 'git rebase"
4339 static int rewrite_file(const char *path
, const char *buf
, size_t len
)
4342 int fd
= open(path
, O_WRONLY
| O_TRUNC
);
4344 return error_errno(_("could not open '%s' for writing"), path
);
4345 if (write_in_full(fd
, buf
, len
) < 0)
4346 rc
= error_errno(_("could not write to '%s'"), path
);
4347 if (close(fd
) && !rc
)
4348 rc
= error_errno(_("could not close '%s'"), path
);
4352 /* skip picking commits whose parents are unchanged */
4353 int skip_unnecessary_picks(void)
4355 const char *todo_file
= rebase_path_todo();
4356 struct strbuf buf
= STRBUF_INIT
;
4357 struct todo_list todo_list
= TODO_LIST_INIT
;
4358 struct object_id onto_oid
, *oid
= &onto_oid
, *parent_oid
;
4361 if (!read_oneliner(&buf
, rebase_path_onto(), 0))
4362 return error(_("could not read 'onto'"));
4363 if (get_oid(buf
.buf
, &onto_oid
)) {
4364 strbuf_release(&buf
);
4365 return error(_("need a HEAD to fixup"));
4367 strbuf_release(&buf
);
4369 if (strbuf_read_file_or_whine(&todo_list
.buf
, todo_file
) < 0)
4371 if (parse_insn_buffer(todo_list
.buf
.buf
, &todo_list
) < 0) {
4372 todo_list_release(&todo_list
);
4376 for (i
= 0; i
< todo_list
.nr
; i
++) {
4377 struct todo_item
*item
= todo_list
.items
+ i
;
4379 if (item
->command
>= TODO_NOOP
)
4381 if (item
->command
!= TODO_PICK
)
4383 if (parse_commit(item
->commit
)) {
4384 todo_list_release(&todo_list
);
4385 return error(_("could not parse commit '%s'"),
4386 oid_to_hex(&item
->commit
->object
.oid
));
4388 if (!item
->commit
->parents
)
4389 break; /* root commit */
4390 if (item
->commit
->parents
->next
)
4391 break; /* merge commit */
4392 parent_oid
= &item
->commit
->parents
->item
->object
.oid
;
4393 if (hashcmp(parent_oid
->hash
, oid
->hash
))
4395 oid
= &item
->commit
->object
.oid
;
4398 int offset
= get_item_line_offset(&todo_list
, i
);
4399 const char *done_path
= rebase_path_done();
4401 fd
= open(done_path
, O_CREAT
| O_WRONLY
| O_APPEND
, 0666);
4403 error_errno(_("could not open '%s' for writing"),
4405 todo_list_release(&todo_list
);
4408 if (write_in_full(fd
, todo_list
.buf
.buf
, offset
) < 0) {
4409 error_errno(_("could not write to '%s'"), done_path
);
4410 todo_list_release(&todo_list
);
4416 if (rewrite_file(rebase_path_todo(), todo_list
.buf
.buf
+ offset
,
4417 todo_list
.buf
.len
- offset
) < 0) {
4418 todo_list_release(&todo_list
);
4422 todo_list
.current
= i
;
4423 if (is_fixup(peek_command(&todo_list
, 0)))
4424 record_in_rewritten(oid
, peek_command(&todo_list
, 0));
4427 todo_list_release(&todo_list
);
4428 printf("%s\n", oid_to_hex(oid
));
4433 struct subject2item_entry
{
4434 struct hashmap_entry entry
;
4436 char subject
[FLEX_ARRAY
];
4439 static int subject2item_cmp(const void *fndata
,
4440 const struct subject2item_entry
*a
,
4441 const struct subject2item_entry
*b
, const void *key
)
4443 return key
? strcmp(a
->subject
, key
) : strcmp(a
->subject
, b
->subject
);
4446 define_commit_slab(commit_todo_item
, struct todo_item
*);
4449 * Rearrange the todo list that has both "pick commit-id msg" and "pick
4450 * commit-id fixup!/squash! msg" in it so that the latter is put immediately
4451 * after the former, and change "pick" to "fixup"/"squash".
4453 * Note that if the config has specified a custom instruction format, each log
4454 * message will have to be retrieved from the commit (as the oneline in the
4455 * script cannot be trusted) in order to normalize the autosquash arrangement.
4457 int rearrange_squash(void)
4459 const char *todo_file
= rebase_path_todo();
4460 struct todo_list todo_list
= TODO_LIST_INIT
;
4461 struct hashmap subject2item
;
4462 int res
= 0, rearranged
= 0, *next
, *tail
, i
;
4464 struct commit_todo_item commit_todo
;
4466 if (strbuf_read_file_or_whine(&todo_list
.buf
, todo_file
) < 0)
4468 if (parse_insn_buffer(todo_list
.buf
.buf
, &todo_list
) < 0) {
4469 todo_list_release(&todo_list
);
4473 init_commit_todo_item(&commit_todo
);
4475 * The hashmap maps onelines to the respective todo list index.
4477 * If any items need to be rearranged, the next[i] value will indicate
4478 * which item was moved directly after the i'th.
4480 * In that case, last[i] will indicate the index of the latest item to
4481 * be moved to appear after the i'th.
4483 hashmap_init(&subject2item
, (hashmap_cmp_fn
) subject2item_cmp
,
4484 NULL
, todo_list
.nr
);
4485 ALLOC_ARRAY(next
, todo_list
.nr
);
4486 ALLOC_ARRAY(tail
, todo_list
.nr
);
4487 ALLOC_ARRAY(subjects
, todo_list
.nr
);
4488 for (i
= 0; i
< todo_list
.nr
; i
++) {
4489 struct strbuf buf
= STRBUF_INIT
;
4490 struct todo_item
*item
= todo_list
.items
+ i
;
4491 const char *commit_buffer
, *subject
, *p
;
4494 struct subject2item_entry
*entry
;
4496 next
[i
] = tail
[i
] = -1;
4497 if (!item
->commit
|| item
->command
== TODO_DROP
) {
4502 if (is_fixup(item
->command
)) {
4503 todo_list_release(&todo_list
);
4504 clear_commit_todo_item(&commit_todo
);
4505 return error(_("the script was already rearranged."));
4508 *commit_todo_item_at(&commit_todo
, item
->commit
) = item
;
4510 parse_commit(item
->commit
);
4511 commit_buffer
= get_commit_buffer(item
->commit
, NULL
);
4512 find_commit_subject(commit_buffer
, &subject
);
4513 format_subject(&buf
, subject
, " ");
4514 subject
= subjects
[i
] = strbuf_detach(&buf
, &subject_len
);
4515 unuse_commit_buffer(item
->commit
, commit_buffer
);
4516 if ((skip_prefix(subject
, "fixup! ", &p
) ||
4517 skip_prefix(subject
, "squash! ", &p
))) {
4518 struct commit
*commit2
;
4523 if (!skip_prefix(p
, "fixup! ", &p
) &&
4524 !skip_prefix(p
, "squash! ", &p
))
4528 if ((entry
= hashmap_get_from_hash(&subject2item
,
4530 /* found by title */
4532 else if (!strchr(p
, ' ') &&
4534 lookup_commit_reference_by_name(p
)) &&
4535 *commit_todo_item_at(&commit_todo
, commit2
))
4536 /* found by commit name */
4537 i2
= *commit_todo_item_at(&commit_todo
, commit2
)
4540 /* copy can be a prefix of the commit subject */
4541 for (i2
= 0; i2
< i
; i2
++)
4543 starts_with(subjects
[i2
], p
))
4551 todo_list
.items
[i
].command
=
4552 starts_with(subject
, "fixup!") ?
4553 TODO_FIXUP
: TODO_SQUASH
;
4559 } else if (!hashmap_get_from_hash(&subject2item
,
4560 strhash(subject
), subject
)) {
4561 FLEX_ALLOC_MEM(entry
, subject
, subject
, subject_len
);
4563 hashmap_entry_init(entry
, strhash(entry
->subject
));
4564 hashmap_put(&subject2item
, entry
);
4569 struct strbuf buf
= STRBUF_INIT
;
4571 for (i
= 0; i
< todo_list
.nr
; i
++) {
4572 enum todo_command command
= todo_list
.items
[i
].command
;
4576 * Initially, all commands are 'pick's. If it is a
4577 * fixup or a squash now, we have rearranged it.
4579 if (is_fixup(command
))
4584 get_item_line(&todo_list
, cur
);
4586 get_item_line(&todo_list
, cur
+ 1);
4588 /* replace 'pick', by 'fixup' or 'squash' */
4589 command
= todo_list
.items
[cur
].command
;
4590 if (is_fixup(command
)) {
4592 todo_command_info
[command
].str
);
4593 bol
+= strcspn(bol
, " \t");
4596 strbuf_add(&buf
, bol
, eol
- bol
);
4602 res
= rewrite_file(todo_file
, buf
.buf
, buf
.len
);
4603 strbuf_release(&buf
);
4608 for (i
= 0; i
< todo_list
.nr
; i
++)
4611 hashmap_free(&subject2item
, 1);
4612 todo_list_release(&todo_list
);
4614 clear_commit_todo_item(&commit_todo
);