5 #include "object-store.h"
10 #include "run-command.h"
14 #include "cache-tree.h"
18 #include "merge-ort.h"
19 #include "merge-ort-wrappers.h"
25 #include "wt-status.h"
27 #include "notes-utils.h"
29 #include "unpack-trees.h"
33 #include "commit-slab.h"
35 #include "commit-reach.h"
36 #include "rebase-interactive.h"
41 #define GIT_REFLOG_ACTION "GIT_REFLOG_ACTION"
43 static const char sign_off_header
[] = "Signed-off-by: ";
44 static const char cherry_picked_prefix
[] = "(cherry picked from commit ";
46 GIT_PATH_FUNC(git_path_commit_editmsg
, "COMMIT_EDITMSG")
48 static GIT_PATH_FUNC(git_path_seq_dir
, "sequencer")
50 static GIT_PATH_FUNC(git_path_todo_file
, "sequencer/todo")
51 static GIT_PATH_FUNC(git_path_opts_file
, "sequencer/opts")
52 static GIT_PATH_FUNC(git_path_head_file
, "sequencer/head")
53 static GIT_PATH_FUNC(git_path_abort_safety_file
, "sequencer/abort-safety")
55 static GIT_PATH_FUNC(rebase_path
, "rebase-merge")
57 * The file containing rebase commands, comments, and empty lines.
58 * This file is created by "git rebase -i" then edited by the user. As
59 * the lines are processed, they are removed from the front of this
60 * file and written to the tail of 'done'.
62 GIT_PATH_FUNC(rebase_path_todo
, "rebase-merge/git-rebase-todo")
63 GIT_PATH_FUNC(rebase_path_todo_backup
, "rebase-merge/git-rebase-todo.backup")
65 GIT_PATH_FUNC(rebase_path_dropped
, "rebase-merge/dropped")
68 * The rebase command lines that have already been processed. A line
69 * is moved here when it is first handled, before any associated user
72 static GIT_PATH_FUNC(rebase_path_done
, "rebase-merge/done")
74 * The file to keep track of how many commands were already processed (e.g.
77 static GIT_PATH_FUNC(rebase_path_msgnum
, "rebase-merge/msgnum")
79 * The file to keep track of how many commands are to be processed in total
80 * (e.g. for the prompt).
82 static GIT_PATH_FUNC(rebase_path_msgtotal
, "rebase-merge/end")
84 * The commit message that is planned to be used for any changes that
85 * need to be committed following a user interaction.
87 static GIT_PATH_FUNC(rebase_path_message
, "rebase-merge/message")
89 * The file into which is accumulated the suggested commit message for
90 * squash/fixup commands. When the first of a series of squash/fixups
91 * is seen, the file is created and the commit message from the
92 * previous commit and from the first squash/fixup commit are written
93 * to it. The commit message for each subsequent squash/fixup commit
94 * is appended to the file as it is processed.
96 static GIT_PATH_FUNC(rebase_path_squash_msg
, "rebase-merge/message-squash")
98 * If the current series of squash/fixups has not yet included a squash
99 * command, then this file exists and holds the commit message of the
100 * original "pick" commit. (If the series ends without a "squash"
101 * command, then this can be used as the commit message of the combined
102 * commit without opening the editor.)
104 static GIT_PATH_FUNC(rebase_path_fixup_msg
, "rebase-merge/message-fixup")
106 * This file contains the list fixup/squash commands that have been
107 * accumulated into message-fixup or message-squash so far.
109 static GIT_PATH_FUNC(rebase_path_current_fixups
, "rebase-merge/current-fixups")
111 * A script to set the GIT_AUTHOR_NAME, GIT_AUTHOR_EMAIL, and
112 * GIT_AUTHOR_DATE that will be used for the commit that is currently
115 static GIT_PATH_FUNC(rebase_path_author_script
, "rebase-merge/author-script")
117 * When an "edit" rebase command is being processed, the SHA1 of the
118 * commit to be edited is recorded in this file. When "git rebase
119 * --continue" is executed, if there are any staged changes then they
120 * will be amended to the HEAD commit, but only provided the HEAD
121 * commit is still the commit to be edited. When any other rebase
122 * command is processed, this file is deleted.
124 static GIT_PATH_FUNC(rebase_path_amend
, "rebase-merge/amend")
126 * When we stop at a given patch via the "edit" command, this file contains
127 * the commit object name of the corresponding patch.
129 static GIT_PATH_FUNC(rebase_path_stopped_sha
, "rebase-merge/stopped-sha")
131 * For the post-rewrite hook, we make a list of rewritten commits and
132 * their new sha1s. The rewritten-pending list keeps the sha1s of
133 * commits that have been processed, but not committed yet,
134 * e.g. because they are waiting for a 'squash' command.
136 static GIT_PATH_FUNC(rebase_path_rewritten_list
, "rebase-merge/rewritten-list")
137 static GIT_PATH_FUNC(rebase_path_rewritten_pending
,
138 "rebase-merge/rewritten-pending")
141 * The path of the file containing the OID of the "squash onto" commit, i.e.
142 * the dummy commit used for `reset [new root]`.
144 static GIT_PATH_FUNC(rebase_path_squash_onto
, "rebase-merge/squash-onto")
147 * The path of the file listing refs that need to be deleted after the rebase
148 * finishes. This is used by the `label` command to record the need for cleanup.
150 static GIT_PATH_FUNC(rebase_path_refs_to_delete
, "rebase-merge/refs-to-delete")
153 * The update-refs file stores a list of refs that will be updated at the end
154 * of the rebase sequence. The 'update-ref <ref>' commands in the todo file
155 * update the OIDs for the refs in this file, but the refs are not updated
156 * until the end of the rebase sequence.
158 * rebase_path_update_refs() returns the path to this file for a given
159 * worktree directory. For the current worktree, pass the_repository->gitdir.
161 static char *rebase_path_update_refs(const char *wt_git_dir
)
163 return xstrfmt("%s/rebase-merge/update-refs", wt_git_dir
);
167 * The following files are written by git-rebase just after parsing the
170 static GIT_PATH_FUNC(rebase_path_gpg_sign_opt
, "rebase-merge/gpg_sign_opt")
171 static GIT_PATH_FUNC(rebase_path_cdate_is_adate
, "rebase-merge/cdate_is_adate")
172 static GIT_PATH_FUNC(rebase_path_ignore_date
, "rebase-merge/ignore_date")
173 static GIT_PATH_FUNC(rebase_path_orig_head
, "rebase-merge/orig-head")
174 static GIT_PATH_FUNC(rebase_path_verbose
, "rebase-merge/verbose")
175 static GIT_PATH_FUNC(rebase_path_quiet
, "rebase-merge/quiet")
176 static GIT_PATH_FUNC(rebase_path_signoff
, "rebase-merge/signoff")
177 static GIT_PATH_FUNC(rebase_path_head_name
, "rebase-merge/head-name")
178 static GIT_PATH_FUNC(rebase_path_onto
, "rebase-merge/onto")
179 static GIT_PATH_FUNC(rebase_path_autostash
, "rebase-merge/autostash")
180 static GIT_PATH_FUNC(rebase_path_strategy
, "rebase-merge/strategy")
181 static GIT_PATH_FUNC(rebase_path_strategy_opts
, "rebase-merge/strategy_opts")
182 static GIT_PATH_FUNC(rebase_path_allow_rerere_autoupdate
, "rebase-merge/allow_rerere_autoupdate")
183 static GIT_PATH_FUNC(rebase_path_reschedule_failed_exec
, "rebase-merge/reschedule-failed-exec")
184 static GIT_PATH_FUNC(rebase_path_no_reschedule_failed_exec
, "rebase-merge/no-reschedule-failed-exec")
185 static GIT_PATH_FUNC(rebase_path_drop_redundant_commits
, "rebase-merge/drop_redundant_commits")
186 static GIT_PATH_FUNC(rebase_path_keep_redundant_commits
, "rebase-merge/keep_redundant_commits")
189 * A 'struct update_refs_record' represents a value in the update-refs
190 * list. We use a string_list to map refs to these (before, after) pairs.
192 struct update_ref_record
{
193 struct object_id before
;
194 struct object_id after
;
197 static struct update_ref_record
*init_update_ref_record(const char *ref
)
199 struct update_ref_record
*rec
;
201 CALLOC_ARRAY(rec
, 1);
203 oidcpy(&rec
->before
, null_oid());
204 oidcpy(&rec
->after
, null_oid());
206 /* This may fail, but that's fine, we will keep the null OID. */
207 read_ref(ref
, &rec
->before
);
212 static int git_sequencer_config(const char *k
, const char *v
, void *cb
)
214 struct replay_opts
*opts
= cb
;
217 if (!strcmp(k
, "commit.cleanup")) {
220 status
= git_config_string(&s
, k
, v
);
224 if (!strcmp(s
, "verbatim")) {
225 opts
->default_msg_cleanup
= COMMIT_MSG_CLEANUP_NONE
;
226 opts
->explicit_cleanup
= 1;
227 } else if (!strcmp(s
, "whitespace")) {
228 opts
->default_msg_cleanup
= COMMIT_MSG_CLEANUP_SPACE
;
229 opts
->explicit_cleanup
= 1;
230 } else if (!strcmp(s
, "strip")) {
231 opts
->default_msg_cleanup
= COMMIT_MSG_CLEANUP_ALL
;
232 opts
->explicit_cleanup
= 1;
233 } else if (!strcmp(s
, "scissors")) {
234 opts
->default_msg_cleanup
= COMMIT_MSG_CLEANUP_SCISSORS
;
235 opts
->explicit_cleanup
= 1;
237 warning(_("invalid commit message cleanup mode '%s'"),
245 if (!strcmp(k
, "commit.gpgsign")) {
246 opts
->gpg_sign
= git_config_bool(k
, v
) ? xstrdup("") : NULL
;
250 if (!opts
->default_strategy
&& !strcmp(k
, "pull.twohead")) {
251 int ret
= git_config_string((const char**)&opts
->default_strategy
, k
, v
);
254 * pull.twohead is allowed to be multi-valued; we only
255 * care about the first value.
257 char *tmp
= strchr(opts
->default_strategy
, ' ');
264 if (opts
->action
== REPLAY_REVERT
&& !strcmp(k
, "revert.reference"))
265 opts
->commit_use_reference
= git_config_bool(k
, v
);
267 status
= git_gpg_config(k
, v
, NULL
);
271 return git_diff_basic_config(k
, v
, NULL
);
274 void sequencer_init_config(struct replay_opts
*opts
)
276 opts
->default_msg_cleanup
= COMMIT_MSG_CLEANUP_NONE
;
277 git_config(git_sequencer_config
, opts
);
280 static inline int is_rebase_i(const struct replay_opts
*opts
)
282 return opts
->action
== REPLAY_INTERACTIVE_REBASE
;
285 static const char *get_dir(const struct replay_opts
*opts
)
287 if (is_rebase_i(opts
))
288 return rebase_path();
289 return git_path_seq_dir();
292 static const char *get_todo_path(const struct replay_opts
*opts
)
294 if (is_rebase_i(opts
))
295 return rebase_path_todo();
296 return git_path_todo_file();
300 * Returns 0 for non-conforming footer
301 * Returns 1 for conforming footer
302 * Returns 2 when sob exists within conforming footer
303 * Returns 3 when sob exists within conforming footer as last entry
305 static int has_conforming_footer(struct strbuf
*sb
, struct strbuf
*sob
,
306 size_t ignore_footer
)
308 struct process_trailer_options opts
= PROCESS_TRAILER_OPTIONS_INIT
;
309 struct trailer_info info
;
311 int found_sob
= 0, found_sob_last
= 0;
317 saved_char
= sb
->buf
[sb
->len
- ignore_footer
];
318 sb
->buf
[sb
->len
- ignore_footer
] = '\0';
321 trailer_info_get(&info
, sb
->buf
, &opts
);
324 sb
->buf
[sb
->len
- ignore_footer
] = saved_char
;
326 if (info
.trailer_start
== info
.trailer_end
)
329 for (i
= 0; i
< info
.trailer_nr
; i
++)
330 if (sob
&& !strncmp(info
.trailers
[i
], sob
->buf
, sob
->len
)) {
332 if (i
== info
.trailer_nr
- 1)
336 trailer_info_release(&info
);
345 static const char *gpg_sign_opt_quoted(struct replay_opts
*opts
)
347 static struct strbuf buf
= STRBUF_INIT
;
351 sq_quotef(&buf
, "-S%s", opts
->gpg_sign
);
355 int sequencer_remove_state(struct replay_opts
*opts
)
357 struct strbuf buf
= STRBUF_INIT
;
360 if (is_rebase_i(opts
) &&
361 strbuf_read_file(&buf
, rebase_path_refs_to_delete(), 0) > 0) {
364 char *eol
= strchr(p
, '\n');
367 if (delete_ref("(rebase) cleanup", p
, NULL
, 0) < 0) {
368 warning(_("could not delete '%s'"), p
);
377 free(opts
->gpg_sign
);
378 free(opts
->default_strategy
);
379 free(opts
->strategy
);
380 for (i
= 0; i
< opts
->xopts_nr
; i
++)
381 free(opts
->xopts
[i
]);
383 strbuf_release(&opts
->current_fixups
);
386 strbuf_addstr(&buf
, get_dir(opts
));
387 if (remove_dir_recursively(&buf
, 0))
388 ret
= error(_("could not remove '%s'"), buf
.buf
);
389 strbuf_release(&buf
);
394 static const char *action_name(const struct replay_opts
*opts
)
396 switch (opts
->action
) {
400 return N_("cherry-pick");
401 case REPLAY_INTERACTIVE_REBASE
:
404 die(_("unknown action: %d"), opts
->action
);
407 struct commit_message
{
414 static const char *short_commit_name(struct commit
*commit
)
416 return find_unique_abbrev(&commit
->object
.oid
, DEFAULT_ABBREV
);
419 static int get_message(struct commit
*commit
, struct commit_message
*out
)
421 const char *abbrev
, *subject
;
424 out
->message
= logmsg_reencode(commit
, NULL
, get_commit_output_encoding());
425 abbrev
= short_commit_name(commit
);
427 subject_len
= find_commit_subject(out
->message
, &subject
);
429 out
->subject
= xmemdupz(subject
, subject_len
);
430 out
->label
= xstrfmt("%s (%s)", abbrev
, out
->subject
);
431 out
->parent_label
= xstrfmt("parent of %s", out
->label
);
436 static void free_message(struct commit
*commit
, struct commit_message
*msg
)
438 free(msg
->parent_label
);
441 unuse_commit_buffer(commit
, msg
->message
);
444 static void print_advice(struct repository
*r
, int show_hint
,
445 struct replay_opts
*opts
)
447 char *msg
= getenv("GIT_CHERRY_PICK_HELP");
452 * A conflict has occurred but the porcelain
453 * (typically rebase --interactive) wants to take care
454 * of the commit itself so remove CHERRY_PICK_HEAD
456 refs_delete_ref(get_main_ref_store(r
), "", "CHERRY_PICK_HEAD",
463 advise(_("after resolving the conflicts, mark the corrected paths\n"
464 "with 'git add <paths>' or 'git rm <paths>'"));
465 else if (opts
->action
== REPLAY_PICK
)
466 advise(_("After resolving the conflicts, mark them with\n"
467 "\"git add/rm <pathspec>\", then run\n"
468 "\"git cherry-pick --continue\".\n"
469 "You can instead skip this commit with \"git cherry-pick --skip\".\n"
470 "To abort and get back to the state before \"git cherry-pick\",\n"
471 "run \"git cherry-pick --abort\"."));
472 else if (opts
->action
== REPLAY_REVERT
)
473 advise(_("After resolving the conflicts, mark them with\n"
474 "\"git add/rm <pathspec>\", then run\n"
475 "\"git revert --continue\".\n"
476 "You can instead skip this commit with \"git revert --skip\".\n"
477 "To abort and get back to the state before \"git revert\",\n"
478 "run \"git revert --abort\"."));
480 BUG("unexpected pick action in print_advice()");
484 static int write_message(const void *buf
, size_t len
, const char *filename
,
487 struct lock_file msg_file
= LOCK_INIT
;
489 int msg_fd
= hold_lock_file_for_update(&msg_file
, filename
, 0);
491 return error_errno(_("could not lock '%s'"), filename
);
492 if (write_in_full(msg_fd
, buf
, len
) < 0) {
493 error_errno(_("could not write to '%s'"), filename
);
494 rollback_lock_file(&msg_file
);
497 if (append_eol
&& write(msg_fd
, "\n", 1) < 0) {
498 error_errno(_("could not write eol to '%s'"), filename
);
499 rollback_lock_file(&msg_file
);
502 if (commit_lock_file(&msg_file
) < 0)
503 return error(_("failed to finalize '%s'"), filename
);
508 int read_oneliner(struct strbuf
*buf
,
509 const char *path
, unsigned flags
)
511 int orig_len
= buf
->len
;
513 if (strbuf_read_file(buf
, path
, 0) < 0) {
514 if ((flags
& READ_ONELINER_WARN_MISSING
) ||
515 (errno
!= ENOENT
&& errno
!= ENOTDIR
))
516 warning_errno(_("could not read '%s'"), path
);
520 if (buf
->len
> orig_len
&& buf
->buf
[buf
->len
- 1] == '\n') {
521 if (--buf
->len
> orig_len
&& buf
->buf
[buf
->len
- 1] == '\r')
523 buf
->buf
[buf
->len
] = '\0';
526 if ((flags
& READ_ONELINER_SKIP_IF_EMPTY
) && buf
->len
== orig_len
)
532 static struct tree
*empty_tree(struct repository
*r
)
534 return lookup_tree(r
, the_hash_algo
->empty_tree
);
537 static int error_dirty_index(struct repository
*repo
, struct replay_opts
*opts
)
539 if (repo_read_index_unmerged(repo
))
540 return error_resolve_conflict(action_name(opts
));
542 error(_("your local changes would be overwritten by %s."),
543 _(action_name(opts
)));
545 if (advice_enabled(ADVICE_COMMIT_BEFORE_MERGE
))
546 advise(_("commit your changes or stash them to proceed."));
550 static void update_abort_safety_file(void)
552 struct object_id head
;
554 /* Do nothing on a single-pick */
555 if (!file_exists(git_path_seq_dir()))
558 if (!get_oid("HEAD", &head
))
559 write_file(git_path_abort_safety_file(), "%s", oid_to_hex(&head
));
561 write_file(git_path_abort_safety_file(), "%s", "");
564 static int fast_forward_to(struct repository
*r
,
565 const struct object_id
*to
,
566 const struct object_id
*from
,
568 struct replay_opts
*opts
)
570 struct ref_transaction
*transaction
;
571 struct strbuf sb
= STRBUF_INIT
;
572 struct strbuf err
= STRBUF_INIT
;
575 if (checkout_fast_forward(r
, from
, to
, 1))
576 return -1; /* the callee should have complained already */
578 strbuf_addf(&sb
, "%s: fast-forward", action_name(opts
));
580 transaction
= ref_transaction_begin(&err
);
582 ref_transaction_update(transaction
, "HEAD",
583 to
, unborn
&& !is_rebase_i(opts
) ?
586 ref_transaction_commit(transaction
, &err
)) {
587 ref_transaction_free(transaction
);
588 error("%s", err
.buf
);
590 strbuf_release(&err
);
595 strbuf_release(&err
);
596 ref_transaction_free(transaction
);
597 update_abort_safety_file();
601 enum commit_msg_cleanup_mode
get_cleanup_mode(const char *cleanup_arg
,
604 if (!cleanup_arg
|| !strcmp(cleanup_arg
, "default"))
605 return use_editor
? COMMIT_MSG_CLEANUP_ALL
:
606 COMMIT_MSG_CLEANUP_SPACE
;
607 else if (!strcmp(cleanup_arg
, "verbatim"))
608 return COMMIT_MSG_CLEANUP_NONE
;
609 else if (!strcmp(cleanup_arg
, "whitespace"))
610 return COMMIT_MSG_CLEANUP_SPACE
;
611 else if (!strcmp(cleanup_arg
, "strip"))
612 return COMMIT_MSG_CLEANUP_ALL
;
613 else if (!strcmp(cleanup_arg
, "scissors"))
614 return use_editor
? COMMIT_MSG_CLEANUP_SCISSORS
:
615 COMMIT_MSG_CLEANUP_SPACE
;
617 die(_("Invalid cleanup mode %s"), cleanup_arg
);
621 * NB using int rather than enum cleanup_mode to stop clang's
622 * -Wtautological-constant-out-of-range-compare complaining that the comparison
625 static const char *describe_cleanup_mode(int cleanup_mode
)
627 static const char *modes
[] = { "whitespace",
632 if (cleanup_mode
< ARRAY_SIZE(modes
))
633 return modes
[cleanup_mode
];
635 BUG("invalid cleanup_mode provided (%d)", cleanup_mode
);
638 void append_conflicts_hint(struct index_state
*istate
,
639 struct strbuf
*msgbuf
, enum commit_msg_cleanup_mode cleanup_mode
)
643 if (cleanup_mode
== COMMIT_MSG_CLEANUP_SCISSORS
) {
644 strbuf_addch(msgbuf
, '\n');
645 wt_status_append_cut_line(msgbuf
);
646 strbuf_addch(msgbuf
, comment_line_char
);
649 strbuf_addch(msgbuf
, '\n');
650 strbuf_commented_addf(msgbuf
, "Conflicts:\n");
651 for (i
= 0; i
< istate
->cache_nr
;) {
652 const struct cache_entry
*ce
= istate
->cache
[i
++];
654 strbuf_commented_addf(msgbuf
, "\t%s\n", ce
->name
);
655 while (i
< istate
->cache_nr
&&
656 !strcmp(ce
->name
, istate
->cache
[i
]->name
))
662 static int do_recursive_merge(struct repository
*r
,
663 struct commit
*base
, struct commit
*next
,
664 const char *base_label
, const char *next_label
,
665 struct object_id
*head
, struct strbuf
*msgbuf
,
666 struct replay_opts
*opts
)
668 struct merge_options o
;
669 struct merge_result result
;
670 struct tree
*next_tree
, *base_tree
, *head_tree
;
671 int clean
, show_output
;
673 struct lock_file index_lock
= LOCK_INIT
;
675 if (repo_hold_locked_index(r
, &index_lock
, LOCK_REPORT_ON_ERROR
) < 0)
680 init_merge_options(&o
, r
);
681 o
.ancestor
= base
? base_label
: "(empty tree)";
683 o
.branch2
= next
? next_label
: "(empty tree)";
684 if (is_rebase_i(opts
))
686 o
.show_rename_progress
= 1;
688 head_tree
= parse_tree_indirect(head
);
689 next_tree
= next
? get_commit_tree(next
) : empty_tree(r
);
690 base_tree
= base
? get_commit_tree(base
) : empty_tree(r
);
692 for (i
= 0; i
< opts
->xopts_nr
; i
++)
693 parse_merge_opt(&o
, opts
->xopts
[i
]);
695 if (!opts
->strategy
|| !strcmp(opts
->strategy
, "ort")) {
696 memset(&result
, 0, sizeof(result
));
697 merge_incore_nonrecursive(&o
, base_tree
, head_tree
, next_tree
,
699 show_output
= !is_rebase_i(opts
) || !result
.clean
;
701 * TODO: merge_switch_to_result will update index/working tree;
702 * we only really want to do that if !result.clean || this is
703 * the final patch to be picked. But determining this is the
704 * final patch would take some work, and "head_tree" would need
705 * to be replace with the tree the index matched before we
706 * started doing any picks.
708 merge_switch_to_result(&o
, head_tree
, &result
, 1, show_output
);
709 clean
= result
.clean
;
711 ensure_full_index(r
->index
);
712 clean
= merge_trees(&o
, head_tree
, next_tree
, base_tree
);
713 if (is_rebase_i(opts
) && clean
<= 0)
714 fputs(o
.obuf
.buf
, stdout
);
715 strbuf_release(&o
.obuf
);
718 rollback_lock_file(&index_lock
);
722 if (write_locked_index(r
->index
, &index_lock
,
723 COMMIT_LOCK
| SKIP_IF_UNCHANGED
))
725 * TRANSLATORS: %s will be "revert", "cherry-pick" or
728 return error(_("%s: Unable to write new index file"),
729 _(action_name(opts
)));
732 append_conflicts_hint(r
->index
, msgbuf
,
733 opts
->default_msg_cleanup
);
738 static struct object_id
*get_cache_tree_oid(struct index_state
*istate
)
740 if (!cache_tree_fully_valid(istate
->cache_tree
))
741 if (cache_tree_update(istate
, 0)) {
742 error(_("unable to update cache tree"));
746 return &istate
->cache_tree
->oid
;
749 static int is_index_unchanged(struct repository
*r
)
751 struct object_id head_oid
, *cache_tree_oid
;
752 struct commit
*head_commit
;
753 struct index_state
*istate
= r
->index
;
755 if (!resolve_ref_unsafe("HEAD", RESOLVE_REF_READING
, &head_oid
, NULL
))
756 return error(_("could not resolve HEAD commit"));
758 head_commit
= lookup_commit(r
, &head_oid
);
761 * If head_commit is NULL, check_commit, called from
762 * lookup_commit, would have indicated that head_commit is not
763 * a commit object already. parse_commit() will return failure
764 * without further complaints in such a case. Otherwise, if
765 * the commit is invalid, parse_commit() will complain. So
766 * there is nothing for us to say here. Just return failure.
768 if (parse_commit(head_commit
))
771 if (!(cache_tree_oid
= get_cache_tree_oid(istate
)))
774 return oideq(cache_tree_oid
, get_commit_tree_oid(head_commit
));
777 static int write_author_script(const char *message
)
779 struct strbuf buf
= STRBUF_INIT
;
784 if (!*message
|| starts_with(message
, "\n")) {
786 /* Missing 'author' line? */
787 unlink(rebase_path_author_script());
789 } else if (skip_prefix(message
, "author ", &message
))
791 else if ((eol
= strchr(message
, '\n')))
796 strbuf_addstr(&buf
, "GIT_AUTHOR_NAME='");
797 while (*message
&& *message
!= '\n' && *message
!= '\r')
798 if (skip_prefix(message
, " <", &message
))
800 else if (*message
!= '\'')
801 strbuf_addch(&buf
, *(message
++));
803 strbuf_addf(&buf
, "'\\%c'", *(message
++));
804 strbuf_addstr(&buf
, "'\nGIT_AUTHOR_EMAIL='");
805 while (*message
&& *message
!= '\n' && *message
!= '\r')
806 if (skip_prefix(message
, "> ", &message
))
808 else if (*message
!= '\'')
809 strbuf_addch(&buf
, *(message
++));
811 strbuf_addf(&buf
, "'\\%c'", *(message
++));
812 strbuf_addstr(&buf
, "'\nGIT_AUTHOR_DATE='@");
813 while (*message
&& *message
!= '\n' && *message
!= '\r')
814 if (*message
!= '\'')
815 strbuf_addch(&buf
, *(message
++));
817 strbuf_addf(&buf
, "'\\%c'", *(message
++));
818 strbuf_addch(&buf
, '\'');
819 res
= write_message(buf
.buf
, buf
.len
, rebase_path_author_script(), 1);
820 strbuf_release(&buf
);
825 * Take a series of KEY='VALUE' lines where VALUE part is
826 * sq-quoted, and append <KEY, VALUE> at the end of the string list
828 static int parse_key_value_squoted(char *buf
, struct string_list
*list
)
831 struct string_list_item
*item
;
833 char *cp
= strchr(buf
, '=');
835 np
= strchrnul(buf
, '\n');
836 return error(_("no key present in '%.*s'"),
837 (int) (np
- buf
), buf
);
839 np
= strchrnul(cp
, '\n');
841 item
= string_list_append(list
, buf
);
843 buf
= np
+ (*np
== '\n');
847 return error(_("unable to dequote value of '%s'"),
849 item
->util
= xstrdup(cp
);
855 * Reads and parses the state directory's "author-script" file, and sets name,
856 * email and date accordingly.
857 * Returns 0 on success, -1 if the file could not be parsed.
859 * The author script is of the format:
861 * GIT_AUTHOR_NAME='$author_name'
862 * GIT_AUTHOR_EMAIL='$author_email'
863 * GIT_AUTHOR_DATE='$author_date'
865 * where $author_name, $author_email and $author_date are quoted. We are strict
866 * with our parsing, as the file was meant to be eval'd in the now-removed
867 * git-am.sh/git-rebase--interactive.sh scripts, and thus if the file differs
868 * from what this function expects, it is better to bail out than to do
869 * something that the user does not expect.
871 int read_author_script(const char *path
, char **name
, char **email
, char **date
,
874 struct strbuf buf
= STRBUF_INIT
;
875 struct string_list kv
= STRING_LIST_INIT_DUP
;
876 int retval
= -1; /* assume failure */
877 int i
, name_i
= -2, email_i
= -2, date_i
= -2, err
= 0;
879 if (strbuf_read_file(&buf
, path
, 256) <= 0) {
880 strbuf_release(&buf
);
881 if (errno
== ENOENT
&& allow_missing
)
884 return error_errno(_("could not open '%s' for reading"),
888 if (parse_key_value_squoted(buf
.buf
, &kv
))
891 for (i
= 0; i
< kv
.nr
; i
++) {
892 if (!strcmp(kv
.items
[i
].string
, "GIT_AUTHOR_NAME")) {
894 name_i
= error(_("'GIT_AUTHOR_NAME' already given"));
897 } else if (!strcmp(kv
.items
[i
].string
, "GIT_AUTHOR_EMAIL")) {
899 email_i
= error(_("'GIT_AUTHOR_EMAIL' already given"));
902 } else if (!strcmp(kv
.items
[i
].string
, "GIT_AUTHOR_DATE")) {
904 date_i
= error(_("'GIT_AUTHOR_DATE' already given"));
908 err
= error(_("unknown variable '%s'"),
913 error(_("missing 'GIT_AUTHOR_NAME'"));
915 error(_("missing 'GIT_AUTHOR_EMAIL'"));
917 error(_("missing 'GIT_AUTHOR_DATE'"));
918 if (name_i
< 0 || email_i
< 0 || date_i
< 0 || err
)
920 *name
= kv
.items
[name_i
].util
;
921 *email
= kv
.items
[email_i
].util
;
922 *date
= kv
.items
[date_i
].util
;
925 string_list_clear(&kv
, !!retval
);
926 strbuf_release(&buf
);
931 * Read a GIT_AUTHOR_NAME, GIT_AUTHOR_EMAIL AND GIT_AUTHOR_DATE from a
932 * file with shell quoting into struct strvec. Returns -1 on
933 * error, 0 otherwise.
935 static int read_env_script(struct strvec
*env
)
937 char *name
, *email
, *date
;
939 if (read_author_script(rebase_path_author_script(),
940 &name
, &email
, &date
, 0))
943 strvec_pushf(env
, "GIT_AUTHOR_NAME=%s", name
);
944 strvec_pushf(env
, "GIT_AUTHOR_EMAIL=%s", email
);
945 strvec_pushf(env
, "GIT_AUTHOR_DATE=%s", date
);
953 static char *get_author(const char *message
)
958 a
= find_commit_header(message
, "author", &len
);
960 return xmemdupz(a
, len
);
965 static const char *author_date_from_env(const struct strvec
*env
)
970 for (i
= 0; i
< env
->nr
; i
++)
971 if (skip_prefix(env
->v
[i
],
972 "GIT_AUTHOR_DATE=", &date
))
975 * If GIT_AUTHOR_DATE is missing we should have already errored out when
978 BUG("GIT_AUTHOR_DATE missing from author script");
981 static const char staged_changes_advice
[] =
982 N_("you have staged changes in your working tree\n"
983 "If these changes are meant to be squashed into the previous commit, run:\n"
985 " git commit --amend %s\n"
987 "If they are meant to go into a new commit, run:\n"
991 "In both cases, once you're done, continue with:\n"
993 " git rebase --continue\n");
995 #define ALLOW_EMPTY (1<<0)
996 #define EDIT_MSG (1<<1)
997 #define AMEND_MSG (1<<2)
998 #define CLEANUP_MSG (1<<3)
999 #define VERIFY_MSG (1<<4)
1000 #define CREATE_ROOT_COMMIT (1<<5)
1001 #define VERBATIM_MSG (1<<6)
1003 static int run_command_silent_on_success(struct child_process
*cmd
)
1005 struct strbuf buf
= STRBUF_INIT
;
1008 cmd
->stdout_to_stderr
= 1;
1009 rc
= pipe_command(cmd
,
1015 fputs(buf
.buf
, stderr
);
1016 strbuf_release(&buf
);
1021 * If we are cherry-pick, and if the merge did not result in
1022 * hand-editing, we will hit this commit and inherit the original
1023 * author date and name.
1025 * If we are revert, or if our cherry-pick results in a hand merge,
1026 * we had better say that the current user is responsible for that.
1028 * An exception is when run_git_commit() is called during an
1029 * interactive rebase: in that case, we will want to retain the
1032 static int run_git_commit(const char *defmsg
,
1033 struct replay_opts
*opts
,
1036 struct child_process cmd
= CHILD_PROCESS_INIT
;
1038 if ((flags
& CLEANUP_MSG
) && (flags
& VERBATIM_MSG
))
1039 BUG("CLEANUP_MSG and VERBATIM_MSG are mutually exclusive");
1043 if (is_rebase_i(opts
) &&
1044 ((opts
->committer_date_is_author_date
&& !opts
->ignore_date
) ||
1045 !(!defmsg
&& (flags
& AMEND_MSG
))) &&
1046 read_env_script(&cmd
.env
)) {
1047 const char *gpg_opt
= gpg_sign_opt_quoted(opts
);
1049 return error(_(staged_changes_advice
),
1053 if (opts
->committer_date_is_author_date
)
1054 strvec_pushf(&cmd
.env
, "GIT_COMMITTER_DATE=%s",
1057 author_date_from_env(&cmd
.env
));
1058 if (opts
->ignore_date
)
1059 strvec_push(&cmd
.env
, "GIT_AUTHOR_DATE=");
1061 strvec_push(&cmd
.args
, "commit");
1063 if (!(flags
& VERIFY_MSG
))
1064 strvec_push(&cmd
.args
, "-n");
1065 if ((flags
& AMEND_MSG
))
1066 strvec_push(&cmd
.args
, "--amend");
1068 strvec_pushf(&cmd
.args
, "-S%s", opts
->gpg_sign
);
1070 strvec_push(&cmd
.args
, "--no-gpg-sign");
1072 strvec_pushl(&cmd
.args
, "-F", defmsg
, NULL
);
1073 else if (!(flags
& EDIT_MSG
))
1074 strvec_pushl(&cmd
.args
, "-C", "HEAD", NULL
);
1075 if ((flags
& CLEANUP_MSG
))
1076 strvec_push(&cmd
.args
, "--cleanup=strip");
1077 if ((flags
& VERBATIM_MSG
))
1078 strvec_push(&cmd
.args
, "--cleanup=verbatim");
1079 if ((flags
& EDIT_MSG
))
1080 strvec_push(&cmd
.args
, "-e");
1081 else if (!(flags
& CLEANUP_MSG
) &&
1082 !opts
->signoff
&& !opts
->record_origin
&&
1083 !opts
->explicit_cleanup
)
1084 strvec_push(&cmd
.args
, "--cleanup=verbatim");
1086 if ((flags
& ALLOW_EMPTY
))
1087 strvec_push(&cmd
.args
, "--allow-empty");
1089 if (!(flags
& EDIT_MSG
))
1090 strvec_push(&cmd
.args
, "--allow-empty-message");
1092 if (is_rebase_i(opts
) && !(flags
& EDIT_MSG
))
1093 return run_command_silent_on_success(&cmd
);
1095 return run_command(&cmd
);
1098 static int rest_is_empty(const struct strbuf
*sb
, int start
)
1103 /* Check if the rest is just whitespace and Signed-off-by's. */
1104 for (i
= start
; i
< sb
->len
; i
++) {
1105 nl
= memchr(sb
->buf
+ i
, '\n', sb
->len
- i
);
1111 if (strlen(sign_off_header
) <= eol
- i
&&
1112 starts_with(sb
->buf
+ i
, sign_off_header
)) {
1117 if (!isspace(sb
->buf
[i
++]))
1124 void cleanup_message(struct strbuf
*msgbuf
,
1125 enum commit_msg_cleanup_mode cleanup_mode
, int verbose
)
1127 if (verbose
|| /* Truncate the message just before the diff, if any. */
1128 cleanup_mode
== COMMIT_MSG_CLEANUP_SCISSORS
)
1129 strbuf_setlen(msgbuf
, wt_status_locate_end(msgbuf
->buf
, msgbuf
->len
));
1130 if (cleanup_mode
!= COMMIT_MSG_CLEANUP_NONE
)
1131 strbuf_stripspace(msgbuf
, cleanup_mode
== COMMIT_MSG_CLEANUP_ALL
);
1135 * Find out if the message in the strbuf contains only whitespace and
1136 * Signed-off-by lines.
1138 int message_is_empty(const struct strbuf
*sb
,
1139 enum commit_msg_cleanup_mode cleanup_mode
)
1141 if (cleanup_mode
== COMMIT_MSG_CLEANUP_NONE
&& sb
->len
)
1143 return rest_is_empty(sb
, 0);
1147 * See if the user edited the message in the editor or left what
1148 * was in the template intact
1150 int template_untouched(const struct strbuf
*sb
, const char *template_file
,
1151 enum commit_msg_cleanup_mode cleanup_mode
)
1153 struct strbuf tmpl
= STRBUF_INIT
;
1156 if (cleanup_mode
== COMMIT_MSG_CLEANUP_NONE
&& sb
->len
)
1159 if (!template_file
|| strbuf_read_file(&tmpl
, template_file
, 0) <= 0)
1162 strbuf_stripspace(&tmpl
, cleanup_mode
== COMMIT_MSG_CLEANUP_ALL
);
1163 if (!skip_prefix(sb
->buf
, tmpl
.buf
, &start
))
1165 strbuf_release(&tmpl
);
1166 return rest_is_empty(sb
, start
- sb
->buf
);
1169 int update_head_with_reflog(const struct commit
*old_head
,
1170 const struct object_id
*new_head
,
1171 const char *action
, const struct strbuf
*msg
,
1174 struct ref_transaction
*transaction
;
1175 struct strbuf sb
= STRBUF_INIT
;
1180 strbuf_addstr(&sb
, action
);
1181 strbuf_addstr(&sb
, ": ");
1184 nl
= strchr(msg
->buf
, '\n');
1186 strbuf_add(&sb
, msg
->buf
, nl
+ 1 - msg
->buf
);
1188 strbuf_addbuf(&sb
, msg
);
1189 strbuf_addch(&sb
, '\n');
1192 transaction
= ref_transaction_begin(err
);
1194 ref_transaction_update(transaction
, "HEAD", new_head
,
1195 old_head
? &old_head
->object
.oid
: null_oid(),
1197 ref_transaction_commit(transaction
, err
)) {
1200 ref_transaction_free(transaction
);
1201 strbuf_release(&sb
);
1206 static int run_rewrite_hook(const struct object_id
*oldoid
,
1207 const struct object_id
*newoid
)
1209 struct child_process proc
= CHILD_PROCESS_INIT
;
1211 struct strbuf sb
= STRBUF_INIT
;
1212 const char *hook_path
= find_hook("post-rewrite");
1217 strvec_pushl(&proc
.args
, hook_path
, "amend", NULL
);
1219 proc
.stdout_to_stderr
= 1;
1220 proc
.trace2_hook_name
= "post-rewrite";
1222 code
= start_command(&proc
);
1225 strbuf_addf(&sb
, "%s %s\n", oid_to_hex(oldoid
), oid_to_hex(newoid
));
1226 sigchain_push(SIGPIPE
, SIG_IGN
);
1227 write_in_full(proc
.in
, sb
.buf
, sb
.len
);
1229 strbuf_release(&sb
);
1230 sigchain_pop(SIGPIPE
);
1231 return finish_command(&proc
);
1234 void commit_post_rewrite(struct repository
*r
,
1235 const struct commit
*old_head
,
1236 const struct object_id
*new_head
)
1238 struct notes_rewrite_cfg
*cfg
;
1240 cfg
= init_copy_notes_for_rewrite("amend");
1242 /* we are amending, so old_head is not NULL */
1243 copy_note_for_rewrite(cfg
, &old_head
->object
.oid
, new_head
);
1244 finish_copy_notes_for_rewrite(r
, cfg
, "Notes added by 'git commit --amend'");
1246 run_rewrite_hook(&old_head
->object
.oid
, new_head
);
1249 static int run_prepare_commit_msg_hook(struct repository
*r
,
1254 const char *name
, *arg1
= NULL
, *arg2
= NULL
;
1256 name
= git_path_commit_editmsg();
1257 if (write_message(msg
->buf
, msg
->len
, name
, 0))
1266 if (run_commit_hook(0, r
->index_file
, NULL
, "prepare-commit-msg", name
,
1268 ret
= error(_("'prepare-commit-msg' hook failed"));
1273 static const char implicit_ident_advice_noconfig
[] =
1274 N_("Your name and email address were configured automatically based\n"
1275 "on your username and hostname. Please check that they are accurate.\n"
1276 "You can suppress this message by setting them explicitly. Run the\n"
1277 "following command and follow the instructions in your editor to edit\n"
1278 "your configuration file:\n"
1280 " git config --global --edit\n"
1282 "After doing this, you may fix the identity used for this commit with:\n"
1284 " git commit --amend --reset-author\n");
1286 static const char implicit_ident_advice_config
[] =
1287 N_("Your name and email address were configured automatically based\n"
1288 "on your username and hostname. Please check that they are accurate.\n"
1289 "You can suppress this message by setting them explicitly:\n"
1291 " git config --global user.name \"Your Name\"\n"
1292 " git config --global user.email you@example.com\n"
1294 "After doing this, you may fix the identity used for this commit with:\n"
1296 " git commit --amend --reset-author\n");
1298 static const char *implicit_ident_advice(void)
1300 char *user_config
= interpolate_path("~/.gitconfig", 0);
1301 char *xdg_config
= xdg_config_home("config");
1302 int config_exists
= file_exists(user_config
) || file_exists(xdg_config
);
1308 return _(implicit_ident_advice_config
);
1310 return _(implicit_ident_advice_noconfig
);
1314 void print_commit_summary(struct repository
*r
,
1316 const struct object_id
*oid
,
1319 struct rev_info rev
;
1320 struct commit
*commit
;
1321 struct strbuf format
= STRBUF_INIT
;
1323 struct pretty_print_context pctx
= {0};
1324 struct strbuf author_ident
= STRBUF_INIT
;
1325 struct strbuf committer_ident
= STRBUF_INIT
;
1326 struct ref_store
*refs
;
1328 commit
= lookup_commit(r
, oid
);
1330 die(_("couldn't look up newly created commit"));
1331 if (parse_commit(commit
))
1332 die(_("could not parse newly created commit"));
1334 strbuf_addstr(&format
, "format:%h] %s");
1336 format_commit_message(commit
, "%an <%ae>", &author_ident
, &pctx
);
1337 format_commit_message(commit
, "%cn <%ce>", &committer_ident
, &pctx
);
1338 if (strbuf_cmp(&author_ident
, &committer_ident
)) {
1339 strbuf_addstr(&format
, "\n Author: ");
1340 strbuf_addbuf_percentquote(&format
, &author_ident
);
1342 if (flags
& SUMMARY_SHOW_AUTHOR_DATE
) {
1343 struct strbuf date
= STRBUF_INIT
;
1345 format_commit_message(commit
, "%ad", &date
, &pctx
);
1346 strbuf_addstr(&format
, "\n Date: ");
1347 strbuf_addbuf_percentquote(&format
, &date
);
1348 strbuf_release(&date
);
1350 if (!committer_ident_sufficiently_given()) {
1351 strbuf_addstr(&format
, "\n Committer: ");
1352 strbuf_addbuf_percentquote(&format
, &committer_ident
);
1353 if (advice_enabled(ADVICE_IMPLICIT_IDENTITY
)) {
1354 strbuf_addch(&format
, '\n');
1355 strbuf_addstr(&format
, implicit_ident_advice());
1358 strbuf_release(&author_ident
);
1359 strbuf_release(&committer_ident
);
1361 repo_init_revisions(r
, &rev
, prefix
);
1362 setup_revisions(0, NULL
, &rev
, NULL
);
1365 rev
.diffopt
.output_format
=
1366 DIFF_FORMAT_SHORTSTAT
| DIFF_FORMAT_SUMMARY
;
1368 rev
.verbose_header
= 1;
1369 rev
.show_root_diff
= 1;
1370 get_commit_format(format
.buf
, &rev
);
1371 rev
.always_show_header
= 0;
1372 rev
.diffopt
.detect_rename
= DIFF_DETECT_RENAME
;
1373 diff_setup_done(&rev
.diffopt
);
1375 refs
= get_main_ref_store(the_repository
);
1376 head
= refs_resolve_ref_unsafe(refs
, "HEAD", 0, NULL
, NULL
);
1378 die(_("unable to resolve HEAD after creating commit"));
1379 if (!strcmp(head
, "HEAD"))
1380 head
= _("detached HEAD");
1382 skip_prefix(head
, "refs/heads/", &head
);
1383 printf("[%s%s ", head
, (flags
& SUMMARY_INITIAL_COMMIT
) ?
1384 _(" (root-commit)") : "");
1386 if (!log_tree_commit(&rev
, commit
)) {
1387 rev
.always_show_header
= 1;
1388 rev
.use_terminator
= 1;
1389 log_tree_commit(&rev
, commit
);
1392 release_revisions(&rev
);
1393 strbuf_release(&format
);
1396 static int parse_head(struct repository
*r
, struct commit
**head
)
1398 struct commit
*current_head
;
1399 struct object_id oid
;
1401 if (get_oid("HEAD", &oid
)) {
1402 current_head
= NULL
;
1404 current_head
= lookup_commit_reference(r
, &oid
);
1406 return error(_("could not parse HEAD"));
1407 if (!oideq(&oid
, ¤t_head
->object
.oid
)) {
1408 warning(_("HEAD %s is not a commit!"),
1411 if (parse_commit(current_head
))
1412 return error(_("could not parse HEAD commit"));
1414 *head
= current_head
;
1420 * Try to commit without forking 'git commit'. In some cases we need
1421 * to run 'git commit' to display an error message
1424 * -1 - error unable to commit
1426 * 1 - run 'git commit'
1428 static int try_to_commit(struct repository
*r
,
1429 struct strbuf
*msg
, const char *author
,
1430 struct replay_opts
*opts
, unsigned int flags
,
1431 struct object_id
*oid
)
1433 struct object_id tree
;
1434 struct commit
*current_head
= NULL
;
1435 struct commit_list
*parents
= NULL
;
1436 struct commit_extra_header
*extra
= NULL
;
1437 struct strbuf err
= STRBUF_INIT
;
1438 struct strbuf commit_msg
= STRBUF_INIT
;
1439 char *amend_author
= NULL
;
1440 const char *committer
= NULL
;
1441 const char *hook_commit
= NULL
;
1442 enum commit_msg_cleanup_mode cleanup
;
1445 if ((flags
& CLEANUP_MSG
) && (flags
& VERBATIM_MSG
))
1446 BUG("CLEANUP_MSG and VERBATIM_MSG are mutually exclusive");
1448 if (parse_head(r
, ¤t_head
))
1451 if (flags
& AMEND_MSG
) {
1452 const char *exclude_gpgsig
[] = { "gpgsig", "gpgsig-sha256", NULL
};
1453 const char *out_enc
= get_commit_output_encoding();
1454 const char *message
= logmsg_reencode(current_head
, NULL
,
1458 const char *orig_message
= NULL
;
1460 find_commit_subject(message
, &orig_message
);
1462 strbuf_addstr(msg
, orig_message
);
1463 hook_commit
= "HEAD";
1465 author
= amend_author
= get_author(message
);
1466 unuse_commit_buffer(current_head
, message
);
1468 res
= error(_("unable to parse commit author"));
1471 parents
= copy_commit_list(current_head
->parents
);
1472 extra
= read_commit_extra_headers(current_head
, exclude_gpgsig
);
1473 } else if (current_head
&&
1474 (!(flags
& CREATE_ROOT_COMMIT
) || (flags
& AMEND_MSG
))) {
1475 commit_list_insert(current_head
, &parents
);
1478 if (write_index_as_tree(&tree
, r
->index
, r
->index_file
, 0, NULL
)) {
1479 res
= error(_("git write-tree failed to write a tree"));
1483 if (!(flags
& ALLOW_EMPTY
)) {
1484 struct commit
*first_parent
= current_head
;
1486 if (flags
& AMEND_MSG
) {
1487 if (current_head
->parents
) {
1488 first_parent
= current_head
->parents
->item
;
1489 if (repo_parse_commit(r
, first_parent
)) {
1490 res
= error(_("could not parse HEAD commit"));
1494 first_parent
= NULL
;
1497 if (oideq(first_parent
1498 ? get_commit_tree_oid(first_parent
)
1499 : the_hash_algo
->empty_tree
,
1501 res
= 1; /* run 'git commit' to display error message */
1506 if (hook_exists("prepare-commit-msg")) {
1507 res
= run_prepare_commit_msg_hook(r
, msg
, hook_commit
);
1510 if (strbuf_read_file(&commit_msg
, git_path_commit_editmsg(),
1512 res
= error_errno(_("unable to read commit message "
1514 git_path_commit_editmsg());
1520 if (flags
& CLEANUP_MSG
)
1521 cleanup
= COMMIT_MSG_CLEANUP_ALL
;
1522 else if (flags
& VERBATIM_MSG
)
1523 cleanup
= COMMIT_MSG_CLEANUP_NONE
;
1524 else if ((opts
->signoff
|| opts
->record_origin
) &&
1525 !opts
->explicit_cleanup
)
1526 cleanup
= COMMIT_MSG_CLEANUP_SPACE
;
1528 cleanup
= opts
->default_msg_cleanup
;
1530 if (cleanup
!= COMMIT_MSG_CLEANUP_NONE
)
1531 strbuf_stripspace(msg
, cleanup
== COMMIT_MSG_CLEANUP_ALL
);
1532 if ((flags
& EDIT_MSG
) && message_is_empty(msg
, cleanup
)) {
1533 res
= 1; /* run 'git commit' to display error message */
1537 if (opts
->committer_date_is_author_date
) {
1538 struct ident_split id
;
1539 struct strbuf date
= STRBUF_INIT
;
1541 if (!opts
->ignore_date
) {
1542 if (split_ident_line(&id
, author
, (int)strlen(author
)) < 0) {
1543 res
= error(_("invalid author identity '%s'"),
1547 if (!id
.date_begin
) {
1549 "corrupt author: missing date information"));
1552 strbuf_addf(&date
, "@%.*s %.*s",
1553 (int)(id
.date_end
- id
.date_begin
),
1555 (int)(id
.tz_end
- id
.tz_begin
),
1560 committer
= fmt_ident(getenv("GIT_COMMITTER_NAME"),
1561 getenv("GIT_COMMITTER_EMAIL"),
1562 WANT_COMMITTER_IDENT
,
1563 opts
->ignore_date
? NULL
: date
.buf
,
1565 strbuf_release(&date
);
1570 if (opts
->ignore_date
) {
1571 struct ident_split id
;
1574 if (split_ident_line(&id
, author
, strlen(author
)) < 0) {
1575 error(_("invalid author identity '%s'"), author
);
1578 name
= xmemdupz(id
.name_begin
, id
.name_end
- id
.name_begin
);
1579 email
= xmemdupz(id
.mail_begin
, id
.mail_end
- id
.mail_begin
);
1580 author
= fmt_ident(name
, email
, WANT_AUTHOR_IDENT
, NULL
,
1586 if (commit_tree_extended(msg
->buf
, msg
->len
, &tree
, parents
, oid
,
1587 author
, committer
, opts
->gpg_sign
, extra
)) {
1588 res
= error(_("failed to write commit object"));
1592 if (update_head_with_reflog(current_head
, oid
,
1593 getenv("GIT_REFLOG_ACTION"), msg
, &err
)) {
1594 res
= error("%s", err
.buf
);
1598 run_commit_hook(0, r
->index_file
, NULL
, "post-commit", NULL
);
1599 if (flags
& AMEND_MSG
)
1600 commit_post_rewrite(r
, current_head
, oid
);
1603 free_commit_extra_headers(extra
);
1604 strbuf_release(&err
);
1605 strbuf_release(&commit_msg
);
1611 static int write_rebase_head(struct object_id
*oid
)
1613 if (update_ref("rebase", "REBASE_HEAD", oid
,
1614 NULL
, REF_NO_DEREF
, UPDATE_REFS_MSG_ON_ERR
))
1615 return error(_("could not update %s"), "REBASE_HEAD");
1620 static int do_commit(struct repository
*r
,
1621 const char *msg_file
, const char *author
,
1622 struct replay_opts
*opts
, unsigned int flags
,
1623 struct object_id
*oid
)
1627 if (!(flags
& EDIT_MSG
) && !(flags
& VERIFY_MSG
)) {
1628 struct object_id oid
;
1629 struct strbuf sb
= STRBUF_INIT
;
1631 if (msg_file
&& strbuf_read_file(&sb
, msg_file
, 2048) < 0)
1632 return error_errno(_("unable to read commit message "
1636 res
= try_to_commit(r
, msg_file
? &sb
: NULL
,
1637 author
, opts
, flags
, &oid
);
1638 strbuf_release(&sb
);
1640 refs_delete_ref(get_main_ref_store(r
), "",
1641 "CHERRY_PICK_HEAD", NULL
, 0);
1642 unlink(git_path_merge_msg(r
));
1643 if (!is_rebase_i(opts
))
1644 print_commit_summary(r
, NULL
, &oid
,
1645 SUMMARY_SHOW_AUTHOR_DATE
);
1650 if (is_rebase_i(opts
) && oid
)
1651 if (write_rebase_head(oid
))
1653 return run_git_commit(msg_file
, opts
, flags
);
1659 static int is_original_commit_empty(struct commit
*commit
)
1661 const struct object_id
*ptree_oid
;
1663 if (parse_commit(commit
))
1664 return error(_("could not parse commit %s"),
1665 oid_to_hex(&commit
->object
.oid
));
1666 if (commit
->parents
) {
1667 struct commit
*parent
= commit
->parents
->item
;
1668 if (parse_commit(parent
))
1669 return error(_("could not parse parent commit %s"),
1670 oid_to_hex(&parent
->object
.oid
));
1671 ptree_oid
= get_commit_tree_oid(parent
);
1673 ptree_oid
= the_hash_algo
->empty_tree
; /* commit is root */
1676 return oideq(ptree_oid
, get_commit_tree_oid(commit
));
1680 * Should empty commits be allowed? Return status:
1681 * <0: Error in is_index_unchanged(r) or is_original_commit_empty(commit)
1682 * 0: Halt on empty commit
1683 * 1: Allow empty commit
1684 * 2: Drop empty commit
1686 static int allow_empty(struct repository
*r
,
1687 struct replay_opts
*opts
,
1688 struct commit
*commit
)
1690 int index_unchanged
, originally_empty
;
1695 * (1) we do not allow empty at all and error out.
1697 * (2) we allow ones that were initially empty, and
1698 * just drop the ones that become empty
1700 * (3) we allow ones that were initially empty, but
1701 * halt for the ones that become empty;
1703 * (4) we allow both.
1705 if (!opts
->allow_empty
)
1706 return 0; /* let "git commit" barf as necessary */
1708 index_unchanged
= is_index_unchanged(r
);
1709 if (index_unchanged
< 0)
1710 return index_unchanged
;
1711 if (!index_unchanged
)
1712 return 0; /* we do not have to say --allow-empty */
1714 if (opts
->keep_redundant_commits
)
1717 originally_empty
= is_original_commit_empty(commit
);
1718 if (originally_empty
< 0)
1719 return originally_empty
;
1720 if (originally_empty
)
1722 else if (opts
->drop_redundant_commits
)
1731 } todo_command_info
[] = {
1732 [TODO_PICK
] = { 'p', "pick" },
1733 [TODO_REVERT
] = { 0, "revert" },
1734 [TODO_EDIT
] = { 'e', "edit" },
1735 [TODO_REWORD
] = { 'r', "reword" },
1736 [TODO_FIXUP
] = { 'f', "fixup" },
1737 [TODO_SQUASH
] = { 's', "squash" },
1738 [TODO_EXEC
] = { 'x', "exec" },
1739 [TODO_BREAK
] = { 'b', "break" },
1740 [TODO_LABEL
] = { 'l', "label" },
1741 [TODO_RESET
] = { 't', "reset" },
1742 [TODO_MERGE
] = { 'm', "merge" },
1743 [TODO_UPDATE_REF
] = { 'u', "update-ref" },
1744 [TODO_NOOP
] = { 0, "noop" },
1745 [TODO_DROP
] = { 'd', "drop" },
1746 [TODO_COMMENT
] = { 0, NULL
},
1749 static const char *command_to_string(const enum todo_command command
)
1751 if (command
< TODO_COMMENT
)
1752 return todo_command_info
[command
].str
;
1753 die(_("unknown command: %d"), command
);
1756 static char command_to_char(const enum todo_command command
)
1758 if (command
< TODO_COMMENT
)
1759 return todo_command_info
[command
].c
;
1760 return comment_line_char
;
1763 static int is_noop(const enum todo_command command
)
1765 return TODO_NOOP
<= command
;
1768 static int is_fixup(enum todo_command command
)
1770 return command
== TODO_FIXUP
|| command
== TODO_SQUASH
;
1773 /* Does this command create a (non-merge) commit? */
1774 static int is_pick_or_similar(enum todo_command command
)
1789 enum todo_item_flags
{
1790 TODO_EDIT_MERGE_MSG
= (1 << 0),
1791 TODO_REPLACE_FIXUP_MSG
= (1 << 1),
1792 TODO_EDIT_FIXUP_MSG
= (1 << 2),
1795 static const char first_commit_msg_str
[] = N_("This is the 1st commit message:");
1796 static const char nth_commit_msg_fmt
[] = N_("This is the commit message #%d:");
1797 static const char skip_first_commit_msg_str
[] = N_("The 1st commit message will be skipped:");
1798 static const char skip_nth_commit_msg_fmt
[] = N_("The commit message #%d will be skipped:");
1799 static const char combined_commit_msg_fmt
[] = N_("This is a combination of %d commits.");
1801 static int is_fixup_flag(enum todo_command command
, unsigned flag
)
1803 return command
== TODO_FIXUP
&& ((flag
& TODO_REPLACE_FIXUP_MSG
) ||
1804 (flag
& TODO_EDIT_FIXUP_MSG
));
1808 * Wrapper around strbuf_add_commented_lines() which avoids double
1809 * commenting commit subjects.
1811 static void add_commented_lines(struct strbuf
*buf
, const void *str
, size_t len
)
1813 const char *s
= str
;
1814 while (len
> 0 && s
[0] == comment_line_char
) {
1816 const char *n
= memchr(s
, '\n', len
);
1821 strbuf_add(buf
, s
, count
);
1825 strbuf_add_commented_lines(buf
, s
, len
);
1828 /* Does the current fixup chain contain a squash command? */
1829 static int seen_squash(struct replay_opts
*opts
)
1831 return starts_with(opts
->current_fixups
.buf
, "squash") ||
1832 strstr(opts
->current_fixups
.buf
, "\nsquash");
1835 static void update_comment_bufs(struct strbuf
*buf1
, struct strbuf
*buf2
, int n
)
1837 strbuf_setlen(buf1
, 2);
1838 strbuf_addf(buf1
, _(nth_commit_msg_fmt
), n
);
1839 strbuf_addch(buf1
, '\n');
1840 strbuf_setlen(buf2
, 2);
1841 strbuf_addf(buf2
, _(skip_nth_commit_msg_fmt
), n
);
1842 strbuf_addch(buf2
, '\n');
1846 * Comment out any un-commented commit messages, updating the message comments
1847 * to say they will be skipped but do not comment out the empty lines that
1848 * surround commit messages and their comments.
1850 static void update_squash_message_for_fixup(struct strbuf
*msg
)
1852 void (*copy_lines
)(struct strbuf
*, const void *, size_t) = strbuf_add
;
1853 struct strbuf buf1
= STRBUF_INIT
, buf2
= STRBUF_INIT
;
1854 const char *s
, *start
;
1856 size_t orig_msg_len
;
1859 strbuf_addf(&buf1
, "# %s\n", _(first_commit_msg_str
));
1860 strbuf_addf(&buf2
, "# %s\n", _(skip_first_commit_msg_str
));
1861 s
= start
= orig_msg
= strbuf_detach(msg
, &orig_msg_len
);
1865 if (skip_prefix(s
, buf1
.buf
, &next
)) {
1867 * Copy the last message, preserving the blank line
1868 * preceding the current line
1870 off
= (s
> start
+ 1 && s
[-2] == '\n') ? 1 : 0;
1871 copy_lines(msg
, start
, s
- start
- off
);
1873 strbuf_addch(msg
, '\n');
1875 * The next message needs to be commented out but the
1876 * message header is already commented out so just copy
1877 * it and the blank line that follows it.
1879 strbuf_addbuf(msg
, &buf2
);
1881 strbuf_addch(msg
, *next
++);
1883 copy_lines
= add_commented_lines
;
1884 update_comment_bufs(&buf1
, &buf2
, ++i
);
1885 } else if (skip_prefix(s
, buf2
.buf
, &next
)) {
1886 off
= (s
> start
+ 1 && s
[-2] == '\n') ? 1 : 0;
1887 copy_lines(msg
, start
, s
- start
- off
);
1890 copy_lines
= strbuf_add
;
1891 update_comment_bufs(&buf1
, &buf2
, ++i
);
1893 s
= strchr(s
, '\n');
1898 copy_lines(msg
, start
, orig_msg_len
- (start
- orig_msg
));
1900 strbuf_release(&buf1
);
1901 strbuf_release(&buf2
);
1904 static int append_squash_message(struct strbuf
*buf
, const char *body
,
1905 enum todo_command command
, struct replay_opts
*opts
,
1908 const char *fixup_msg
;
1909 size_t commented_len
= 0, fixup_off
;
1911 * amend is non-interactive and not normally used with fixup!
1912 * or squash! commits, so only comment out those subjects when
1913 * squashing commit messages.
1915 if (starts_with(body
, "amend!") ||
1916 ((command
== TODO_SQUASH
|| seen_squash(opts
)) &&
1917 (starts_with(body
, "squash!") || starts_with(body
, "fixup!"))))
1918 commented_len
= commit_subject_length(body
);
1920 strbuf_addf(buf
, "\n%c ", comment_line_char
);
1921 strbuf_addf(buf
, _(nth_commit_msg_fmt
),
1922 ++opts
->current_fixup_count
+ 1);
1923 strbuf_addstr(buf
, "\n\n");
1924 strbuf_add_commented_lines(buf
, body
, commented_len
);
1925 /* buf->buf may be reallocated so store an offset into the buffer */
1926 fixup_off
= buf
->len
;
1927 strbuf_addstr(buf
, body
+ commented_len
);
1929 /* fixup -C after squash behaves like squash */
1930 if (is_fixup_flag(command
, flag
) && !seen_squash(opts
)) {
1932 * We're replacing the commit message so we need to
1933 * append the Signed-off-by: trailer if the user
1934 * requested '--signoff'.
1937 append_signoff(buf
, 0, 0);
1939 if ((command
== TODO_FIXUP
) &&
1940 (flag
& TODO_REPLACE_FIXUP_MSG
) &&
1941 (file_exists(rebase_path_fixup_msg()) ||
1942 !file_exists(rebase_path_squash_msg()))) {
1943 fixup_msg
= skip_blank_lines(buf
->buf
+ fixup_off
);
1944 if (write_message(fixup_msg
, strlen(fixup_msg
),
1945 rebase_path_fixup_msg(), 0) < 0)
1946 return error(_("cannot write '%s'"),
1947 rebase_path_fixup_msg());
1949 unlink(rebase_path_fixup_msg());
1952 unlink(rebase_path_fixup_msg());
1958 static int update_squash_messages(struct repository
*r
,
1959 enum todo_command command
,
1960 struct commit
*commit
,
1961 struct replay_opts
*opts
,
1964 struct strbuf buf
= STRBUF_INIT
;
1966 const char *message
, *body
;
1967 const char *encoding
= get_commit_output_encoding();
1969 if (opts
->current_fixup_count
> 0) {
1970 struct strbuf header
= STRBUF_INIT
;
1973 if (strbuf_read_file(&buf
, rebase_path_squash_msg(), 9) <= 0)
1974 return error(_("could not read '%s'"),
1975 rebase_path_squash_msg());
1977 eol
= buf
.buf
[0] != comment_line_char
?
1978 buf
.buf
: strchrnul(buf
.buf
, '\n');
1980 strbuf_addf(&header
, "%c ", comment_line_char
);
1981 strbuf_addf(&header
, _(combined_commit_msg_fmt
),
1982 opts
->current_fixup_count
+ 2);
1983 strbuf_splice(&buf
, 0, eol
- buf
.buf
, header
.buf
, header
.len
);
1984 strbuf_release(&header
);
1985 if (is_fixup_flag(command
, flag
) && !seen_squash(opts
))
1986 update_squash_message_for_fixup(&buf
);
1988 struct object_id head
;
1989 struct commit
*head_commit
;
1990 const char *head_message
, *body
;
1992 if (get_oid("HEAD", &head
))
1993 return error(_("need a HEAD to fixup"));
1994 if (!(head_commit
= lookup_commit_reference(r
, &head
)))
1995 return error(_("could not read HEAD"));
1996 if (!(head_message
= logmsg_reencode(head_commit
, NULL
, encoding
)))
1997 return error(_("could not read HEAD's commit message"));
1999 find_commit_subject(head_message
, &body
);
2000 if (command
== TODO_FIXUP
&& !flag
&& write_message(body
, strlen(body
),
2001 rebase_path_fixup_msg(), 0) < 0) {
2002 unuse_commit_buffer(head_commit
, head_message
);
2003 return error(_("cannot write '%s'"), rebase_path_fixup_msg());
2005 strbuf_addf(&buf
, "%c ", comment_line_char
);
2006 strbuf_addf(&buf
, _(combined_commit_msg_fmt
), 2);
2007 strbuf_addf(&buf
, "\n%c ", comment_line_char
);
2008 strbuf_addstr(&buf
, is_fixup_flag(command
, flag
) ?
2009 _(skip_first_commit_msg_str
) :
2010 _(first_commit_msg_str
));
2011 strbuf_addstr(&buf
, "\n\n");
2012 if (is_fixup_flag(command
, flag
))
2013 strbuf_add_commented_lines(&buf
, body
, strlen(body
));
2015 strbuf_addstr(&buf
, body
);
2017 unuse_commit_buffer(head_commit
, head_message
);
2020 if (!(message
= logmsg_reencode(commit
, NULL
, encoding
)))
2021 return error(_("could not read commit message of %s"),
2022 oid_to_hex(&commit
->object
.oid
));
2023 find_commit_subject(message
, &body
);
2025 if (command
== TODO_SQUASH
|| is_fixup_flag(command
, flag
)) {
2026 res
= append_squash_message(&buf
, body
, command
, opts
, flag
);
2027 } else if (command
== TODO_FIXUP
) {
2028 strbuf_addf(&buf
, "\n%c ", comment_line_char
);
2029 strbuf_addf(&buf
, _(skip_nth_commit_msg_fmt
),
2030 ++opts
->current_fixup_count
+ 1);
2031 strbuf_addstr(&buf
, "\n\n");
2032 strbuf_add_commented_lines(&buf
, body
, strlen(body
));
2034 return error(_("unknown command: %d"), command
);
2035 unuse_commit_buffer(commit
, message
);
2038 res
= write_message(buf
.buf
, buf
.len
, rebase_path_squash_msg(),
2040 strbuf_release(&buf
);
2043 strbuf_addf(&opts
->current_fixups
, "%s%s %s",
2044 opts
->current_fixups
.len
? "\n" : "",
2045 command_to_string(command
),
2046 oid_to_hex(&commit
->object
.oid
));
2047 res
= write_message(opts
->current_fixups
.buf
,
2048 opts
->current_fixups
.len
,
2049 rebase_path_current_fixups(), 0);
2055 static void flush_rewritten_pending(void)
2057 struct strbuf buf
= STRBUF_INIT
;
2058 struct object_id newoid
;
2061 if (strbuf_read_file(&buf
, rebase_path_rewritten_pending(), (GIT_MAX_HEXSZ
+ 1) * 2) > 0 &&
2062 !get_oid("HEAD", &newoid
) &&
2063 (out
= fopen_or_warn(rebase_path_rewritten_list(), "a"))) {
2064 char *bol
= buf
.buf
, *eol
;
2067 eol
= strchrnul(bol
, '\n');
2068 fprintf(out
, "%.*s %s\n", (int)(eol
- bol
),
2069 bol
, oid_to_hex(&newoid
));
2075 unlink(rebase_path_rewritten_pending());
2077 strbuf_release(&buf
);
2080 static void record_in_rewritten(struct object_id
*oid
,
2081 enum todo_command next_command
)
2083 FILE *out
= fopen_or_warn(rebase_path_rewritten_pending(), "a");
2088 fprintf(out
, "%s\n", oid_to_hex(oid
));
2091 if (!is_fixup(next_command
))
2092 flush_rewritten_pending();
2095 static int should_edit(struct replay_opts
*opts
) {
2098 * Note that we only handle the case of non-conflicted
2099 * commits; continue_single_pick() handles the conflicted
2100 * commits itself instead of calling this function.
2102 return (opts
->action
== REPLAY_REVERT
&& isatty(0)) ? 1 : 0;
2106 static void refer_to_commit(struct replay_opts
*opts
,
2107 struct strbuf
*msgbuf
, struct commit
*commit
)
2109 if (opts
->commit_use_reference
) {
2110 struct pretty_print_context ctx
= {
2111 .abbrev
= DEFAULT_ABBREV
,
2112 .date_mode
.type
= DATE_SHORT
,
2114 format_commit_message(commit
, "%h (%s, %ad)", msgbuf
, &ctx
);
2116 strbuf_addstr(msgbuf
, oid_to_hex(&commit
->object
.oid
));
2120 static int do_pick_commit(struct repository
*r
,
2121 struct todo_item
*item
,
2122 struct replay_opts
*opts
,
2123 int final_fixup
, int *check_todo
)
2125 unsigned int flags
= should_edit(opts
) ? EDIT_MSG
: 0;
2126 const char *msg_file
= should_edit(opts
) ? NULL
: git_path_merge_msg(r
);
2127 struct object_id head
;
2128 struct commit
*base
, *next
, *parent
;
2129 const char *base_label
, *next_label
;
2130 char *author
= NULL
;
2131 struct commit_message msg
= { NULL
, NULL
, NULL
, NULL
};
2132 struct strbuf msgbuf
= STRBUF_INIT
;
2133 int res
, unborn
= 0, reword
= 0, allow
, drop_commit
;
2134 enum todo_command command
= item
->command
;
2135 struct commit
*commit
= item
->commit
;
2137 if (opts
->no_commit
) {
2139 * We do not intend to commit immediately. We just want to
2140 * merge the differences in, so let's compute the tree
2141 * that represents the "current" state for the merge machinery
2144 if (write_index_as_tree(&head
, r
->index
, r
->index_file
, 0, NULL
))
2145 return error(_("your index file is unmerged."));
2147 unborn
= get_oid("HEAD", &head
);
2148 /* Do we want to generate a root commit? */
2149 if (is_pick_or_similar(command
) && opts
->have_squash_onto
&&
2150 oideq(&head
, &opts
->squash_onto
)) {
2151 if (is_fixup(command
))
2152 return error(_("cannot fixup root commit"));
2153 flags
|= CREATE_ROOT_COMMIT
;
2156 oidcpy(&head
, the_hash_algo
->empty_tree
);
2157 if (index_differs_from(r
, unborn
? empty_tree_oid_hex() : "HEAD",
2159 return error_dirty_index(r
, opts
);
2161 discard_index(r
->index
);
2163 if (!commit
->parents
)
2165 else if (commit
->parents
->next
) {
2166 /* Reverting or cherry-picking a merge commit */
2168 struct commit_list
*p
;
2170 if (!opts
->mainline
)
2171 return error(_("commit %s is a merge but no -m option was given."),
2172 oid_to_hex(&commit
->object
.oid
));
2174 for (cnt
= 1, p
= commit
->parents
;
2175 cnt
!= opts
->mainline
&& p
;
2178 if (cnt
!= opts
->mainline
|| !p
)
2179 return error(_("commit %s does not have parent %d"),
2180 oid_to_hex(&commit
->object
.oid
), opts
->mainline
);
2182 } else if (1 < opts
->mainline
)
2184 * Non-first parent explicitly specified as mainline for
2187 return error(_("commit %s does not have parent %d"),
2188 oid_to_hex(&commit
->object
.oid
), opts
->mainline
);
2190 parent
= commit
->parents
->item
;
2192 if (get_message(commit
, &msg
) != 0)
2193 return error(_("cannot get commit message for %s"),
2194 oid_to_hex(&commit
->object
.oid
));
2196 if (opts
->allow_ff
&& !is_fixup(command
) &&
2197 ((parent
&& oideq(&parent
->object
.oid
, &head
)) ||
2198 (!parent
&& unborn
))) {
2199 if (is_rebase_i(opts
))
2200 write_author_script(msg
.message
);
2201 res
= fast_forward_to(r
, &commit
->object
.oid
, &head
, unborn
,
2203 if (res
|| command
!= TODO_REWORD
)
2207 goto fast_forward_edit
;
2209 if (parent
&& parse_commit(parent
) < 0)
2210 /* TRANSLATORS: The first %s will be a "todo" command like
2211 "revert" or "pick", the second %s a SHA1. */
2212 return error(_("%s: cannot parse parent commit %s"),
2213 command_to_string(command
),
2214 oid_to_hex(&parent
->object
.oid
));
2217 * "commit" is an existing commit. We would want to apply
2218 * the difference it introduces since its first parent "prev"
2219 * on top of the current HEAD if we are cherry-pick. Or the
2220 * reverse of it if we are revert.
2223 if (command
== TODO_REVERT
) {
2225 base_label
= msg
.label
;
2227 next_label
= msg
.parent_label
;
2228 if (opts
->commit_use_reference
) {
2229 strbuf_addstr(&msgbuf
,
2230 "# *** SAY WHY WE ARE REVERTING ON THE TITLE LINE ***");
2232 strbuf_addstr(&msgbuf
, "Revert \"");
2233 strbuf_addstr(&msgbuf
, msg
.subject
);
2234 strbuf_addstr(&msgbuf
, "\"");
2236 strbuf_addstr(&msgbuf
, "\n\nThis reverts commit ");
2237 refer_to_commit(opts
, &msgbuf
, commit
);
2239 if (commit
->parents
&& commit
->parents
->next
) {
2240 strbuf_addstr(&msgbuf
, ", reversing\nchanges made to ");
2241 refer_to_commit(opts
, &msgbuf
, parent
);
2243 strbuf_addstr(&msgbuf
, ".\n");
2248 base_label
= msg
.parent_label
;
2250 next_label
= msg
.label
;
2252 /* Append the commit log message to msgbuf. */
2253 if (find_commit_subject(msg
.message
, &p
))
2254 strbuf_addstr(&msgbuf
, p
);
2256 if (opts
->record_origin
) {
2257 strbuf_complete_line(&msgbuf
);
2258 if (!has_conforming_footer(&msgbuf
, NULL
, 0))
2259 strbuf_addch(&msgbuf
, '\n');
2260 strbuf_addstr(&msgbuf
, cherry_picked_prefix
);
2261 strbuf_addstr(&msgbuf
, oid_to_hex(&commit
->object
.oid
));
2262 strbuf_addstr(&msgbuf
, ")\n");
2264 if (!is_fixup(command
))
2265 author
= get_author(msg
.message
);
2268 if (command
== TODO_REWORD
)
2270 else if (is_fixup(command
)) {
2271 if (update_squash_messages(r
, command
, commit
,
2276 msg_file
= rebase_path_squash_msg();
2277 else if (file_exists(rebase_path_fixup_msg())) {
2278 flags
|= VERBATIM_MSG
;
2279 msg_file
= rebase_path_fixup_msg();
2281 const char *dest
= git_path_squash_msg(r
);
2283 if (copy_file(dest
, rebase_path_squash_msg(), 0666))
2284 return error(_("could not rename '%s' to '%s'"),
2285 rebase_path_squash_msg(), dest
);
2286 unlink(git_path_merge_msg(r
));
2292 if (opts
->signoff
&& !is_fixup(command
))
2293 append_signoff(&msgbuf
, 0, 0);
2295 if (is_rebase_i(opts
) && write_author_script(msg
.message
) < 0)
2297 else if (!opts
->strategy
||
2298 !strcmp(opts
->strategy
, "recursive") ||
2299 !strcmp(opts
->strategy
, "ort") ||
2300 command
== TODO_REVERT
) {
2301 res
= do_recursive_merge(r
, base
, next
, base_label
, next_label
,
2302 &head
, &msgbuf
, opts
);
2306 res
|= write_message(msgbuf
.buf
, msgbuf
.len
,
2307 git_path_merge_msg(r
), 0);
2309 struct commit_list
*common
= NULL
;
2310 struct commit_list
*remotes
= NULL
;
2312 res
= write_message(msgbuf
.buf
, msgbuf
.len
,
2313 git_path_merge_msg(r
), 0);
2315 commit_list_insert(base
, &common
);
2316 commit_list_insert(next
, &remotes
);
2317 res
|= try_merge_command(r
, opts
->strategy
,
2318 opts
->xopts_nr
, (const char **)opts
->xopts
,
2319 common
, oid_to_hex(&head
), remotes
);
2320 free_commit_list(common
);
2321 free_commit_list(remotes
);
2323 strbuf_release(&msgbuf
);
2326 * If the merge was clean or if it failed due to conflict, we write
2327 * CHERRY_PICK_HEAD for the subsequent invocation of commit to use.
2328 * However, if the merge did not even start, then we don't want to
2331 if ((command
== TODO_PICK
|| command
== TODO_REWORD
||
2332 command
== TODO_EDIT
) && !opts
->no_commit
&&
2333 (res
== 0 || res
== 1) &&
2334 update_ref(NULL
, "CHERRY_PICK_HEAD", &commit
->object
.oid
, NULL
,
2335 REF_NO_DEREF
, UPDATE_REFS_MSG_ON_ERR
))
2337 if (command
== TODO_REVERT
&& ((opts
->no_commit
&& res
== 0) || res
== 1) &&
2338 update_ref(NULL
, "REVERT_HEAD", &commit
->object
.oid
, NULL
,
2339 REF_NO_DEREF
, UPDATE_REFS_MSG_ON_ERR
))
2343 error(command
== TODO_REVERT
2344 ? _("could not revert %s... %s")
2345 : _("could not apply %s... %s"),
2346 short_commit_name(commit
), msg
.subject
);
2347 print_advice(r
, res
== 1, opts
);
2348 repo_rerere(r
, opts
->allow_rerere_auto
);
2353 allow
= allow_empty(r
, opts
, commit
);
2357 } else if (allow
== 1) {
2358 flags
|= ALLOW_EMPTY
;
2359 } else if (allow
== 2) {
2361 refs_delete_ref(get_main_ref_store(r
), "", "CHERRY_PICK_HEAD",
2363 unlink(git_path_merge_msg(r
));
2364 unlink(git_path_auto_merge(r
));
2366 _("dropping %s %s -- patch contents already upstream\n"),
2367 oid_to_hex(&commit
->object
.oid
), msg
.subject
);
2368 } /* else allow == 0 and there's nothing special to do */
2369 if (!opts
->no_commit
&& !drop_commit
) {
2370 if (author
|| command
== TODO_REVERT
|| (flags
& AMEND_MSG
))
2371 res
= do_commit(r
, msg_file
, author
, opts
, flags
,
2372 commit
? &commit
->object
.oid
: NULL
);
2374 res
= error(_("unable to parse commit author"));
2375 *check_todo
= !!(flags
& EDIT_MSG
);
2376 if (!res
&& reword
) {
2378 res
= run_git_commit(NULL
, opts
, EDIT_MSG
|
2379 VERIFY_MSG
| AMEND_MSG
|
2380 (flags
& ALLOW_EMPTY
));
2386 if (!res
&& final_fixup
) {
2387 unlink(rebase_path_fixup_msg());
2388 unlink(rebase_path_squash_msg());
2389 unlink(rebase_path_current_fixups());
2390 strbuf_reset(&opts
->current_fixups
);
2391 opts
->current_fixup_count
= 0;
2395 free_message(commit
, &msg
);
2397 update_abort_safety_file();
2402 static int prepare_revs(struct replay_opts
*opts
)
2405 * picking (but not reverting) ranges (but not individual revisions)
2406 * should be done in reverse
2408 if (opts
->action
== REPLAY_PICK
&& !opts
->revs
->no_walk
)
2409 opts
->revs
->reverse
^= 1;
2411 if (prepare_revision_walk(opts
->revs
))
2412 return error(_("revision walk setup failed"));
2417 static int read_and_refresh_cache(struct repository
*r
,
2418 struct replay_opts
*opts
)
2420 struct lock_file index_lock
= LOCK_INIT
;
2421 int index_fd
= repo_hold_locked_index(r
, &index_lock
, 0);
2422 if (repo_read_index(r
) < 0) {
2423 rollback_lock_file(&index_lock
);
2424 return error(_("git %s: failed to read the index"),
2427 refresh_index(r
->index
, REFRESH_QUIET
|REFRESH_UNMERGED
, NULL
, NULL
, NULL
);
2429 if (index_fd
>= 0) {
2430 if (write_locked_index(r
->index
, &index_lock
,
2431 COMMIT_LOCK
| SKIP_IF_UNCHANGED
)) {
2432 return error(_("git %s: failed to refresh the index"),
2438 * If we are resolving merges in any way other than "ort", then
2439 * expand the sparse index.
2441 if (opts
->strategy
&& strcmp(opts
->strategy
, "ort"))
2442 ensure_full_index(r
->index
);
2446 void todo_list_release(struct todo_list
*todo_list
)
2448 strbuf_release(&todo_list
->buf
);
2449 FREE_AND_NULL(todo_list
->items
);
2450 todo_list
->nr
= todo_list
->alloc
= 0;
2453 static struct todo_item
*append_new_todo(struct todo_list
*todo_list
)
2455 ALLOC_GROW(todo_list
->items
, todo_list
->nr
+ 1, todo_list
->alloc
);
2456 todo_list
->total_nr
++;
2457 return todo_list
->items
+ todo_list
->nr
++;
2460 const char *todo_item_get_arg(struct todo_list
*todo_list
,
2461 struct todo_item
*item
)
2463 return todo_list
->buf
.buf
+ item
->arg_offset
;
2466 static int is_command(enum todo_command command
, const char **bol
)
2468 const char *str
= todo_command_info
[command
].str
;
2469 const char nick
= todo_command_info
[command
].c
;
2470 const char *p
= *bol
+ 1;
2472 return skip_prefix(*bol
, str
, bol
) ||
2473 ((nick
&& **bol
== nick
) &&
2474 (*p
== ' ' || *p
== '\t' || *p
== '\n' || *p
== '\r' || !*p
) &&
2478 static int parse_insn_line(struct repository
*r
, struct todo_item
*item
,
2479 const char *buf
, const char *bol
, char *eol
)
2481 struct object_id commit_oid
;
2482 char *end_of_object_name
;
2483 int i
, saved
, status
, padding
;
2488 bol
+= strspn(bol
, " \t");
2490 if (bol
== eol
|| *bol
== '\r' || *bol
== comment_line_char
) {
2491 item
->command
= TODO_COMMENT
;
2492 item
->commit
= NULL
;
2493 item
->arg_offset
= bol
- buf
;
2494 item
->arg_len
= eol
- bol
;
2498 for (i
= 0; i
< TODO_COMMENT
; i
++)
2499 if (is_command(i
, &bol
)) {
2503 if (i
>= TODO_COMMENT
)
2506 /* Eat up extra spaces/ tabs before object name */
2507 padding
= strspn(bol
, " \t");
2510 if (item
->command
== TODO_NOOP
|| item
->command
== TODO_BREAK
) {
2512 return error(_("%s does not accept arguments: '%s'"),
2513 command_to_string(item
->command
), bol
);
2514 item
->commit
= NULL
;
2515 item
->arg_offset
= bol
- buf
;
2516 item
->arg_len
= eol
- bol
;
2521 return error(_("missing arguments for %s"),
2522 command_to_string(item
->command
));
2524 if (item
->command
== TODO_EXEC
|| item
->command
== TODO_LABEL
||
2525 item
->command
== TODO_RESET
|| item
->command
== TODO_UPDATE_REF
) {
2526 item
->commit
= NULL
;
2527 item
->arg_offset
= bol
- buf
;
2528 item
->arg_len
= (int)(eol
- bol
);
2532 if (item
->command
== TODO_FIXUP
) {
2533 if (skip_prefix(bol
, "-C", &bol
) &&
2534 (*bol
== ' ' || *bol
== '\t')) {
2535 bol
+= strspn(bol
, " \t");
2536 item
->flags
|= TODO_REPLACE_FIXUP_MSG
;
2537 } else if (skip_prefix(bol
, "-c", &bol
) &&
2538 (*bol
== ' ' || *bol
== '\t')) {
2539 bol
+= strspn(bol
, " \t");
2540 item
->flags
|= TODO_EDIT_FIXUP_MSG
;
2544 if (item
->command
== TODO_MERGE
) {
2545 if (skip_prefix(bol
, "-C", &bol
))
2546 bol
+= strspn(bol
, " \t");
2547 else if (skip_prefix(bol
, "-c", &bol
)) {
2548 bol
+= strspn(bol
, " \t");
2549 item
->flags
|= TODO_EDIT_MERGE_MSG
;
2551 item
->flags
|= TODO_EDIT_MERGE_MSG
;
2552 item
->commit
= NULL
;
2553 item
->arg_offset
= bol
- buf
;
2554 item
->arg_len
= (int)(eol
- bol
);
2559 end_of_object_name
= (char *) bol
+ strcspn(bol
, " \t\n");
2560 saved
= *end_of_object_name
;
2561 *end_of_object_name
= '\0';
2562 status
= get_oid(bol
, &commit_oid
);
2564 error(_("could not parse '%s'"), bol
); /* return later */
2565 *end_of_object_name
= saved
;
2567 bol
= end_of_object_name
+ strspn(end_of_object_name
, " \t");
2568 item
->arg_offset
= bol
- buf
;
2569 item
->arg_len
= (int)(eol
- bol
);
2574 item
->commit
= lookup_commit_reference(r
, &commit_oid
);
2575 return item
->commit
? 0 : -1;
2578 int sequencer_get_last_command(struct repository
*r
, enum replay_action
*action
)
2580 const char *todo_file
, *bol
;
2581 struct strbuf buf
= STRBUF_INIT
;
2584 todo_file
= git_path_todo_file();
2585 if (strbuf_read_file(&buf
, todo_file
, 0) < 0) {
2586 if (errno
== ENOENT
|| errno
== ENOTDIR
)
2589 return error_errno("unable to open '%s'", todo_file
);
2591 bol
= buf
.buf
+ strspn(buf
.buf
, " \t\r\n");
2592 if (is_command(TODO_PICK
, &bol
) && (*bol
== ' ' || *bol
== '\t'))
2593 *action
= REPLAY_PICK
;
2594 else if (is_command(TODO_REVERT
, &bol
) &&
2595 (*bol
== ' ' || *bol
== '\t'))
2596 *action
= REPLAY_REVERT
;
2600 strbuf_release(&buf
);
2605 int todo_list_parse_insn_buffer(struct repository
*r
, char *buf
,
2606 struct todo_list
*todo_list
)
2608 struct todo_item
*item
;
2609 char *p
= buf
, *next_p
;
2610 int i
, res
= 0, fixup_okay
= file_exists(rebase_path_done());
2612 todo_list
->current
= todo_list
->nr
= 0;
2614 for (i
= 1; *p
; i
++, p
= next_p
) {
2615 char *eol
= strchrnul(p
, '\n');
2617 next_p
= *eol
? eol
+ 1 /* skip LF */ : eol
;
2619 if (p
!= eol
&& eol
[-1] == '\r')
2620 eol
--; /* strip Carriage Return */
2622 item
= append_new_todo(todo_list
);
2623 item
->offset_in_buf
= p
- todo_list
->buf
.buf
;
2624 if (parse_insn_line(r
, item
, buf
, p
, eol
)) {
2625 res
= error(_("invalid line %d: %.*s"),
2626 i
, (int)(eol
- p
), p
);
2627 item
->command
= TODO_COMMENT
+ 1;
2628 item
->arg_offset
= p
- buf
;
2629 item
->arg_len
= (int)(eol
- p
);
2630 item
->commit
= NULL
;
2635 else if (is_fixup(item
->command
))
2636 return error(_("cannot '%s' without a previous commit"),
2637 command_to_string(item
->command
));
2638 else if (!is_noop(item
->command
))
2645 static int count_commands(struct todo_list
*todo_list
)
2649 for (i
= 0; i
< todo_list
->nr
; i
++)
2650 if (todo_list
->items
[i
].command
!= TODO_COMMENT
)
2656 static int get_item_line_offset(struct todo_list
*todo_list
, int index
)
2658 return index
< todo_list
->nr
?
2659 todo_list
->items
[index
].offset_in_buf
: todo_list
->buf
.len
;
2662 static const char *get_item_line(struct todo_list
*todo_list
, int index
)
2664 return todo_list
->buf
.buf
+ get_item_line_offset(todo_list
, index
);
2667 static int get_item_line_length(struct todo_list
*todo_list
, int index
)
2669 return get_item_line_offset(todo_list
, index
+ 1)
2670 - get_item_line_offset(todo_list
, index
);
2673 static ssize_t
strbuf_read_file_or_whine(struct strbuf
*sb
, const char *path
)
2678 fd
= open(path
, O_RDONLY
);
2680 return error_errno(_("could not open '%s'"), path
);
2681 len
= strbuf_read(sb
, fd
, 0);
2684 return error(_("could not read '%s'."), path
);
2688 static int have_finished_the_last_pick(void)
2690 struct strbuf buf
= STRBUF_INIT
;
2692 const char *todo_path
= git_path_todo_file();
2695 if (strbuf_read_file(&buf
, todo_path
, 0) < 0) {
2696 if (errno
== ENOENT
) {
2699 error_errno("unable to open '%s'", todo_path
);
2703 /* If there is only one line then we are done */
2704 eol
= strchr(buf
.buf
, '\n');
2705 if (!eol
|| !eol
[1])
2708 strbuf_release(&buf
);
2713 void sequencer_post_commit_cleanup(struct repository
*r
, int verbose
)
2715 struct replay_opts opts
= REPLAY_OPTS_INIT
;
2716 int need_cleanup
= 0;
2718 if (refs_ref_exists(get_main_ref_store(r
), "CHERRY_PICK_HEAD")) {
2719 if (!refs_delete_ref(get_main_ref_store(r
), "",
2720 "CHERRY_PICK_HEAD", NULL
, 0) &&
2722 warning(_("cancelling a cherry picking in progress"));
2723 opts
.action
= REPLAY_PICK
;
2727 if (refs_ref_exists(get_main_ref_store(r
), "REVERT_HEAD")) {
2728 if (!refs_delete_ref(get_main_ref_store(r
), "", "REVERT_HEAD",
2731 warning(_("cancelling a revert in progress"));
2732 opts
.action
= REPLAY_REVERT
;
2736 unlink(git_path_auto_merge(r
));
2741 if (!have_finished_the_last_pick())
2744 sequencer_remove_state(&opts
);
2747 static void todo_list_write_total_nr(struct todo_list
*todo_list
)
2749 FILE *f
= fopen_or_warn(rebase_path_msgtotal(), "w");
2752 fprintf(f
, "%d\n", todo_list
->total_nr
);
2757 static int read_populate_todo(struct repository
*r
,
2758 struct todo_list
*todo_list
,
2759 struct replay_opts
*opts
)
2761 const char *todo_file
= get_todo_path(opts
);
2764 strbuf_reset(&todo_list
->buf
);
2765 if (strbuf_read_file_or_whine(&todo_list
->buf
, todo_file
) < 0)
2768 res
= todo_list_parse_insn_buffer(r
, todo_list
->buf
.buf
, todo_list
);
2770 if (is_rebase_i(opts
))
2771 return error(_("please fix this using "
2772 "'git rebase --edit-todo'."));
2773 return error(_("unusable instruction sheet: '%s'"), todo_file
);
2776 if (!todo_list
->nr
&&
2777 (!is_rebase_i(opts
) || !file_exists(rebase_path_done())))
2778 return error(_("no commits parsed."));
2780 if (!is_rebase_i(opts
)) {
2781 enum todo_command valid
=
2782 opts
->action
== REPLAY_PICK
? TODO_PICK
: TODO_REVERT
;
2785 for (i
= 0; i
< todo_list
->nr
; i
++)
2786 if (valid
== todo_list
->items
[i
].command
)
2788 else if (valid
== TODO_PICK
)
2789 return error(_("cannot cherry-pick during a revert."));
2791 return error(_("cannot revert during a cherry-pick."));
2794 if (is_rebase_i(opts
)) {
2795 struct todo_list done
= TODO_LIST_INIT
;
2797 if (strbuf_read_file(&done
.buf
, rebase_path_done(), 0) > 0 &&
2798 !todo_list_parse_insn_buffer(r
, done
.buf
.buf
, &done
))
2799 todo_list
->done_nr
= count_commands(&done
);
2801 todo_list
->done_nr
= 0;
2803 todo_list
->total_nr
= todo_list
->done_nr
2804 + count_commands(todo_list
);
2805 todo_list_release(&done
);
2807 todo_list_write_total_nr(todo_list
);
2813 static int git_config_string_dup(char **dest
,
2814 const char *var
, const char *value
)
2817 return config_error_nonbool(var
);
2819 *dest
= xstrdup(value
);
2823 static int populate_opts_cb(const char *key
, const char *value
, void *data
)
2825 struct replay_opts
*opts
= data
;
2830 else if (!strcmp(key
, "options.no-commit"))
2831 opts
->no_commit
= git_config_bool_or_int(key
, value
, &error_flag
);
2832 else if (!strcmp(key
, "options.edit"))
2833 opts
->edit
= git_config_bool_or_int(key
, value
, &error_flag
);
2834 else if (!strcmp(key
, "options.allow-empty"))
2836 git_config_bool_or_int(key
, value
, &error_flag
);
2837 else if (!strcmp(key
, "options.allow-empty-message"))
2838 opts
->allow_empty_message
=
2839 git_config_bool_or_int(key
, value
, &error_flag
);
2840 else if (!strcmp(key
, "options.keep-redundant-commits"))
2841 opts
->keep_redundant_commits
=
2842 git_config_bool_or_int(key
, value
, &error_flag
);
2843 else if (!strcmp(key
, "options.signoff"))
2844 opts
->signoff
= git_config_bool_or_int(key
, value
, &error_flag
);
2845 else if (!strcmp(key
, "options.record-origin"))
2846 opts
->record_origin
= git_config_bool_or_int(key
, value
, &error_flag
);
2847 else if (!strcmp(key
, "options.allow-ff"))
2848 opts
->allow_ff
= git_config_bool_or_int(key
, value
, &error_flag
);
2849 else if (!strcmp(key
, "options.mainline"))
2850 opts
->mainline
= git_config_int(key
, value
);
2851 else if (!strcmp(key
, "options.strategy"))
2852 git_config_string_dup(&opts
->strategy
, key
, value
);
2853 else if (!strcmp(key
, "options.gpg-sign"))
2854 git_config_string_dup(&opts
->gpg_sign
, key
, value
);
2855 else if (!strcmp(key
, "options.strategy-option")) {
2856 ALLOC_GROW(opts
->xopts
, opts
->xopts_nr
+ 1, opts
->xopts_alloc
);
2857 opts
->xopts
[opts
->xopts_nr
++] = xstrdup(value
);
2858 } else if (!strcmp(key
, "options.allow-rerere-auto"))
2859 opts
->allow_rerere_auto
=
2860 git_config_bool_or_int(key
, value
, &error_flag
) ?
2861 RERERE_AUTOUPDATE
: RERERE_NOAUTOUPDATE
;
2862 else if (!strcmp(key
, "options.default-msg-cleanup")) {
2863 opts
->explicit_cleanup
= 1;
2864 opts
->default_msg_cleanup
= get_cleanup_mode(value
, 1);
2866 return error(_("invalid key: %s"), key
);
2869 return error(_("invalid value for '%s': '%s'"), key
, value
);
2874 void parse_strategy_opts(struct replay_opts
*opts
, char *raw_opts
)
2877 char *strategy_opts_string
= raw_opts
;
2879 if (*strategy_opts_string
== ' ')
2880 strategy_opts_string
++;
2882 opts
->xopts_nr
= split_cmdline(strategy_opts_string
,
2883 (const char ***)&opts
->xopts
);
2884 for (i
= 0; i
< opts
->xopts_nr
; i
++) {
2885 const char *arg
= opts
->xopts
[i
];
2887 skip_prefix(arg
, "--", &arg
);
2888 opts
->xopts
[i
] = xstrdup(arg
);
2892 static void read_strategy_opts(struct replay_opts
*opts
, struct strbuf
*buf
)
2895 if (!read_oneliner(buf
, rebase_path_strategy(), 0))
2897 opts
->strategy
= strbuf_detach(buf
, NULL
);
2898 if (!read_oneliner(buf
, rebase_path_strategy_opts(), 0))
2901 parse_strategy_opts(opts
, buf
->buf
);
2904 static int read_populate_opts(struct replay_opts
*opts
)
2906 if (is_rebase_i(opts
)) {
2907 struct strbuf buf
= STRBUF_INIT
;
2910 if (read_oneliner(&buf
, rebase_path_gpg_sign_opt(),
2911 READ_ONELINER_SKIP_IF_EMPTY
)) {
2912 if (!starts_with(buf
.buf
, "-S"))
2915 free(opts
->gpg_sign
);
2916 opts
->gpg_sign
= xstrdup(buf
.buf
+ 2);
2921 if (read_oneliner(&buf
, rebase_path_allow_rerere_autoupdate(),
2922 READ_ONELINER_SKIP_IF_EMPTY
)) {
2923 if (!strcmp(buf
.buf
, "--rerere-autoupdate"))
2924 opts
->allow_rerere_auto
= RERERE_AUTOUPDATE
;
2925 else if (!strcmp(buf
.buf
, "--no-rerere-autoupdate"))
2926 opts
->allow_rerere_auto
= RERERE_NOAUTOUPDATE
;
2930 if (file_exists(rebase_path_verbose()))
2933 if (file_exists(rebase_path_quiet()))
2936 if (file_exists(rebase_path_signoff())) {
2941 if (file_exists(rebase_path_cdate_is_adate())) {
2943 opts
->committer_date_is_author_date
= 1;
2946 if (file_exists(rebase_path_ignore_date())) {
2948 opts
->ignore_date
= 1;
2951 if (file_exists(rebase_path_reschedule_failed_exec()))
2952 opts
->reschedule_failed_exec
= 1;
2953 else if (file_exists(rebase_path_no_reschedule_failed_exec()))
2954 opts
->reschedule_failed_exec
= 0;
2956 if (file_exists(rebase_path_drop_redundant_commits()))
2957 opts
->drop_redundant_commits
= 1;
2959 if (file_exists(rebase_path_keep_redundant_commits()))
2960 opts
->keep_redundant_commits
= 1;
2962 read_strategy_opts(opts
, &buf
);
2965 if (read_oneliner(&opts
->current_fixups
,
2966 rebase_path_current_fixups(),
2967 READ_ONELINER_SKIP_IF_EMPTY
)) {
2968 const char *p
= opts
->current_fixups
.buf
;
2969 opts
->current_fixup_count
= 1;
2970 while ((p
= strchr(p
, '\n'))) {
2971 opts
->current_fixup_count
++;
2976 if (read_oneliner(&buf
, rebase_path_squash_onto(), 0)) {
2977 if (get_oid_committish(buf
.buf
, &opts
->squash_onto
) < 0) {
2978 ret
= error(_("unusable squash-onto"));
2981 opts
->have_squash_onto
= 1;
2985 strbuf_release(&buf
);
2989 if (!file_exists(git_path_opts_file()))
2992 * The function git_parse_source(), called from git_config_from_file(),
2993 * may die() in case of a syntactically incorrect file. We do not care
2994 * about this case, though, because we wrote that file ourselves, so we
2995 * are pretty certain that it is syntactically correct.
2997 if (git_config_from_file(populate_opts_cb
, git_path_opts_file(), opts
) < 0)
2998 return error(_("malformed options sheet: '%s'"),
2999 git_path_opts_file());
3003 static void write_strategy_opts(struct replay_opts
*opts
)
3006 struct strbuf buf
= STRBUF_INIT
;
3008 for (i
= 0; i
< opts
->xopts_nr
; ++i
)
3009 strbuf_addf(&buf
, " --%s", opts
->xopts
[i
]);
3011 write_file(rebase_path_strategy_opts(), "%s\n", buf
.buf
);
3012 strbuf_release(&buf
);
3015 int write_basic_state(struct replay_opts
*opts
, const char *head_name
,
3016 struct commit
*onto
, const struct object_id
*orig_head
)
3019 write_file(rebase_path_head_name(), "%s\n", head_name
);
3021 write_file(rebase_path_onto(), "%s\n",
3022 oid_to_hex(&onto
->object
.oid
));
3024 write_file(rebase_path_orig_head(), "%s\n",
3025 oid_to_hex(orig_head
));
3028 write_file(rebase_path_quiet(), "%s", "");
3030 write_file(rebase_path_verbose(), "%s", "");
3032 write_file(rebase_path_strategy(), "%s\n", opts
->strategy
);
3033 if (opts
->xopts_nr
> 0)
3034 write_strategy_opts(opts
);
3036 if (opts
->allow_rerere_auto
== RERERE_AUTOUPDATE
)
3037 write_file(rebase_path_allow_rerere_autoupdate(), "--rerere-autoupdate\n");
3038 else if (opts
->allow_rerere_auto
== RERERE_NOAUTOUPDATE
)
3039 write_file(rebase_path_allow_rerere_autoupdate(), "--no-rerere-autoupdate\n");
3042 write_file(rebase_path_gpg_sign_opt(), "-S%s\n", opts
->gpg_sign
);
3044 write_file(rebase_path_signoff(), "--signoff\n");
3045 if (opts
->drop_redundant_commits
)
3046 write_file(rebase_path_drop_redundant_commits(), "%s", "");
3047 if (opts
->keep_redundant_commits
)
3048 write_file(rebase_path_keep_redundant_commits(), "%s", "");
3049 if (opts
->committer_date_is_author_date
)
3050 write_file(rebase_path_cdate_is_adate(), "%s", "");
3051 if (opts
->ignore_date
)
3052 write_file(rebase_path_ignore_date(), "%s", "");
3053 if (opts
->reschedule_failed_exec
)
3054 write_file(rebase_path_reschedule_failed_exec(), "%s", "");
3056 write_file(rebase_path_no_reschedule_failed_exec(), "%s", "");
3061 static int walk_revs_populate_todo(struct todo_list
*todo_list
,
3062 struct replay_opts
*opts
)
3064 enum todo_command command
= opts
->action
== REPLAY_PICK
?
3065 TODO_PICK
: TODO_REVERT
;
3066 const char *command_string
= todo_command_info
[command
].str
;
3067 const char *encoding
;
3068 struct commit
*commit
;
3070 if (prepare_revs(opts
))
3073 encoding
= get_log_output_encoding();
3075 while ((commit
= get_revision(opts
->revs
))) {
3076 struct todo_item
*item
= append_new_todo(todo_list
);
3077 const char *commit_buffer
= logmsg_reencode(commit
, NULL
, encoding
);
3078 const char *subject
;
3081 item
->command
= command
;
3082 item
->commit
= commit
;
3083 item
->arg_offset
= 0;
3085 item
->offset_in_buf
= todo_list
->buf
.len
;
3086 subject_len
= find_commit_subject(commit_buffer
, &subject
);
3087 strbuf_addf(&todo_list
->buf
, "%s %s %.*s\n", command_string
,
3088 short_commit_name(commit
), subject_len
, subject
);
3089 unuse_commit_buffer(commit
, commit_buffer
);
3093 return error(_("empty commit set passed"));
3098 static int create_seq_dir(struct repository
*r
)
3100 enum replay_action action
;
3101 const char *in_progress_error
= NULL
;
3102 const char *in_progress_advice
= NULL
;
3103 unsigned int advise_skip
=
3104 refs_ref_exists(get_main_ref_store(r
), "REVERT_HEAD") ||
3105 refs_ref_exists(get_main_ref_store(r
), "CHERRY_PICK_HEAD");
3107 if (!sequencer_get_last_command(r
, &action
)) {
3110 in_progress_error
= _("revert is already in progress");
3111 in_progress_advice
=
3112 _("try \"git revert (--continue | %s--abort | --quit)\"");
3115 in_progress_error
= _("cherry-pick is already in progress");
3116 in_progress_advice
=
3117 _("try \"git cherry-pick (--continue | %s--abort | --quit)\"");
3120 BUG("unexpected action in create_seq_dir");
3123 if (in_progress_error
) {
3124 error("%s", in_progress_error
);
3125 if (advice_enabled(ADVICE_SEQUENCER_IN_USE
))
3126 advise(in_progress_advice
,
3127 advise_skip
? "--skip | " : "");
3130 if (mkdir(git_path_seq_dir(), 0777) < 0)
3131 return error_errno(_("could not create sequencer directory '%s'"),
3132 git_path_seq_dir());
3137 static int save_head(const char *head
)
3139 struct lock_file head_lock
= LOCK_INIT
;
3140 struct strbuf buf
= STRBUF_INIT
;
3144 fd
= hold_lock_file_for_update(&head_lock
, git_path_head_file(), 0);
3146 return error_errno(_("could not lock HEAD"));
3147 strbuf_addf(&buf
, "%s\n", head
);
3148 written
= write_in_full(fd
, buf
.buf
, buf
.len
);
3149 strbuf_release(&buf
);
3151 error_errno(_("could not write to '%s'"), git_path_head_file());
3152 rollback_lock_file(&head_lock
);
3155 if (commit_lock_file(&head_lock
) < 0)
3156 return error(_("failed to finalize '%s'"), git_path_head_file());
3160 static int rollback_is_safe(void)
3162 struct strbuf sb
= STRBUF_INIT
;
3163 struct object_id expected_head
, actual_head
;
3165 if (strbuf_read_file(&sb
, git_path_abort_safety_file(), 0) >= 0) {
3167 if (get_oid_hex(sb
.buf
, &expected_head
)) {
3168 strbuf_release(&sb
);
3169 die(_("could not parse %s"), git_path_abort_safety_file());
3171 strbuf_release(&sb
);
3173 else if (errno
== ENOENT
)
3174 oidclr(&expected_head
);
3176 die_errno(_("could not read '%s'"), git_path_abort_safety_file());
3178 if (get_oid("HEAD", &actual_head
))
3179 oidclr(&actual_head
);
3181 return oideq(&actual_head
, &expected_head
);
3184 static int reset_merge(const struct object_id
*oid
)
3186 struct child_process cmd
= CHILD_PROCESS_INIT
;
3189 strvec_pushl(&cmd
.args
, "reset", "--merge", NULL
);
3191 if (!is_null_oid(oid
))
3192 strvec_push(&cmd
.args
, oid_to_hex(oid
));
3194 return run_command(&cmd
);
3197 static int rollback_single_pick(struct repository
*r
)
3199 struct object_id head_oid
;
3201 if (!refs_ref_exists(get_main_ref_store(r
), "CHERRY_PICK_HEAD") &&
3202 !refs_ref_exists(get_main_ref_store(r
), "REVERT_HEAD"))
3203 return error(_("no cherry-pick or revert in progress"));
3204 if (read_ref_full("HEAD", 0, &head_oid
, NULL
))
3205 return error(_("cannot resolve HEAD"));
3206 if (is_null_oid(&head_oid
))
3207 return error(_("cannot abort from a branch yet to be born"));
3208 return reset_merge(&head_oid
);
3211 static int skip_single_pick(void)
3213 struct object_id head
;
3215 if (read_ref_full("HEAD", 0, &head
, NULL
))
3216 return error(_("cannot resolve HEAD"));
3217 return reset_merge(&head
);
3220 int sequencer_rollback(struct repository
*r
, struct replay_opts
*opts
)
3223 struct object_id oid
;
3224 struct strbuf buf
= STRBUF_INIT
;
3227 f
= fopen(git_path_head_file(), "r");
3228 if (!f
&& errno
== ENOENT
) {
3230 * There is no multiple-cherry-pick in progress.
3231 * If CHERRY_PICK_HEAD or REVERT_HEAD indicates
3232 * a single-cherry-pick in progress, abort that.
3234 return rollback_single_pick(r
);
3237 return error_errno(_("cannot open '%s'"), git_path_head_file());
3238 if (strbuf_getline_lf(&buf
, f
)) {
3239 error(_("cannot read '%s': %s"), git_path_head_file(),
3240 ferror(f
) ? strerror(errno
) : _("unexpected end of file"));
3245 if (parse_oid_hex(buf
.buf
, &oid
, &p
) || *p
!= '\0') {
3246 error(_("stored pre-cherry-pick HEAD file '%s' is corrupt"),
3247 git_path_head_file());
3250 if (is_null_oid(&oid
)) {
3251 error(_("cannot abort from a branch yet to be born"));
3255 if (!rollback_is_safe()) {
3256 /* Do not error, just do not rollback */
3257 warning(_("You seem to have moved HEAD. "
3258 "Not rewinding, check your HEAD!"));
3260 if (reset_merge(&oid
))
3262 strbuf_release(&buf
);
3263 return sequencer_remove_state(opts
);
3265 strbuf_release(&buf
);
3269 int sequencer_skip(struct repository
*r
, struct replay_opts
*opts
)
3271 enum replay_action action
= -1;
3272 sequencer_get_last_command(r
, &action
);
3275 * Check whether the subcommand requested to skip the commit is actually
3276 * in progress and that it's safe to skip the commit.
3278 * opts->action tells us which subcommand requested to skip the commit.
3279 * If the corresponding .git/<ACTION>_HEAD exists, we know that the
3280 * action is in progress and we can skip the commit.
3282 * Otherwise we check that the last instruction was related to the
3283 * particular subcommand we're trying to execute and barf if that's not
3286 * Finally we check that the rollback is "safe", i.e., has the HEAD
3287 * moved? In this case, it doesn't make sense to "reset the merge" and
3288 * "skip the commit" as the user already handled this by committing. But
3289 * we'd not want to barf here, instead give advice on how to proceed. We
3290 * only need to check that when .git/<ACTION>_HEAD doesn't exist because
3291 * it gets removed when the user commits, so if it still exists we're
3292 * sure the user can't have committed before.
3294 switch (opts
->action
) {
3296 if (!refs_ref_exists(get_main_ref_store(r
), "REVERT_HEAD")) {
3297 if (action
!= REPLAY_REVERT
)
3298 return error(_("no revert in progress"));
3299 if (!rollback_is_safe())
3304 if (!refs_ref_exists(get_main_ref_store(r
),
3305 "CHERRY_PICK_HEAD")) {
3306 if (action
!= REPLAY_PICK
)
3307 return error(_("no cherry-pick in progress"));
3308 if (!rollback_is_safe())
3313 BUG("unexpected action in sequencer_skip");
3316 if (skip_single_pick())
3317 return error(_("failed to skip the commit"));
3318 if (!is_directory(git_path_seq_dir()))
3321 return sequencer_continue(r
, opts
);
3324 error(_("there is nothing to skip"));
3326 if (advice_enabled(ADVICE_RESOLVE_CONFLICT
)) {
3327 advise(_("have you committed already?\n"
3328 "try \"git %s --continue\""),
3329 action
== REPLAY_REVERT
? "revert" : "cherry-pick");
3334 static int save_todo(struct todo_list
*todo_list
, struct replay_opts
*opts
)
3336 struct lock_file todo_lock
= LOCK_INIT
;
3337 const char *todo_path
= get_todo_path(opts
);
3338 int next
= todo_list
->current
, offset
, fd
;
3341 * rebase -i writes "git-rebase-todo" without the currently executing
3342 * command, appending it to "done" instead.
3344 if (is_rebase_i(opts
))
3347 fd
= hold_lock_file_for_update(&todo_lock
, todo_path
, 0);
3349 return error_errno(_("could not lock '%s'"), todo_path
);
3350 offset
= get_item_line_offset(todo_list
, next
);
3351 if (write_in_full(fd
, todo_list
->buf
.buf
+ offset
,
3352 todo_list
->buf
.len
- offset
) < 0)
3353 return error_errno(_("could not write to '%s'"), todo_path
);
3354 if (commit_lock_file(&todo_lock
) < 0)
3355 return error(_("failed to finalize '%s'"), todo_path
);
3357 if (is_rebase_i(opts
) && next
> 0) {
3358 const char *done
= rebase_path_done();
3359 int fd
= open(done
, O_CREAT
| O_WRONLY
| O_APPEND
, 0666);
3364 if (write_in_full(fd
, get_item_line(todo_list
, next
- 1),
3365 get_item_line_length(todo_list
, next
- 1))
3367 ret
= error_errno(_("could not write to '%s'"), done
);
3369 ret
= error_errno(_("failed to finalize '%s'"), done
);
3375 static int save_opts(struct replay_opts
*opts
)
3377 const char *opts_file
= git_path_opts_file();
3380 if (opts
->no_commit
)
3381 res
|= git_config_set_in_file_gently(opts_file
,
3382 "options.no-commit", "true");
3383 if (opts
->edit
>= 0)
3384 res
|= git_config_set_in_file_gently(opts_file
, "options.edit",
3385 opts
->edit
? "true" : "false");
3386 if (opts
->allow_empty
)
3387 res
|= git_config_set_in_file_gently(opts_file
,
3388 "options.allow-empty", "true");
3389 if (opts
->allow_empty_message
)
3390 res
|= git_config_set_in_file_gently(opts_file
,
3391 "options.allow-empty-message", "true");
3392 if (opts
->keep_redundant_commits
)
3393 res
|= git_config_set_in_file_gently(opts_file
,
3394 "options.keep-redundant-commits", "true");
3396 res
|= git_config_set_in_file_gently(opts_file
,
3397 "options.signoff", "true");
3398 if (opts
->record_origin
)
3399 res
|= git_config_set_in_file_gently(opts_file
,
3400 "options.record-origin", "true");
3402 res
|= git_config_set_in_file_gently(opts_file
,
3403 "options.allow-ff", "true");
3404 if (opts
->mainline
) {
3405 struct strbuf buf
= STRBUF_INIT
;
3406 strbuf_addf(&buf
, "%d", opts
->mainline
);
3407 res
|= git_config_set_in_file_gently(opts_file
,
3408 "options.mainline", buf
.buf
);
3409 strbuf_release(&buf
);
3412 res
|= git_config_set_in_file_gently(opts_file
,
3413 "options.strategy", opts
->strategy
);
3415 res
|= git_config_set_in_file_gently(opts_file
,
3416 "options.gpg-sign", opts
->gpg_sign
);
3419 for (i
= 0; i
< opts
->xopts_nr
; i
++)
3420 res
|= git_config_set_multivar_in_file_gently(opts_file
,
3421 "options.strategy-option",
3422 opts
->xopts
[i
], "^$", 0);
3424 if (opts
->allow_rerere_auto
)
3425 res
|= git_config_set_in_file_gently(opts_file
,
3426 "options.allow-rerere-auto",
3427 opts
->allow_rerere_auto
== RERERE_AUTOUPDATE
?
3430 if (opts
->explicit_cleanup
)
3431 res
|= git_config_set_in_file_gently(opts_file
,
3432 "options.default-msg-cleanup",
3433 describe_cleanup_mode(opts
->default_msg_cleanup
));
3437 static int make_patch(struct repository
*r
,
3438 struct commit
*commit
,
3439 struct replay_opts
*opts
)
3441 struct strbuf buf
= STRBUF_INIT
;
3442 struct rev_info log_tree_opt
;
3443 const char *subject
;
3444 char hex
[GIT_MAX_HEXSZ
+ 1];
3447 oid_to_hex_r(hex
, &commit
->object
.oid
);
3448 if (write_message(hex
, strlen(hex
), rebase_path_stopped_sha(), 1) < 0)
3450 res
|= write_rebase_head(&commit
->object
.oid
);
3452 strbuf_addf(&buf
, "%s/patch", get_dir(opts
));
3453 memset(&log_tree_opt
, 0, sizeof(log_tree_opt
));
3454 repo_init_revisions(r
, &log_tree_opt
, NULL
);
3455 log_tree_opt
.abbrev
= 0;
3456 log_tree_opt
.diff
= 1;
3457 log_tree_opt
.diffopt
.output_format
= DIFF_FORMAT_PATCH
;
3458 log_tree_opt
.disable_stdin
= 1;
3459 log_tree_opt
.no_commit_id
= 1;
3460 log_tree_opt
.diffopt
.file
= fopen(buf
.buf
, "w");
3461 log_tree_opt
.diffopt
.use_color
= GIT_COLOR_NEVER
;
3462 if (!log_tree_opt
.diffopt
.file
)
3463 res
|= error_errno(_("could not open '%s'"), buf
.buf
);
3465 res
|= log_tree_commit(&log_tree_opt
, commit
);
3466 fclose(log_tree_opt
.diffopt
.file
);
3470 strbuf_addf(&buf
, "%s/message", get_dir(opts
));
3471 if (!file_exists(buf
.buf
)) {
3472 const char *encoding
= get_commit_output_encoding();
3473 const char *commit_buffer
= logmsg_reencode(commit
, NULL
, encoding
);
3474 find_commit_subject(commit_buffer
, &subject
);
3475 res
|= write_message(subject
, strlen(subject
), buf
.buf
, 1);
3476 unuse_commit_buffer(commit
, commit_buffer
);
3478 strbuf_release(&buf
);
3479 release_revisions(&log_tree_opt
);
3484 static int intend_to_amend(void)
3486 struct object_id head
;
3489 if (get_oid("HEAD", &head
))
3490 return error(_("cannot read HEAD"));
3492 p
= oid_to_hex(&head
);
3493 return write_message(p
, strlen(p
), rebase_path_amend(), 1);
3496 static int error_with_patch(struct repository
*r
,
3497 struct commit
*commit
,
3498 const char *subject
, int subject_len
,
3499 struct replay_opts
*opts
,
3500 int exit_code
, int to_amend
)
3503 if (make_patch(r
, commit
, opts
))
3505 } else if (copy_file(rebase_path_message(),
3506 git_path_merge_msg(r
), 0666))
3507 return error(_("unable to copy '%s' to '%s'"),
3508 git_path_merge_msg(r
), rebase_path_message());
3511 if (intend_to_amend())
3515 _("You can amend the commit now, with\n"
3517 " git commit --amend %s\n"
3519 "Once you are satisfied with your changes, run\n"
3521 " git rebase --continue\n"),
3522 gpg_sign_opt_quoted(opts
));
3523 } else if (exit_code
) {
3525 fprintf_ln(stderr
, _("Could not apply %s... %.*s"),
3526 short_commit_name(commit
), subject_len
, subject
);
3529 * We don't have the hash of the parent so
3530 * just print the line from the todo file.
3532 fprintf_ln(stderr
, _("Could not merge %.*s"),
3533 subject_len
, subject
);
3539 static int error_failed_squash(struct repository
*r
,
3540 struct commit
*commit
,
3541 struct replay_opts
*opts
,
3543 const char *subject
)
3545 if (copy_file(rebase_path_message(), rebase_path_squash_msg(), 0666))
3546 return error(_("could not copy '%s' to '%s'"),
3547 rebase_path_squash_msg(), rebase_path_message());
3548 unlink(git_path_merge_msg(r
));
3549 if (copy_file(git_path_merge_msg(r
), rebase_path_message(), 0666))
3550 return error(_("could not copy '%s' to '%s'"),
3551 rebase_path_message(),
3552 git_path_merge_msg(r
));
3553 return error_with_patch(r
, commit
, subject
, subject_len
, opts
, 1, 0);
3556 static int do_exec(struct repository
*r
, const char *command_line
)
3558 struct child_process cmd
= CHILD_PROCESS_INIT
;
3561 fprintf(stderr
, _("Executing: %s\n"), command_line
);
3563 strvec_push(&cmd
.args
, command_line
);
3564 status
= run_command(&cmd
);
3566 /* force re-reading of the cache */
3567 if (discard_index(r
->index
) < 0 || repo_read_index(r
) < 0)
3568 return error(_("could not read index"));
3570 dirty
= require_clean_work_tree(r
, "rebase", NULL
, 1, 1);
3573 warning(_("execution failed: %s\n%s"
3574 "You can fix the problem, and then run\n"
3576 " git rebase --continue\n"
3579 dirty
? N_("and made changes to the index and/or the "
3580 "working tree\n") : "");
3582 /* command not found */
3585 warning(_("execution succeeded: %s\nbut "
3586 "left changes to the index and/or the working tree\n"
3587 "Commit or stash your changes, and then run\n"
3589 " git rebase --continue\n"
3590 "\n"), command_line
);
3597 __attribute__((format (printf
, 2, 3)))
3598 static int safe_append(const char *filename
, const char *fmt
, ...)
3601 struct lock_file lock
= LOCK_INIT
;
3602 int fd
= hold_lock_file_for_update(&lock
, filename
,
3603 LOCK_REPORT_ON_ERROR
);
3604 struct strbuf buf
= STRBUF_INIT
;
3609 if (strbuf_read_file(&buf
, filename
, 0) < 0 && errno
!= ENOENT
) {
3610 error_errno(_("could not read '%s'"), filename
);
3611 rollback_lock_file(&lock
);
3614 strbuf_complete(&buf
, '\n');
3616 strbuf_vaddf(&buf
, fmt
, ap
);
3619 if (write_in_full(fd
, buf
.buf
, buf
.len
) < 0) {
3620 error_errno(_("could not write to '%s'"), filename
);
3621 strbuf_release(&buf
);
3622 rollback_lock_file(&lock
);
3625 if (commit_lock_file(&lock
) < 0) {
3626 strbuf_release(&buf
);
3627 rollback_lock_file(&lock
);
3628 return error(_("failed to finalize '%s'"), filename
);
3631 strbuf_release(&buf
);
3635 static int do_label(struct repository
*r
, const char *name
, int len
)
3637 struct ref_store
*refs
= get_main_ref_store(r
);
3638 struct ref_transaction
*transaction
;
3639 struct strbuf ref_name
= STRBUF_INIT
, err
= STRBUF_INIT
;
3640 struct strbuf msg
= STRBUF_INIT
;
3642 struct object_id head_oid
;
3644 if (len
== 1 && *name
== '#')
3645 return error(_("illegal label name: '%.*s'"), len
, name
);
3647 strbuf_addf(&ref_name
, "refs/rewritten/%.*s", len
, name
);
3648 strbuf_addf(&msg
, "rebase (label) '%.*s'", len
, name
);
3650 transaction
= ref_store_transaction_begin(refs
, &err
);
3652 error("%s", err
.buf
);
3654 } else if (get_oid("HEAD", &head_oid
)) {
3655 error(_("could not read HEAD"));
3657 } else if (ref_transaction_update(transaction
, ref_name
.buf
, &head_oid
,
3658 NULL
, 0, msg
.buf
, &err
) < 0 ||
3659 ref_transaction_commit(transaction
, &err
)) {
3660 error("%s", err
.buf
);
3663 ref_transaction_free(transaction
);
3664 strbuf_release(&err
);
3665 strbuf_release(&msg
);
3668 ret
= safe_append(rebase_path_refs_to_delete(),
3669 "%s\n", ref_name
.buf
);
3670 strbuf_release(&ref_name
);
3675 __attribute__((format (printf
, 3, 4)))
3676 static const char *reflog_message(struct replay_opts
*opts
,
3677 const char *sub_action
, const char *fmt
, ...)
3680 static struct strbuf buf
= STRBUF_INIT
;
3681 char *reflog_action
= getenv(GIT_REFLOG_ACTION
);
3685 strbuf_addstr(&buf
, reflog_action
? reflog_action
: action_name(opts
));
3687 strbuf_addf(&buf
, " (%s)", sub_action
);
3689 strbuf_addstr(&buf
, ": ");
3690 strbuf_vaddf(&buf
, fmt
, ap
);
3697 static int do_reset(struct repository
*r
,
3698 const char *name
, int len
,
3699 struct replay_opts
*opts
)
3701 struct strbuf ref_name
= STRBUF_INIT
;
3702 struct object_id oid
;
3703 struct lock_file lock
= LOCK_INIT
;
3704 struct tree_desc desc
= { 0 };
3706 struct unpack_trees_options unpack_tree_opts
= { 0 };
3709 if (repo_hold_locked_index(r
, &lock
, LOCK_REPORT_ON_ERROR
) < 0)
3712 if (len
== 10 && !strncmp("[new root]", name
, len
)) {
3713 if (!opts
->have_squash_onto
) {
3715 if (commit_tree("", 0, the_hash_algo
->empty_tree
,
3716 NULL
, &opts
->squash_onto
,
3718 return error(_("writing fake root commit"));
3719 opts
->have_squash_onto
= 1;
3720 hex
= oid_to_hex(&opts
->squash_onto
);
3721 if (write_message(hex
, strlen(hex
),
3722 rebase_path_squash_onto(), 0))
3723 return error(_("writing squash-onto"));
3725 oidcpy(&oid
, &opts
->squash_onto
);
3729 /* Determine the length of the label */
3730 for (i
= 0; i
< len
; i
++)
3731 if (isspace(name
[i
]))
3735 strbuf_addf(&ref_name
, "refs/rewritten/%.*s", len
, name
);
3736 if (get_oid(ref_name
.buf
, &oid
) &&
3737 get_oid(ref_name
.buf
+ strlen("refs/rewritten/"), &oid
)) {
3738 ret
= error(_("could not read '%s'"), ref_name
.buf
);
3743 setup_unpack_trees_porcelain(&unpack_tree_opts
, "reset");
3744 unpack_tree_opts
.head_idx
= 1;
3745 unpack_tree_opts
.src_index
= r
->index
;
3746 unpack_tree_opts
.dst_index
= r
->index
;
3747 unpack_tree_opts
.fn
= oneway_merge
;
3748 unpack_tree_opts
.merge
= 1;
3749 unpack_tree_opts
.update
= 1;
3750 unpack_tree_opts
.preserve_ignored
= 0; /* FIXME: !overwrite_ignore */
3751 unpack_tree_opts
.skip_cache_tree_update
= 1;
3752 init_checkout_metadata(&unpack_tree_opts
.meta
, name
, &oid
, NULL
);
3754 if (repo_read_index_unmerged(r
)) {
3755 ret
= error_resolve_conflict(action_name(opts
));
3759 if (!fill_tree_descriptor(r
, &desc
, &oid
)) {
3760 ret
= error(_("failed to find tree of %s"), oid_to_hex(&oid
));
3764 if (unpack_trees(1, &desc
, &unpack_tree_opts
)) {
3769 tree
= parse_tree_indirect(&oid
);
3770 prime_cache_tree(r
, r
->index
, tree
);
3772 if (write_locked_index(r
->index
, &lock
, COMMIT_LOCK
) < 0)
3773 ret
= error(_("could not write index"));
3776 ret
= update_ref(reflog_message(opts
, "reset", "'%.*s'",
3777 len
, name
), "HEAD", &oid
,
3778 NULL
, 0, UPDATE_REFS_MSG_ON_ERR
);
3780 free((void *)desc
.buffer
);
3782 rollback_lock_file(&lock
);
3783 strbuf_release(&ref_name
);
3784 clear_unpack_trees_porcelain(&unpack_tree_opts
);
3788 static struct commit
*lookup_label(const char *label
, int len
,
3791 struct commit
*commit
;
3794 strbuf_addf(buf
, "refs/rewritten/%.*s", len
, label
);
3795 commit
= lookup_commit_reference_by_name(buf
->buf
);
3797 /* fall back to non-rewritten ref or commit */
3798 strbuf_splice(buf
, 0, strlen("refs/rewritten/"), "", 0);
3799 commit
= lookup_commit_reference_by_name(buf
->buf
);
3803 error(_("could not resolve '%s'"), buf
->buf
);
3808 static int do_merge(struct repository
*r
,
3809 struct commit
*commit
,
3810 const char *arg
, int arg_len
,
3811 int flags
, int *check_todo
, struct replay_opts
*opts
)
3813 int run_commit_flags
= 0;
3814 struct strbuf ref_name
= STRBUF_INIT
;
3815 struct commit
*head_commit
, *merge_commit
, *i
;
3816 struct commit_list
*bases
, *j
;
3817 struct commit_list
*to_merge
= NULL
, **tail
= &to_merge
;
3818 const char *strategy
= !opts
->xopts_nr
&&
3820 !strcmp(opts
->strategy
, "recursive") ||
3821 !strcmp(opts
->strategy
, "ort")) ?
3822 NULL
: opts
->strategy
;
3823 struct merge_options o
;
3824 int merge_arg_len
, oneline_offset
, can_fast_forward
, ret
, k
;
3825 static struct lock_file lock
;
3828 if (repo_hold_locked_index(r
, &lock
, LOCK_REPORT_ON_ERROR
) < 0) {
3833 head_commit
= lookup_commit_reference_by_name("HEAD");
3835 ret
= error(_("cannot merge without a current revision"));
3840 * For octopus merges, the arg starts with the list of revisions to be
3841 * merged. The list is optionally followed by '#' and the oneline.
3843 merge_arg_len
= oneline_offset
= arg_len
;
3844 for (p
= arg
; p
- arg
< arg_len
; p
+= strspn(p
, " \t\n")) {
3847 if (*p
== '#' && (!p
[1] || isspace(p
[1]))) {
3848 p
+= 1 + strspn(p
+ 1, " \t\n");
3849 oneline_offset
= p
- arg
;
3852 k
= strcspn(p
, " \t\n");
3855 merge_commit
= lookup_label(p
, k
, &ref_name
);
3856 if (!merge_commit
) {
3857 ret
= error(_("unable to parse '%.*s'"), k
, p
);
3860 tail
= &commit_list_insert(merge_commit
, tail
)->next
;
3862 merge_arg_len
= p
- arg
;
3866 ret
= error(_("nothing to merge: '%.*s'"), arg_len
, arg
);
3870 if (opts
->have_squash_onto
&&
3871 oideq(&head_commit
->object
.oid
, &opts
->squash_onto
)) {
3873 * When the user tells us to "merge" something into a
3874 * "[new root]", let's simply fast-forward to the merge head.
3876 rollback_lock_file(&lock
);
3878 ret
= error(_("octopus merge cannot be executed on "
3879 "top of a [new root]"));
3881 ret
= fast_forward_to(r
, &to_merge
->item
->object
.oid
,
3882 &head_commit
->object
.oid
, 0,
3888 * If HEAD is not identical to the first parent of the original merge
3889 * commit, we cannot fast-forward.
3891 can_fast_forward
= opts
->allow_ff
&& commit
&& commit
->parents
&&
3892 oideq(&commit
->parents
->item
->object
.oid
,
3893 &head_commit
->object
.oid
);
3896 * If any merge head is different from the original one, we cannot
3899 if (can_fast_forward
) {
3900 struct commit_list
*p
= commit
->parents
->next
;
3902 for (j
= to_merge
; j
&& p
; j
= j
->next
, p
= p
->next
)
3903 if (!oideq(&j
->item
->object
.oid
,
3904 &p
->item
->object
.oid
)) {
3905 can_fast_forward
= 0;
3909 * If the number of merge heads differs from the original merge
3910 * commit, we cannot fast-forward.
3913 can_fast_forward
= 0;
3916 if (can_fast_forward
) {
3917 rollback_lock_file(&lock
);
3918 ret
= fast_forward_to(r
, &commit
->object
.oid
,
3919 &head_commit
->object
.oid
, 0, opts
);
3920 if (flags
& TODO_EDIT_MERGE_MSG
)
3921 goto fast_forward_edit
;
3927 const char *encoding
= get_commit_output_encoding();
3928 const char *message
= logmsg_reencode(commit
, NULL
, encoding
);
3933 ret
= error(_("could not get commit message of '%s'"),
3934 oid_to_hex(&commit
->object
.oid
));
3937 write_author_script(message
);
3938 find_commit_subject(message
, &body
);
3940 ret
= write_message(body
, len
, git_path_merge_msg(r
), 0);
3941 unuse_commit_buffer(commit
, message
);
3943 error_errno(_("could not write '%s'"),
3944 git_path_merge_msg(r
));
3948 struct strbuf buf
= STRBUF_INIT
;
3951 strbuf_addf(&buf
, "author %s", git_author_info(0));
3952 write_author_script(buf
.buf
);
3955 if (oneline_offset
< arg_len
) {
3956 p
= arg
+ oneline_offset
;
3957 len
= arg_len
- oneline_offset
;
3959 strbuf_addf(&buf
, "Merge %s '%.*s'",
3960 to_merge
->next
? "branches" : "branch",
3961 merge_arg_len
, arg
);
3966 ret
= write_message(p
, len
, git_path_merge_msg(r
), 0);
3967 strbuf_release(&buf
);
3969 error_errno(_("could not write '%s'"),
3970 git_path_merge_msg(r
));
3975 if (strategy
|| to_merge
->next
) {
3977 struct child_process cmd
= CHILD_PROCESS_INIT
;
3979 if (read_env_script(&cmd
.env
)) {
3980 const char *gpg_opt
= gpg_sign_opt_quoted(opts
);
3982 ret
= error(_(staged_changes_advice
), gpg_opt
, gpg_opt
);
3986 if (opts
->committer_date_is_author_date
)
3987 strvec_pushf(&cmd
.env
, "GIT_COMMITTER_DATE=%s",
3990 author_date_from_env(&cmd
.env
));
3991 if (opts
->ignore_date
)
3992 strvec_push(&cmd
.env
, "GIT_AUTHOR_DATE=");
3995 strvec_push(&cmd
.args
, "merge");
3996 strvec_push(&cmd
.args
, "-s");
3998 strvec_push(&cmd
.args
, "octopus");
4000 strvec_push(&cmd
.args
, strategy
);
4001 for (k
= 0; k
< opts
->xopts_nr
; k
++)
4002 strvec_pushf(&cmd
.args
,
4003 "-X%s", opts
->xopts
[k
]);
4005 if (!(flags
& TODO_EDIT_MERGE_MSG
))
4006 strvec_push(&cmd
.args
, "--no-edit");
4008 strvec_push(&cmd
.args
, "--edit");
4009 strvec_push(&cmd
.args
, "--no-ff");
4010 strvec_push(&cmd
.args
, "--no-log");
4011 strvec_push(&cmd
.args
, "--no-stat");
4012 strvec_push(&cmd
.args
, "-F");
4013 strvec_push(&cmd
.args
, git_path_merge_msg(r
));
4015 strvec_pushf(&cmd
.args
, "-S%s", opts
->gpg_sign
);
4017 strvec_push(&cmd
.args
, "--no-gpg-sign");
4019 /* Add the tips to be merged */
4020 for (j
= to_merge
; j
; j
= j
->next
)
4021 strvec_push(&cmd
.args
,
4022 oid_to_hex(&j
->item
->object
.oid
));
4024 strbuf_release(&ref_name
);
4025 refs_delete_ref(get_main_ref_store(r
), "", "CHERRY_PICK_HEAD",
4027 rollback_lock_file(&lock
);
4029 ret
= run_command(&cmd
);
4031 /* force re-reading of the cache */
4032 if (!ret
&& (discard_index(r
->index
) < 0 ||
4033 repo_read_index(r
) < 0))
4034 ret
= error(_("could not read index"));
4038 merge_commit
= to_merge
->item
;
4039 bases
= get_merge_bases(head_commit
, merge_commit
);
4040 if (bases
&& oideq(&merge_commit
->object
.oid
,
4041 &bases
->item
->object
.oid
)) {
4043 /* skip merging an ancestor of HEAD */
4047 write_message(oid_to_hex(&merge_commit
->object
.oid
), the_hash_algo
->hexsz
,
4048 git_path_merge_head(r
), 0);
4049 write_message("no-ff", 5, git_path_merge_mode(r
), 0);
4051 bases
= reverse_commit_list(bases
);
4054 init_merge_options(&o
, r
);
4056 o
.branch2
= ref_name
.buf
;
4057 o
.buffer_output
= 2;
4059 if (!opts
->strategy
|| !strcmp(opts
->strategy
, "ort")) {
4061 * TODO: Should use merge_incore_recursive() and
4062 * merge_switch_to_result(), skipping the call to
4063 * merge_switch_to_result() when we don't actually need to
4064 * update the index and working copy immediately.
4066 ret
= merge_ort_recursive(&o
,
4067 head_commit
, merge_commit
, bases
,
4070 ret
= merge_recursive(&o
, head_commit
, merge_commit
, bases
,
4074 fputs(o
.obuf
.buf
, stdout
);
4075 strbuf_release(&o
.obuf
);
4077 error(_("could not even attempt to merge '%.*s'"),
4078 merge_arg_len
, arg
);
4082 * The return value of merge_recursive() is 1 on clean, and 0 on
4085 * Let's reverse that, so that do_merge() returns 0 upon success and
4086 * 1 upon failed merge (keeping the return value -1 for the cases where
4087 * we will want to reschedule the `merge` command).
4091 if (r
->index
->cache_changed
&&
4092 write_locked_index(r
->index
, &lock
, COMMIT_LOCK
)) {
4093 ret
= error(_("merge: Unable to write new index file"));
4097 rollback_lock_file(&lock
);
4099 repo_rerere(r
, opts
->allow_rerere_auto
);
4102 * In case of problems, we now want to return a positive
4103 * value (a negative one would indicate that the `merge`
4104 * command needs to be rescheduled).
4106 ret
= !!run_git_commit(git_path_merge_msg(r
), opts
,
4109 if (!ret
&& flags
& TODO_EDIT_MERGE_MSG
) {
4112 run_commit_flags
|= AMEND_MSG
| EDIT_MSG
| VERIFY_MSG
;
4113 ret
= !!run_git_commit(NULL
, opts
, run_commit_flags
);
4118 strbuf_release(&ref_name
);
4119 rollback_lock_file(&lock
);
4120 free_commit_list(to_merge
);
4124 static int write_update_refs_state(struct string_list
*refs_to_oids
)
4127 struct lock_file lock
= LOCK_INIT
;
4129 struct string_list_item
*item
;
4132 if (!refs_to_oids
->nr
)
4135 path
= rebase_path_update_refs(the_repository
->gitdir
);
4137 if (safe_create_leading_directories(path
)) {
4138 result
= error(_("unable to create leading directories of %s"),
4143 if (hold_lock_file_for_update(&lock
, path
, 0) < 0) {
4144 result
= error(_("another 'rebase' process appears to be running; "
4145 "'%s.lock' already exists"),
4150 fp
= fdopen_lock_file(&lock
, "w");
4152 result
= error_errno(_("could not open '%s' for writing"), path
);
4153 rollback_lock_file(&lock
);
4157 for_each_string_list_item(item
, refs_to_oids
) {
4158 struct update_ref_record
*rec
= item
->util
;
4159 fprintf(fp
, "%s\n%s\n%s\n", item
->string
,
4160 oid_to_hex(&rec
->before
), oid_to_hex(&rec
->after
));
4163 result
= commit_lock_file(&lock
);
4171 * Parse the update-refs file for the current rebase, then remove the
4172 * refs that do not appear in the todo_list (and have not had updated
4173 * values stored) and add refs that are in the todo_list but not
4174 * represented in the update-refs file.
4176 * If there are changes to the update-refs list, then write the new state
4179 void todo_list_filter_update_refs(struct repository
*r
,
4180 struct todo_list
*todo_list
)
4184 struct string_list update_refs
= STRING_LIST_INIT_DUP
;
4186 sequencer_get_update_refs_state(r
->gitdir
, &update_refs
);
4189 * For each item in the update_refs list, if it has no updated
4190 * value and does not appear in the todo_list, then remove it
4191 * from the update_refs list.
4193 for (i
= 0; i
< update_refs
.nr
; i
++) {
4196 const char *ref
= update_refs
.items
[i
].string
;
4197 size_t reflen
= strlen(ref
);
4198 struct update_ref_record
*rec
= update_refs
.items
[i
].util
;
4200 /* OID already stored as updated. */
4201 if (!is_null_oid(&rec
->after
))
4204 for (j
= 0; !found
&& j
< todo_list
->total_nr
; j
++) {
4205 struct todo_item
*item
= &todo_list
->items
[j
];
4206 const char *arg
= todo_list
->buf
.buf
+ item
->arg_offset
;
4208 if (item
->command
!= TODO_UPDATE_REF
)
4211 if (item
->arg_len
!= reflen
||
4212 strncmp(arg
, ref
, reflen
))
4219 free(update_refs
.items
[i
].string
);
4220 free(update_refs
.items
[i
].util
);
4223 MOVE_ARRAY(update_refs
.items
+ i
, update_refs
.items
+ i
+ 1, update_refs
.nr
- i
);
4231 * For each todo_item, check if its ref is in the update_refs list.
4232 * If not, then add it as an un-updated ref.
4234 for (i
= 0; i
< todo_list
->total_nr
; i
++) {
4235 struct todo_item
*item
= &todo_list
->items
[i
];
4236 const char *arg
= todo_list
->buf
.buf
+ item
->arg_offset
;
4239 if (item
->command
!= TODO_UPDATE_REF
)
4242 for (j
= 0; !found
&& j
< update_refs
.nr
; j
++) {
4243 const char *ref
= update_refs
.items
[j
].string
;
4245 found
= strlen(ref
) == item
->arg_len
&&
4246 !strncmp(ref
, arg
, item
->arg_len
);
4250 struct string_list_item
*inserted
;
4251 struct strbuf argref
= STRBUF_INIT
;
4253 strbuf_add(&argref
, arg
, item
->arg_len
);
4254 inserted
= string_list_insert(&update_refs
, argref
.buf
);
4255 inserted
->util
= init_update_ref_record(argref
.buf
);
4256 strbuf_release(&argref
);
4262 write_update_refs_state(&update_refs
);
4263 string_list_clear(&update_refs
, 1);
4266 static int do_update_ref(struct repository
*r
, const char *refname
)
4268 struct string_list_item
*item
;
4269 struct string_list list
= STRING_LIST_INIT_DUP
;
4271 if (sequencer_get_update_refs_state(r
->gitdir
, &list
))
4274 for_each_string_list_item(item
, &list
) {
4275 if (!strcmp(item
->string
, refname
)) {
4276 struct update_ref_record
*rec
= item
->util
;
4277 if (read_ref("HEAD", &rec
->after
))
4283 write_update_refs_state(&list
);
4284 string_list_clear(&list
, 1);
4288 static int do_update_refs(struct repository
*r
, int quiet
)
4291 struct string_list_item
*item
;
4292 struct string_list refs_to_oids
= STRING_LIST_INIT_DUP
;
4293 struct ref_store
*refs
= get_main_ref_store(r
);
4294 struct strbuf update_msg
= STRBUF_INIT
;
4295 struct strbuf error_msg
= STRBUF_INIT
;
4297 if ((res
= sequencer_get_update_refs_state(r
->gitdir
, &refs_to_oids
)))
4300 for_each_string_list_item(item
, &refs_to_oids
) {
4301 struct update_ref_record
*rec
= item
->util
;
4304 loop_res
= refs_update_ref(refs
, "rewritten during rebase",
4306 &rec
->after
, &rec
->before
,
4307 0, UPDATE_REFS_MSG_ON_ERR
);
4314 strbuf_addf(&error_msg
, "\t%s\n", item
->string
);
4316 strbuf_addf(&update_msg
, "\t%s\n", item
->string
);
4320 (update_msg
.len
|| error_msg
.len
)) {
4322 _("Updated the following refs with %s:\n%s"),
4328 _("Failed to update the following refs with %s:\n%s"),
4333 string_list_clear(&refs_to_oids
, 1);
4334 strbuf_release(&update_msg
);
4335 strbuf_release(&error_msg
);
4339 static int is_final_fixup(struct todo_list
*todo_list
)
4341 int i
= todo_list
->current
;
4343 if (!is_fixup(todo_list
->items
[i
].command
))
4346 while (++i
< todo_list
->nr
)
4347 if (is_fixup(todo_list
->items
[i
].command
))
4349 else if (!is_noop(todo_list
->items
[i
].command
))
4354 static enum todo_command
peek_command(struct todo_list
*todo_list
, int offset
)
4358 for (i
= todo_list
->current
+ offset
; i
< todo_list
->nr
; i
++)
4359 if (!is_noop(todo_list
->items
[i
].command
))
4360 return todo_list
->items
[i
].command
;
4365 void create_autostash(struct repository
*r
, const char *path
)
4367 struct strbuf buf
= STRBUF_INIT
;
4368 struct lock_file lock_file
= LOCK_INIT
;
4371 fd
= repo_hold_locked_index(r
, &lock_file
, 0);
4372 refresh_index(r
->index
, REFRESH_QUIET
, NULL
, NULL
, NULL
);
4374 repo_update_index_if_able(r
, &lock_file
);
4375 rollback_lock_file(&lock_file
);
4377 if (has_unstaged_changes(r
, 1) ||
4378 has_uncommitted_changes(r
, 1)) {
4379 struct child_process stash
= CHILD_PROCESS_INIT
;
4380 struct reset_head_opts ropts
= { .flags
= RESET_HEAD_HARD
};
4381 struct object_id oid
;
4383 strvec_pushl(&stash
.args
,
4384 "stash", "create", "autostash", NULL
);
4388 if (capture_command(&stash
, &buf
, GIT_MAX_HEXSZ
))
4389 die(_("Cannot autostash"));
4390 strbuf_trim_trailing_newline(&buf
);
4391 if (get_oid(buf
.buf
, &oid
))
4392 die(_("Unexpected stash response: '%s'"),
4395 strbuf_add_unique_abbrev(&buf
, &oid
, DEFAULT_ABBREV
);
4397 if (safe_create_leading_directories_const(path
))
4398 die(_("Could not create directory for '%s'"),
4400 write_file(path
, "%s", oid_to_hex(&oid
));
4401 printf(_("Created autostash: %s\n"), buf
.buf
);
4402 if (reset_head(r
, &ropts
) < 0)
4403 die(_("could not reset --hard"));
4404 if (discard_index(r
->index
) < 0 ||
4405 repo_read_index(r
) < 0)
4406 die(_("could not read index"));
4408 strbuf_release(&buf
);
4411 static int apply_save_autostash_oid(const char *stash_oid
, int attempt_apply
)
4413 struct child_process child
= CHILD_PROCESS_INIT
;
4416 if (attempt_apply
) {
4418 child
.no_stdout
= 1;
4419 child
.no_stderr
= 1;
4420 strvec_push(&child
.args
, "stash");
4421 strvec_push(&child
.args
, "apply");
4422 strvec_push(&child
.args
, stash_oid
);
4423 ret
= run_command(&child
);
4426 if (attempt_apply
&& !ret
)
4427 fprintf(stderr
, _("Applied autostash.\n"));
4429 struct child_process store
= CHILD_PROCESS_INIT
;
4432 strvec_push(&store
.args
, "stash");
4433 strvec_push(&store
.args
, "store");
4434 strvec_push(&store
.args
, "-m");
4435 strvec_push(&store
.args
, "autostash");
4436 strvec_push(&store
.args
, "-q");
4437 strvec_push(&store
.args
, stash_oid
);
4438 if (run_command(&store
))
4439 ret
= error(_("cannot store %s"), stash_oid
);
4443 "Your changes are safe in the stash.\n"
4444 "You can run \"git stash pop\" or"
4445 " \"git stash drop\" at any time.\n"),
4447 _("Applying autostash resulted in conflicts.") :
4448 _("Autostash exists; creating a new stash entry."));
4454 static int apply_save_autostash(const char *path
, int attempt_apply
)
4456 struct strbuf stash_oid
= STRBUF_INIT
;
4459 if (!read_oneliner(&stash_oid
, path
,
4460 READ_ONELINER_SKIP_IF_EMPTY
)) {
4461 strbuf_release(&stash_oid
);
4464 strbuf_trim(&stash_oid
);
4466 ret
= apply_save_autostash_oid(stash_oid
.buf
, attempt_apply
);
4469 strbuf_release(&stash_oid
);
4473 int save_autostash(const char *path
)
4475 return apply_save_autostash(path
, 0);
4478 int apply_autostash(const char *path
)
4480 return apply_save_autostash(path
, 1);
4483 int apply_autostash_oid(const char *stash_oid
)
4485 return apply_save_autostash_oid(stash_oid
, 1);
4488 static int checkout_onto(struct repository
*r
, struct replay_opts
*opts
,
4489 const char *onto_name
, const struct object_id
*onto
,
4490 const struct object_id
*orig_head
)
4492 struct reset_head_opts ropts
= {
4494 .orig_head
= orig_head
,
4495 .flags
= RESET_HEAD_DETACH
| RESET_ORIG_HEAD
|
4496 RESET_HEAD_RUN_POST_CHECKOUT_HOOK
,
4497 .head_msg
= reflog_message(opts
, "start", "checkout %s",
4499 .default_reflog_action
= "rebase"
4501 if (reset_head(r
, &ropts
)) {
4502 apply_autostash(rebase_path_autostash());
4503 sequencer_remove_state(opts
);
4504 return error(_("could not detach HEAD"));
4510 static int stopped_at_head(struct repository
*r
)
4512 struct object_id head
;
4513 struct commit
*commit
;
4514 struct commit_message message
;
4516 if (get_oid("HEAD", &head
) ||
4517 !(commit
= lookup_commit(r
, &head
)) ||
4518 parse_commit(commit
) || get_message(commit
, &message
))
4519 fprintf(stderr
, _("Stopped at HEAD\n"));
4521 fprintf(stderr
, _("Stopped at %s\n"), message
.label
);
4522 free_message(commit
, &message
);
4528 static int reread_todo_if_changed(struct repository
*r
,
4529 struct todo_list
*todo_list
,
4530 struct replay_opts
*opts
)
4533 struct strbuf buf
= STRBUF_INIT
;
4535 if (strbuf_read_file_or_whine(&buf
, get_todo_path(opts
)) < 0)
4537 offset
= get_item_line_offset(todo_list
, todo_list
->current
+ 1);
4538 if (buf
.len
!= todo_list
->buf
.len
- offset
||
4539 memcmp(buf
.buf
, todo_list
->buf
.buf
+ offset
, buf
.len
)) {
4540 /* Reread the todo file if it has changed. */
4541 todo_list_release(todo_list
);
4542 if (read_populate_todo(r
, todo_list
, opts
))
4543 return -1; /* message was printed */
4544 /* `current` will be incremented on return */
4545 todo_list
->current
= -1;
4547 strbuf_release(&buf
);
4552 static const char rescheduled_advice
[] =
4553 N_("Could not execute the todo command\n"
4557 "It has been rescheduled; To edit the command before continuing, please\n"
4558 "edit the todo list first:\n"
4560 " git rebase --edit-todo\n"
4561 " git rebase --continue\n");
4563 static int pick_commits(struct repository
*r
,
4564 struct todo_list
*todo_list
,
4565 struct replay_opts
*opts
)
4567 int res
= 0, reschedule
= 0;
4568 char *prev_reflog_action
;
4570 /* Note that 0 for 3rd parameter of setenv means set only if not set */
4571 setenv(GIT_REFLOG_ACTION
, action_name(opts
), 0);
4572 prev_reflog_action
= xstrdup(getenv(GIT_REFLOG_ACTION
));
4574 assert(!(opts
->signoff
|| opts
->no_commit
||
4575 opts
->record_origin
|| should_edit(opts
) ||
4576 opts
->committer_date_is_author_date
||
4577 opts
->ignore_date
));
4578 if (read_and_refresh_cache(r
, opts
))
4581 while (todo_list
->current
< todo_list
->nr
) {
4582 struct todo_item
*item
= todo_list
->items
+ todo_list
->current
;
4583 const char *arg
= todo_item_get_arg(todo_list
, item
);
4586 if (save_todo(todo_list
, opts
))
4588 if (is_rebase_i(opts
)) {
4589 if (item
->command
!= TODO_COMMENT
) {
4590 FILE *f
= fopen(rebase_path_msgnum(), "w");
4592 todo_list
->done_nr
++;
4595 fprintf(f
, "%d\n", todo_list
->done_nr
);
4599 fprintf(stderr
, _("Rebasing (%d/%d)%s"),
4601 todo_list
->total_nr
,
4602 opts
->verbose
? "\n" : "\r");
4604 unlink(rebase_path_message());
4605 unlink(rebase_path_author_script());
4606 unlink(rebase_path_stopped_sha());
4607 unlink(rebase_path_amend());
4608 unlink(git_path_merge_head(r
));
4609 unlink(git_path_auto_merge(r
));
4610 delete_ref(NULL
, "REBASE_HEAD", NULL
, REF_NO_DEREF
);
4612 if (item
->command
== TODO_BREAK
) {
4615 return stopped_at_head(r
);
4618 if (item
->command
<= TODO_SQUASH
) {
4619 if (is_rebase_i(opts
))
4620 setenv(GIT_REFLOG_ACTION
, reflog_message(opts
,
4621 command_to_string(item
->command
), NULL
),
4623 res
= do_pick_commit(r
, item
, opts
,
4624 is_final_fixup(todo_list
),
4626 if (is_rebase_i(opts
))
4627 setenv(GIT_REFLOG_ACTION
, prev_reflog_action
, 1);
4628 if (is_rebase_i(opts
) && res
< 0) {
4630 advise(_(rescheduled_advice
),
4631 get_item_line_length(todo_list
,
4632 todo_list
->current
),
4633 get_item_line(todo_list
,
4634 todo_list
->current
));
4635 todo_list
->current
--;
4636 if (save_todo(todo_list
, opts
))
4639 if (item
->command
== TODO_EDIT
) {
4640 struct commit
*commit
= item
->commit
;
4645 _("Stopped at %s... %.*s\n"),
4646 short_commit_name(commit
),
4647 item
->arg_len
, arg
);
4649 return error_with_patch(r
, commit
,
4650 arg
, item
->arg_len
, opts
, res
, !res
);
4652 if (is_rebase_i(opts
) && !res
)
4653 record_in_rewritten(&item
->commit
->object
.oid
,
4654 peek_command(todo_list
, 1));
4655 if (res
&& is_fixup(item
->command
)) {
4658 return error_failed_squash(r
, item
->commit
, opts
,
4659 item
->arg_len
, arg
);
4660 } else if (res
&& is_rebase_i(opts
) && item
->commit
) {
4662 struct object_id oid
;
4665 * If we are rewording and have either
4666 * fast-forwarded already, or are about to
4667 * create a new root commit, we want to amend,
4668 * otherwise we do not.
4670 if (item
->command
== TODO_REWORD
&&
4671 !get_oid("HEAD", &oid
) &&
4672 (oideq(&item
->commit
->object
.oid
, &oid
) ||
4673 (opts
->have_squash_onto
&&
4674 oideq(&opts
->squash_onto
, &oid
))))
4677 return res
| error_with_patch(r
, item
->commit
,
4678 arg
, item
->arg_len
, opts
,
4681 } else if (item
->command
== TODO_EXEC
) {
4682 char *end_of_arg
= (char *)(arg
+ item
->arg_len
);
4683 int saved
= *end_of_arg
;
4688 res
= do_exec(r
, arg
);
4689 *end_of_arg
= saved
;
4692 if (opts
->reschedule_failed_exec
)
4696 } else if (item
->command
== TODO_LABEL
) {
4697 if ((res
= do_label(r
, arg
, item
->arg_len
)))
4699 } else if (item
->command
== TODO_RESET
) {
4700 if ((res
= do_reset(r
, arg
, item
->arg_len
, opts
)))
4702 } else if (item
->command
== TODO_MERGE
) {
4703 if ((res
= do_merge(r
, item
->commit
, arg
, item
->arg_len
,
4704 item
->flags
, &check_todo
, opts
)) < 0)
4706 else if (item
->commit
)
4707 record_in_rewritten(&item
->commit
->object
.oid
,
4708 peek_command(todo_list
, 1));
4710 /* failed with merge conflicts */
4711 return error_with_patch(r
, item
->commit
,
4714 } else if (item
->command
== TODO_UPDATE_REF
) {
4715 struct strbuf ref
= STRBUF_INIT
;
4716 strbuf_add(&ref
, arg
, item
->arg_len
);
4717 if ((res
= do_update_ref(r
, ref
.buf
)))
4719 strbuf_release(&ref
);
4720 } else if (!is_noop(item
->command
))
4721 return error(_("unknown command %d"), item
->command
);
4724 advise(_(rescheduled_advice
),
4725 get_item_line_length(todo_list
,
4726 todo_list
->current
),
4727 get_item_line(todo_list
, todo_list
->current
));
4728 todo_list
->current
--;
4729 if (save_todo(todo_list
, opts
))
4732 return error_with_patch(r
,
4736 } else if (is_rebase_i(opts
) && check_todo
&& !res
&&
4737 reread_todo_if_changed(r
, todo_list
, opts
)) {
4741 todo_list
->current
++;
4746 if (is_rebase_i(opts
)) {
4747 struct strbuf head_ref
= STRBUF_INIT
, buf
= STRBUF_INIT
;
4750 /* Stopped in the middle, as planned? */
4751 if (todo_list
->current
< todo_list
->nr
)
4754 if (read_oneliner(&head_ref
, rebase_path_head_name(), 0) &&
4755 starts_with(head_ref
.buf
, "refs/")) {
4757 struct object_id head
, orig
;
4760 if (get_oid("HEAD", &head
)) {
4761 res
= error(_("cannot read HEAD"));
4763 strbuf_release(&head_ref
);
4764 strbuf_release(&buf
);
4767 if (!read_oneliner(&buf
, rebase_path_orig_head(), 0) ||
4768 get_oid_hex(buf
.buf
, &orig
)) {
4769 res
= error(_("could not read orig-head"));
4770 goto cleanup_head_ref
;
4773 if (!read_oneliner(&buf
, rebase_path_onto(), 0)) {
4774 res
= error(_("could not read 'onto'"));
4775 goto cleanup_head_ref
;
4777 msg
= reflog_message(opts
, "finish", "%s onto %s",
4778 head_ref
.buf
, buf
.buf
);
4779 if (update_ref(msg
, head_ref
.buf
, &head
, &orig
,
4780 REF_NO_DEREF
, UPDATE_REFS_MSG_ON_ERR
)) {
4781 res
= error(_("could not update %s"),
4783 goto cleanup_head_ref
;
4785 msg
= reflog_message(opts
, "finish", "returning to %s",
4787 if (create_symref("HEAD", head_ref
.buf
, msg
)) {
4788 res
= error(_("could not update HEAD to %s"),
4790 goto cleanup_head_ref
;
4795 if (opts
->verbose
) {
4796 struct rev_info log_tree_opt
;
4797 struct object_id orig
, head
;
4799 memset(&log_tree_opt
, 0, sizeof(log_tree_opt
));
4800 repo_init_revisions(r
, &log_tree_opt
, NULL
);
4801 log_tree_opt
.diff
= 1;
4802 log_tree_opt
.diffopt
.output_format
=
4803 DIFF_FORMAT_DIFFSTAT
;
4804 log_tree_opt
.disable_stdin
= 1;
4806 if (read_oneliner(&buf
, rebase_path_orig_head(), 0) &&
4807 !get_oid(buf
.buf
, &orig
) &&
4808 !get_oid("HEAD", &head
)) {
4809 diff_tree_oid(&orig
, &head
, "",
4810 &log_tree_opt
.diffopt
);
4811 log_tree_diff_flush(&log_tree_opt
);
4813 release_revisions(&log_tree_opt
);
4815 flush_rewritten_pending();
4816 if (!stat(rebase_path_rewritten_list(), &st
) &&
4818 struct child_process child
= CHILD_PROCESS_INIT
;
4819 const char *post_rewrite_hook
=
4820 find_hook("post-rewrite");
4822 child
.in
= open(rebase_path_rewritten_list(), O_RDONLY
);
4824 strvec_push(&child
.args
, "notes");
4825 strvec_push(&child
.args
, "copy");
4826 strvec_push(&child
.args
, "--for-rewrite=rebase");
4827 /* we don't care if this copying failed */
4828 run_command(&child
);
4830 if (post_rewrite_hook
) {
4831 struct child_process hook
= CHILD_PROCESS_INIT
;
4833 hook
.in
= open(rebase_path_rewritten_list(),
4835 hook
.stdout_to_stderr
= 1;
4836 hook
.trace2_hook_name
= "post-rewrite";
4837 strvec_push(&hook
.args
, post_rewrite_hook
);
4838 strvec_push(&hook
.args
, "rebase");
4839 /* we don't care if this hook failed */
4843 apply_autostash(rebase_path_autostash());
4849 _("Successfully rebased and updated %s.\n"),
4853 strbuf_release(&buf
);
4854 strbuf_release(&head_ref
);
4856 if (do_update_refs(r
, opts
->quiet
))
4861 * Sequence of picks finished successfully; cleanup by
4862 * removing the .git/sequencer directory
4864 return sequencer_remove_state(opts
);
4867 static int continue_single_pick(struct repository
*r
, struct replay_opts
*opts
)
4869 struct child_process cmd
= CHILD_PROCESS_INIT
;
4871 if (!refs_ref_exists(get_main_ref_store(r
), "CHERRY_PICK_HEAD") &&
4872 !refs_ref_exists(get_main_ref_store(r
), "REVERT_HEAD"))
4873 return error(_("no cherry-pick or revert in progress"));
4876 strvec_push(&cmd
.args
, "commit");
4879 * continue_single_pick() handles the case of recovering from a
4880 * conflict. should_edit() doesn't handle that case; for a conflict,
4881 * we want to edit if the user asked for it, or if they didn't specify
4882 * and stdin is a tty.
4884 if (!opts
->edit
|| (opts
->edit
< 0 && !isatty(0)))
4886 * Include --cleanup=strip as well because we don't want the
4887 * "# Conflicts:" messages.
4889 strvec_pushl(&cmd
.args
, "--no-edit", "--cleanup=strip", NULL
);
4891 return run_command(&cmd
);
4894 static int commit_staged_changes(struct repository
*r
,
4895 struct replay_opts
*opts
,
4896 struct todo_list
*todo_list
)
4898 unsigned int flags
= ALLOW_EMPTY
| EDIT_MSG
;
4899 unsigned int final_fixup
= 0, is_clean
;
4901 if (has_unstaged_changes(r
, 1))
4902 return error(_("cannot rebase: You have unstaged changes."));
4904 is_clean
= !has_uncommitted_changes(r
, 0);
4906 if (file_exists(rebase_path_amend())) {
4907 struct strbuf rev
= STRBUF_INIT
;
4908 struct object_id head
, to_amend
;
4910 if (get_oid("HEAD", &head
))
4911 return error(_("cannot amend non-existing commit"));
4912 if (!read_oneliner(&rev
, rebase_path_amend(), 0))
4913 return error(_("invalid file: '%s'"), rebase_path_amend());
4914 if (get_oid_hex(rev
.buf
, &to_amend
))
4915 return error(_("invalid contents: '%s'"),
4916 rebase_path_amend());
4917 if (!is_clean
&& !oideq(&head
, &to_amend
))
4918 return error(_("\nYou have uncommitted changes in your "
4919 "working tree. Please, commit them\n"
4920 "first and then run 'git rebase "
4921 "--continue' again."));
4923 * When skipping a failed fixup/squash, we need to edit the
4924 * commit message, the current fixup list and count, and if it
4925 * was the last fixup/squash in the chain, we need to clean up
4926 * the commit message and if there was a squash, let the user
4929 if (!is_clean
|| !opts
->current_fixup_count
)
4930 ; /* this is not the final fixup */
4931 else if (!oideq(&head
, &to_amend
) ||
4932 !file_exists(rebase_path_stopped_sha())) {
4933 /* was a final fixup or squash done manually? */
4934 if (!is_fixup(peek_command(todo_list
, 0))) {
4935 unlink(rebase_path_fixup_msg());
4936 unlink(rebase_path_squash_msg());
4937 unlink(rebase_path_current_fixups());
4938 strbuf_reset(&opts
->current_fixups
);
4939 opts
->current_fixup_count
= 0;
4942 /* we are in a fixup/squash chain */
4943 const char *p
= opts
->current_fixups
.buf
;
4944 int len
= opts
->current_fixups
.len
;
4946 opts
->current_fixup_count
--;
4948 BUG("Incorrect current_fixups:\n%s", p
);
4949 while (len
&& p
[len
- 1] != '\n')
4951 strbuf_setlen(&opts
->current_fixups
, len
);
4952 if (write_message(p
, len
, rebase_path_current_fixups(),
4954 return error(_("could not write file: '%s'"),
4955 rebase_path_current_fixups());
4958 * If a fixup/squash in a fixup/squash chain failed, the
4959 * commit message is already correct, no need to commit
4962 * Only if it is the final command in the fixup/squash
4963 * chain, and only if the chain is longer than a single
4964 * fixup/squash command (which was just skipped), do we
4965 * actually need to re-commit with a cleaned up commit
4968 if (opts
->current_fixup_count
> 0 &&
4969 !is_fixup(peek_command(todo_list
, 0))) {
4972 * If there was not a single "squash" in the
4973 * chain, we only need to clean up the commit
4974 * message, no need to bother the user with
4975 * opening the commit message in the editor.
4977 if (!starts_with(p
, "squash ") &&
4978 !strstr(p
, "\nsquash "))
4979 flags
= (flags
& ~EDIT_MSG
) | CLEANUP_MSG
;
4980 } else if (is_fixup(peek_command(todo_list
, 0))) {
4982 * We need to update the squash message to skip
4983 * the latest commit message.
4985 struct commit
*commit
;
4986 const char *path
= rebase_path_squash_msg();
4987 const char *encoding
= get_commit_output_encoding();
4989 if (parse_head(r
, &commit
) ||
4990 !(p
= logmsg_reencode(commit
, NULL
, encoding
)) ||
4991 write_message(p
, strlen(p
), path
, 0)) {
4992 unuse_commit_buffer(commit
, p
);
4993 return error(_("could not write file: "
4996 unuse_commit_buffer(commit
, p
);
5000 strbuf_release(&rev
);
5005 if (refs_ref_exists(get_main_ref_store(r
),
5006 "CHERRY_PICK_HEAD") &&
5007 refs_delete_ref(get_main_ref_store(r
), "",
5008 "CHERRY_PICK_HEAD", NULL
, 0))
5009 return error(_("could not remove CHERRY_PICK_HEAD"));
5010 if (unlink(git_path_merge_msg(r
)) && errno
!= ENOENT
)
5011 return error_errno(_("could not remove '%s'"),
5012 git_path_merge_msg(r
));
5017 if (run_git_commit(final_fixup
? NULL
: rebase_path_message(),
5019 return error(_("could not commit staged changes."));
5020 unlink(rebase_path_amend());
5021 unlink(git_path_merge_head(r
));
5022 unlink(git_path_auto_merge(r
));
5024 unlink(rebase_path_fixup_msg());
5025 unlink(rebase_path_squash_msg());
5027 if (opts
->current_fixup_count
> 0) {
5029 * Whether final fixup or not, we just cleaned up the commit
5032 unlink(rebase_path_current_fixups());
5033 strbuf_reset(&opts
->current_fixups
);
5034 opts
->current_fixup_count
= 0;
5039 int sequencer_continue(struct repository
*r
, struct replay_opts
*opts
)
5041 struct todo_list todo_list
= TODO_LIST_INIT
;
5044 if (read_and_refresh_cache(r
, opts
))
5047 if (read_populate_opts(opts
))
5049 if (is_rebase_i(opts
)) {
5050 char *previous_reflog_action
;
5052 if ((res
= read_populate_todo(r
, &todo_list
, opts
)))
5053 goto release_todo_list
;
5055 if (file_exists(rebase_path_dropped())) {
5056 if ((res
= todo_list_check_against_backup(r
, &todo_list
)))
5057 goto release_todo_list
;
5059 unlink(rebase_path_dropped());
5062 previous_reflog_action
= xstrdup(getenv(GIT_REFLOG_ACTION
));
5063 setenv(GIT_REFLOG_ACTION
, reflog_message(opts
, "continue", NULL
), 1);
5064 if (commit_staged_changes(r
, opts
, &todo_list
)) {
5066 goto release_todo_list
;
5068 setenv(GIT_REFLOG_ACTION
, previous_reflog_action
, 1);
5069 } else if (!file_exists(get_todo_path(opts
)))
5070 return continue_single_pick(r
, opts
);
5071 else if ((res
= read_populate_todo(r
, &todo_list
, opts
)))
5072 goto release_todo_list
;
5074 if (!is_rebase_i(opts
)) {
5075 /* Verify that the conflict has been resolved */
5076 if (refs_ref_exists(get_main_ref_store(r
),
5077 "CHERRY_PICK_HEAD") ||
5078 refs_ref_exists(get_main_ref_store(r
), "REVERT_HEAD")) {
5079 res
= continue_single_pick(r
, opts
);
5081 goto release_todo_list
;
5083 if (index_differs_from(r
, "HEAD", NULL
, 0)) {
5084 res
= error_dirty_index(r
, opts
);
5085 goto release_todo_list
;
5087 todo_list
.current
++;
5088 } else if (file_exists(rebase_path_stopped_sha())) {
5089 struct strbuf buf
= STRBUF_INIT
;
5090 struct object_id oid
;
5092 if (read_oneliner(&buf
, rebase_path_stopped_sha(),
5093 READ_ONELINER_SKIP_IF_EMPTY
) &&
5094 !get_oid_hex(buf
.buf
, &oid
))
5095 record_in_rewritten(&oid
, peek_command(&todo_list
, 0));
5096 strbuf_release(&buf
);
5099 res
= pick_commits(r
, &todo_list
, opts
);
5101 todo_list_release(&todo_list
);
5105 static int single_pick(struct repository
*r
,
5106 struct commit
*cmit
,
5107 struct replay_opts
*opts
)
5110 struct todo_item item
;
5112 item
.command
= opts
->action
== REPLAY_PICK
?
5113 TODO_PICK
: TODO_REVERT
;
5116 setenv(GIT_REFLOG_ACTION
, action_name(opts
), 0);
5117 return do_pick_commit(r
, &item
, opts
, 0, &check_todo
);
5120 int sequencer_pick_revisions(struct repository
*r
,
5121 struct replay_opts
*opts
)
5123 struct todo_list todo_list
= TODO_LIST_INIT
;
5124 struct object_id oid
;
5128 if (read_and_refresh_cache(r
, opts
))
5131 for (i
= 0; i
< opts
->revs
->pending
.nr
; i
++) {
5132 struct object_id oid
;
5133 const char *name
= opts
->revs
->pending
.objects
[i
].name
;
5135 /* This happens when using --stdin. */
5139 if (!get_oid(name
, &oid
)) {
5140 if (!lookup_commit_reference_gently(r
, &oid
, 1)) {
5141 enum object_type type
= oid_object_info(r
,
5144 return error(_("%s: can't cherry-pick a %s"),
5145 name
, type_name(type
));
5148 return error(_("%s: bad revision"), name
);
5152 * If we were called as "git cherry-pick <commit>", just
5153 * cherry-pick/revert it, set CHERRY_PICK_HEAD /
5154 * REVERT_HEAD, and don't touch the sequencer state.
5155 * This means it is possible to cherry-pick in the middle
5156 * of a cherry-pick sequence.
5158 if (opts
->revs
->cmdline
.nr
== 1 &&
5159 opts
->revs
->cmdline
.rev
->whence
== REV_CMD_REV
&&
5160 opts
->revs
->no_walk
&&
5161 !opts
->revs
->cmdline
.rev
->flags
) {
5162 struct commit
*cmit
;
5163 if (prepare_revision_walk(opts
->revs
))
5164 return error(_("revision walk setup failed"));
5165 cmit
= get_revision(opts
->revs
);
5167 return error(_("empty commit set passed"));
5168 if (get_revision(opts
->revs
))
5169 BUG("unexpected extra commit from walk");
5170 return single_pick(r
, cmit
, opts
);
5174 * Start a new cherry-pick/ revert sequence; but
5175 * first, make sure that an existing one isn't in
5179 if (walk_revs_populate_todo(&todo_list
, opts
) ||
5180 create_seq_dir(r
) < 0)
5182 if (get_oid("HEAD", &oid
) && (opts
->action
== REPLAY_REVERT
))
5183 return error(_("can't revert as initial commit"));
5184 if (save_head(oid_to_hex(&oid
)))
5186 if (save_opts(opts
))
5188 update_abort_safety_file();
5189 res
= pick_commits(r
, &todo_list
, opts
);
5190 todo_list_release(&todo_list
);
5194 void append_signoff(struct strbuf
*msgbuf
, size_t ignore_footer
, unsigned flag
)
5196 unsigned no_dup_sob
= flag
& APPEND_SIGNOFF_DEDUP
;
5197 struct strbuf sob
= STRBUF_INIT
;
5200 strbuf_addstr(&sob
, sign_off_header
);
5201 strbuf_addstr(&sob
, fmt_name(WANT_COMMITTER_IDENT
));
5202 strbuf_addch(&sob
, '\n');
5205 strbuf_complete_line(msgbuf
);
5208 * If the whole message buffer is equal to the sob, pretend that we
5209 * found a conforming footer with a matching sob
5211 if (msgbuf
->len
- ignore_footer
== sob
.len
&&
5212 !strncmp(msgbuf
->buf
, sob
.buf
, sob
.len
))
5215 has_footer
= has_conforming_footer(msgbuf
, &sob
, ignore_footer
);
5218 const char *append_newlines
= NULL
;
5219 size_t len
= msgbuf
->len
- ignore_footer
;
5223 * The buffer is completely empty. Leave foom for
5224 * the title and body to be filled in by the user.
5226 append_newlines
= "\n\n";
5227 } else if (len
== 1) {
5229 * Buffer contains a single newline. Add another
5230 * so that we leave room for the title and body.
5232 append_newlines
= "\n";
5233 } else if (msgbuf
->buf
[len
- 2] != '\n') {
5235 * Buffer ends with a single newline. Add another
5236 * so that there is an empty line between the message
5239 append_newlines
= "\n";
5240 } /* else, the buffer already ends with two newlines. */
5242 if (append_newlines
)
5243 strbuf_splice(msgbuf
, msgbuf
->len
- ignore_footer
, 0,
5244 append_newlines
, strlen(append_newlines
));
5247 if (has_footer
!= 3 && (!no_dup_sob
|| has_footer
!= 2))
5248 strbuf_splice(msgbuf
, msgbuf
->len
- ignore_footer
, 0,
5251 strbuf_release(&sob
);
5254 struct labels_entry
{
5255 struct hashmap_entry entry
;
5256 char label
[FLEX_ARRAY
];
5259 static int labels_cmp(const void *fndata UNUSED
,
5260 const struct hashmap_entry
*eptr
,
5261 const struct hashmap_entry
*entry_or_key
, const void *key
)
5263 const struct labels_entry
*a
, *b
;
5265 a
= container_of(eptr
, const struct labels_entry
, entry
);
5266 b
= container_of(entry_or_key
, const struct labels_entry
, entry
);
5268 return key
? strcmp(a
->label
, key
) : strcmp(a
->label
, b
->label
);
5271 struct string_entry
{
5272 struct oidmap_entry entry
;
5273 char string
[FLEX_ARRAY
];
5276 struct label_state
{
5277 struct oidmap commit2label
;
5278 struct hashmap labels
;
5282 static const char *label_oid(struct object_id
*oid
, const char *label
,
5283 struct label_state
*state
)
5285 struct labels_entry
*labels_entry
;
5286 struct string_entry
*string_entry
;
5287 struct object_id dummy
;
5290 string_entry
= oidmap_get(&state
->commit2label
, oid
);
5292 return string_entry
->string
;
5295 * For "uninteresting" commits, i.e. commits that are not to be
5296 * rebased, and which can therefore not be labeled, we use a unique
5297 * abbreviation of the commit name. This is slightly more complicated
5298 * than calling find_unique_abbrev() because we also need to make
5299 * sure that the abbreviation does not conflict with any other
5302 * We disallow "interesting" commits to be labeled by a string that
5303 * is a valid full-length hash, to ensure that we always can find an
5304 * abbreviation for any uninteresting commit's names that does not
5305 * clash with any other label.
5307 strbuf_reset(&state
->buf
);
5311 strbuf_grow(&state
->buf
, GIT_MAX_HEXSZ
);
5312 label
= p
= state
->buf
.buf
;
5314 find_unique_abbrev_r(p
, oid
, default_abbrev
);
5317 * We may need to extend the abbreviated hash so that there is
5318 * no conflicting label.
5320 if (hashmap_get_from_hash(&state
->labels
, strihash(p
), p
)) {
5321 size_t i
= strlen(p
) + 1;
5323 oid_to_hex_r(p
, oid
);
5324 for (; i
< the_hash_algo
->hexsz
; i
++) {
5327 if (!hashmap_get_from_hash(&state
->labels
,
5334 struct strbuf
*buf
= &state
->buf
;
5337 * Sanitize labels by replacing non-alpha-numeric characters
5338 * (including white-space ones) by dashes, as they might be
5339 * illegal in file names (and hence in ref names).
5341 * Note that we retain non-ASCII UTF-8 characters (identified
5342 * via the most significant bit). They should be all acceptable
5343 * in file names. We do not validate the UTF-8 here, that's not
5344 * the job of this function.
5346 for (; *label
; label
++)
5347 if ((*label
& 0x80) || isalnum(*label
))
5348 strbuf_addch(buf
, *label
);
5349 /* avoid leading dash and double-dashes */
5350 else if (buf
->len
&& buf
->buf
[buf
->len
- 1] != '-')
5351 strbuf_addch(buf
, '-');
5353 strbuf_addstr(buf
, "rev-");
5354 strbuf_add_unique_abbrev(buf
, oid
, default_abbrev
);
5358 if ((buf
->len
== the_hash_algo
->hexsz
&&
5359 !get_oid_hex(label
, &dummy
)) ||
5360 (buf
->len
== 1 && *label
== '#') ||
5361 hashmap_get_from_hash(&state
->labels
,
5362 strihash(label
), label
)) {
5364 * If the label already exists, or if the label is a
5365 * valid full OID, or the label is a '#' (which we use
5366 * as a separator between merge heads and oneline), we
5367 * append a dash and a number to make it unique.
5369 size_t len
= buf
->len
;
5371 for (i
= 2; ; i
++) {
5372 strbuf_setlen(buf
, len
);
5373 strbuf_addf(buf
, "-%d", i
);
5374 if (!hashmap_get_from_hash(&state
->labels
,
5384 FLEX_ALLOC_STR(labels_entry
, label
, label
);
5385 hashmap_entry_init(&labels_entry
->entry
, strihash(label
));
5386 hashmap_add(&state
->labels
, &labels_entry
->entry
);
5388 FLEX_ALLOC_STR(string_entry
, string
, label
);
5389 oidcpy(&string_entry
->entry
.oid
, oid
);
5390 oidmap_put(&state
->commit2label
, string_entry
);
5392 return string_entry
->string
;
5395 static int make_script_with_merges(struct pretty_print_context
*pp
,
5396 struct rev_info
*revs
, struct strbuf
*out
,
5399 int keep_empty
= flags
& TODO_LIST_KEEP_EMPTY
;
5400 int rebase_cousins
= flags
& TODO_LIST_REBASE_COUSINS
;
5401 int root_with_onto
= flags
& TODO_LIST_ROOT_WITH_ONTO
;
5402 int skipped_commit
= 0;
5403 struct strbuf buf
= STRBUF_INIT
, oneline
= STRBUF_INIT
;
5404 struct strbuf label
= STRBUF_INIT
;
5405 struct commit_list
*commits
= NULL
, **tail
= &commits
, *iter
;
5406 struct commit_list
*tips
= NULL
, **tips_tail
= &tips
;
5407 struct commit
*commit
;
5408 struct oidmap commit2todo
= OIDMAP_INIT
;
5409 struct string_entry
*entry
;
5410 struct oidset interesting
= OIDSET_INIT
, child_seen
= OIDSET_INIT
,
5411 shown
= OIDSET_INIT
;
5412 struct label_state state
= { OIDMAP_INIT
, { NULL
}, STRBUF_INIT
};
5414 int abbr
= flags
& TODO_LIST_ABBREVIATE_CMDS
;
5415 const char *cmd_pick
= abbr
? "p" : "pick",
5416 *cmd_label
= abbr
? "l" : "label",
5417 *cmd_reset
= abbr
? "t" : "reset",
5418 *cmd_merge
= abbr
? "m" : "merge";
5420 oidmap_init(&commit2todo
, 0);
5421 oidmap_init(&state
.commit2label
, 0);
5422 hashmap_init(&state
.labels
, labels_cmp
, NULL
, 0);
5423 strbuf_init(&state
.buf
, 32);
5425 if (revs
->cmdline
.nr
&& (revs
->cmdline
.rev
[0].flags
& BOTTOM
)) {
5426 struct labels_entry
*onto_label_entry
;
5427 struct object_id
*oid
= &revs
->cmdline
.rev
[0].item
->oid
;
5428 FLEX_ALLOC_STR(entry
, string
, "onto");
5429 oidcpy(&entry
->entry
.oid
, oid
);
5430 oidmap_put(&state
.commit2label
, entry
);
5432 FLEX_ALLOC_STR(onto_label_entry
, label
, "onto");
5433 hashmap_entry_init(&onto_label_entry
->entry
, strihash("onto"));
5434 hashmap_add(&state
.labels
, &onto_label_entry
->entry
);
5439 * - get onelines for all commits
5440 * - gather all branch tips (i.e. 2nd or later parents of merges)
5441 * - label all branch tips
5443 while ((commit
= get_revision(revs
))) {
5444 struct commit_list
*to_merge
;
5445 const char *p1
, *p2
;
5446 struct object_id
*oid
;
5449 tail
= &commit_list_insert(commit
, tail
)->next
;
5450 oidset_insert(&interesting
, &commit
->object
.oid
);
5452 is_empty
= is_original_commit_empty(commit
);
5453 if (!is_empty
&& (commit
->object
.flags
& PATCHSAME
)) {
5454 if (flags
& TODO_LIST_WARN_SKIPPED_CHERRY_PICKS
)
5455 warning(_("skipped previously applied commit %s"),
5456 short_commit_name(commit
));
5460 if (is_empty
&& !keep_empty
)
5463 strbuf_reset(&oneline
);
5464 pretty_print_commit(pp
, commit
, &oneline
);
5466 to_merge
= commit
->parents
? commit
->parents
->next
: NULL
;
5468 /* non-merge commit: easy case */
5470 strbuf_addf(&buf
, "%s %s %s", cmd_pick
,
5471 oid_to_hex(&commit
->object
.oid
),
5474 strbuf_addf(&buf
, " %c empty",
5477 FLEX_ALLOC_STR(entry
, string
, buf
.buf
);
5478 oidcpy(&entry
->entry
.oid
, &commit
->object
.oid
);
5479 oidmap_put(&commit2todo
, entry
);
5484 /* Create a label */
5485 strbuf_reset(&label
);
5486 if (skip_prefix(oneline
.buf
, "Merge ", &p1
) &&
5487 (p1
= strchr(p1
, '\'')) &&
5488 (p2
= strchr(++p1
, '\'')))
5489 strbuf_add(&label
, p1
, p2
- p1
);
5490 else if (skip_prefix(oneline
.buf
, "Merge pull request ",
5492 (p1
= strstr(p1
, " from ")))
5493 strbuf_addstr(&label
, p1
+ strlen(" from "));
5495 strbuf_addbuf(&label
, &oneline
);
5498 strbuf_addf(&buf
, "%s -C %s",
5499 cmd_merge
, oid_to_hex(&commit
->object
.oid
));
5501 /* label the tips of merged branches */
5502 for (; to_merge
; to_merge
= to_merge
->next
) {
5503 oid
= &to_merge
->item
->object
.oid
;
5504 strbuf_addch(&buf
, ' ');
5506 if (!oidset_contains(&interesting
, oid
)) {
5507 strbuf_addstr(&buf
, label_oid(oid
, NULL
,
5512 tips_tail
= &commit_list_insert(to_merge
->item
,
5515 strbuf_addstr(&buf
, label_oid(oid
, label
.buf
, &state
));
5517 strbuf_addf(&buf
, " # %s", oneline
.buf
);
5519 FLEX_ALLOC_STR(entry
, string
, buf
.buf
);
5520 oidcpy(&entry
->entry
.oid
, &commit
->object
.oid
);
5521 oidmap_put(&commit2todo
, entry
);
5524 advise_if_enabled(ADVICE_SKIPPED_CHERRY_PICKS
,
5525 _("use --reapply-cherry-picks to include skipped commits"));
5529 * - label branch points
5530 * - add HEAD to the branch tips
5532 for (iter
= commits
; iter
; iter
= iter
->next
) {
5533 struct commit_list
*parent
= iter
->item
->parents
;
5534 for (; parent
; parent
= parent
->next
) {
5535 struct object_id
*oid
= &parent
->item
->object
.oid
;
5536 if (!oidset_contains(&interesting
, oid
))
5538 if (oidset_insert(&child_seen
, oid
))
5539 label_oid(oid
, "branch-point", &state
);
5542 /* Add HEAD as implicit "tip of branch" */
5544 tips_tail
= &commit_list_insert(iter
->item
,
5549 * Third phase: output the todo list. This is a bit tricky, as we
5550 * want to avoid jumping back and forth between revisions. To
5551 * accomplish that goal, we walk backwards from the branch tips,
5552 * gathering commits not yet shown, reversing the list on the fly,
5553 * then outputting that list (labeling revisions as needed).
5555 strbuf_addf(out
, "%s onto\n", cmd_label
);
5556 for (iter
= tips
; iter
; iter
= iter
->next
) {
5557 struct commit_list
*list
= NULL
, *iter2
;
5559 commit
= iter
->item
;
5560 if (oidset_contains(&shown
, &commit
->object
.oid
))
5562 entry
= oidmap_get(&state
.commit2label
, &commit
->object
.oid
);
5565 strbuf_addf(out
, "\n%c Branch %s\n", comment_line_char
, entry
->string
);
5567 strbuf_addch(out
, '\n');
5569 while (oidset_contains(&interesting
, &commit
->object
.oid
) &&
5570 !oidset_contains(&shown
, &commit
->object
.oid
)) {
5571 commit_list_insert(commit
, &list
);
5572 if (!commit
->parents
) {
5576 commit
= commit
->parents
->item
;
5580 strbuf_addf(out
, "%s %s\n", cmd_reset
,
5581 rebase_cousins
|| root_with_onto
?
5582 "onto" : "[new root]");
5584 const char *to
= NULL
;
5586 entry
= oidmap_get(&state
.commit2label
,
5587 &commit
->object
.oid
);
5590 else if (!rebase_cousins
)
5591 to
= label_oid(&commit
->object
.oid
, NULL
,
5594 if (!to
|| !strcmp(to
, "onto"))
5595 strbuf_addf(out
, "%s onto\n", cmd_reset
);
5597 strbuf_reset(&oneline
);
5598 pretty_print_commit(pp
, commit
, &oneline
);
5599 strbuf_addf(out
, "%s %s # %s\n",
5600 cmd_reset
, to
, oneline
.buf
);
5604 for (iter2
= list
; iter2
; iter2
= iter2
->next
) {
5605 struct object_id
*oid
= &iter2
->item
->object
.oid
;
5606 entry
= oidmap_get(&commit2todo
, oid
);
5607 /* only show if not already upstream */
5609 strbuf_addf(out
, "%s\n", entry
->string
);
5610 entry
= oidmap_get(&state
.commit2label
, oid
);
5612 strbuf_addf(out
, "%s %s\n",
5613 cmd_label
, entry
->string
);
5614 oidset_insert(&shown
, oid
);
5617 free_commit_list(list
);
5620 free_commit_list(commits
);
5621 free_commit_list(tips
);
5623 strbuf_release(&label
);
5624 strbuf_release(&oneline
);
5625 strbuf_release(&buf
);
5627 oidmap_free(&commit2todo
, 1);
5628 oidmap_free(&state
.commit2label
, 1);
5629 hashmap_clear_and_free(&state
.labels
, struct labels_entry
, entry
);
5630 strbuf_release(&state
.buf
);
5635 int sequencer_make_script(struct repository
*r
, struct strbuf
*out
, int argc
,
5636 const char **argv
, unsigned flags
)
5638 char *format
= NULL
;
5639 struct pretty_print_context pp
= {0};
5640 struct rev_info revs
;
5641 struct commit
*commit
;
5642 int keep_empty
= flags
& TODO_LIST_KEEP_EMPTY
;
5643 const char *insn
= flags
& TODO_LIST_ABBREVIATE_CMDS
? "p" : "pick";
5644 int rebase_merges
= flags
& TODO_LIST_REBASE_MERGES
;
5645 int reapply_cherry_picks
= flags
& TODO_LIST_REAPPLY_CHERRY_PICKS
;
5646 int skipped_commit
= 0;
5649 repo_init_revisions(r
, &revs
, NULL
);
5650 revs
.verbose_header
= 1;
5652 revs
.max_parents
= 1;
5653 revs
.cherry_mark
= !reapply_cherry_picks
;
5656 revs
.right_only
= 1;
5657 revs
.sort_order
= REV_SORT_IN_GRAPH_ORDER
;
5658 revs
.topo_order
= 1;
5660 revs
.pretty_given
= 1;
5661 git_config_get_string("rebase.instructionFormat", &format
);
5662 if (!format
|| !*format
) {
5664 format
= xstrdup("%s");
5666 get_commit_format(format
, &revs
);
5668 pp
.fmt
= revs
.commit_format
;
5669 pp
.output_encoding
= get_log_output_encoding();
5671 if (setup_revisions(argc
, argv
, &revs
, NULL
) > 1) {
5672 ret
= error(_("make_script: unhandled options"));
5676 if (prepare_revision_walk(&revs
) < 0) {
5677 ret
= error(_("make_script: error preparing revisions"));
5681 if (rebase_merges
) {
5682 ret
= make_script_with_merges(&pp
, &revs
, out
, flags
);
5686 while ((commit
= get_revision(&revs
))) {
5687 int is_empty
= is_original_commit_empty(commit
);
5689 if (!is_empty
&& (commit
->object
.flags
& PATCHSAME
)) {
5690 if (flags
& TODO_LIST_WARN_SKIPPED_CHERRY_PICKS
)
5691 warning(_("skipped previously applied commit %s"),
5692 short_commit_name(commit
));
5696 if (is_empty
&& !keep_empty
)
5698 strbuf_addf(out
, "%s %s ", insn
,
5699 oid_to_hex(&commit
->object
.oid
));
5700 pretty_print_commit(&pp
, commit
, out
);
5702 strbuf_addf(out
, " %c empty", comment_line_char
);
5703 strbuf_addch(out
, '\n');
5706 advise_if_enabled(ADVICE_SKIPPED_CHERRY_PICKS
,
5707 _("use --reapply-cherry-picks to include skipped commits"));
5709 release_revisions(&revs
);
5714 * Add commands after pick and (series of) squash/fixup commands
5717 static void todo_list_add_exec_commands(struct todo_list
*todo_list
,
5718 struct string_list
*commands
)
5720 struct strbuf
*buf
= &todo_list
->buf
;
5721 size_t base_offset
= buf
->len
;
5722 int i
, insert
, nr
= 0, alloc
= 0;
5723 struct todo_item
*items
= NULL
, *base_items
= NULL
;
5725 CALLOC_ARRAY(base_items
, commands
->nr
);
5726 for (i
= 0; i
< commands
->nr
; i
++) {
5727 size_t command_len
= strlen(commands
->items
[i
].string
);
5729 strbuf_addstr(buf
, commands
->items
[i
].string
);
5730 strbuf_addch(buf
, '\n');
5732 base_items
[i
].command
= TODO_EXEC
;
5733 base_items
[i
].offset_in_buf
= base_offset
;
5734 base_items
[i
].arg_offset
= base_offset
+ strlen("exec ");
5735 base_items
[i
].arg_len
= command_len
- strlen("exec ");
5737 base_offset
+= command_len
+ 1;
5741 * Insert <commands> after every pick. Here, fixup/squash chains
5742 * are considered part of the pick, so we insert the commands *after*
5743 * those chains if there are any.
5745 * As we insert the exec commands immediately after rearranging
5746 * any fixups and before the user edits the list, a fixup chain
5747 * can never contain comments (any comments are empty picks that
5748 * have been commented out because the user did not specify
5749 * --keep-empty). So, it is safe to insert an exec command
5750 * without looking at the command following a comment.
5753 for (i
= 0; i
< todo_list
->nr
; i
++) {
5754 enum todo_command command
= todo_list
->items
[i
].command
;
5755 if (insert
&& !is_fixup(command
)) {
5756 ALLOC_GROW(items
, nr
+ commands
->nr
, alloc
);
5757 COPY_ARRAY(items
+ nr
, base_items
, commands
->nr
);
5763 ALLOC_GROW(items
, nr
+ 1, alloc
);
5764 items
[nr
++] = todo_list
->items
[i
];
5766 if (command
== TODO_PICK
|| command
== TODO_MERGE
)
5770 /* insert or append final <commands> */
5772 ALLOC_GROW(items
, nr
+ commands
->nr
, alloc
);
5773 COPY_ARRAY(items
+ nr
, base_items
, commands
->nr
);
5778 FREE_AND_NULL(todo_list
->items
);
5779 todo_list
->items
= items
;
5781 todo_list
->alloc
= alloc
;
5784 static void todo_list_to_strbuf(struct repository
*r
, struct todo_list
*todo_list
,
5785 struct strbuf
*buf
, int num
, unsigned flags
)
5787 struct todo_item
*item
;
5788 int i
, max
= todo_list
->nr
;
5790 if (num
> 0 && num
< max
)
5793 for (item
= todo_list
->items
, i
= 0; i
< max
; i
++, item
++) {
5796 /* if the item is not a command write it and continue */
5797 if (item
->command
>= TODO_COMMENT
) {
5798 strbuf_addf(buf
, "%.*s\n", item
->arg_len
,
5799 todo_item_get_arg(todo_list
, item
));
5803 /* add command to the buffer */
5804 cmd
= command_to_char(item
->command
);
5805 if ((flags
& TODO_LIST_ABBREVIATE_CMDS
) && cmd
)
5806 strbuf_addch(buf
, cmd
);
5808 strbuf_addstr(buf
, command_to_string(item
->command
));
5812 const char *oid
= flags
& TODO_LIST_SHORTEN_IDS
?
5813 short_commit_name(item
->commit
) :
5814 oid_to_hex(&item
->commit
->object
.oid
);
5816 if (item
->command
== TODO_FIXUP
) {
5817 if (item
->flags
& TODO_EDIT_FIXUP_MSG
)
5818 strbuf_addstr(buf
, " -c");
5819 else if (item
->flags
& TODO_REPLACE_FIXUP_MSG
) {
5820 strbuf_addstr(buf
, " -C");
5824 if (item
->command
== TODO_MERGE
) {
5825 if (item
->flags
& TODO_EDIT_MERGE_MSG
)
5826 strbuf_addstr(buf
, " -c");
5828 strbuf_addstr(buf
, " -C");
5831 strbuf_addf(buf
, " %s", oid
);
5834 /* add all the rest */
5836 strbuf_addch(buf
, '\n');
5838 strbuf_addf(buf
, " %.*s\n", item
->arg_len
,
5839 todo_item_get_arg(todo_list
, item
));
5843 int todo_list_write_to_file(struct repository
*r
, struct todo_list
*todo_list
,
5844 const char *file
, const char *shortrevisions
,
5845 const char *shortonto
, int num
, unsigned flags
)
5848 struct strbuf buf
= STRBUF_INIT
;
5850 todo_list_to_strbuf(r
, todo_list
, &buf
, num
, flags
);
5851 if (flags
& TODO_LIST_APPEND_TODO_HELP
)
5852 append_todo_help(count_commands(todo_list
),
5853 shortrevisions
, shortonto
, &buf
);
5855 res
= write_message(buf
.buf
, buf
.len
, file
, 0);
5856 strbuf_release(&buf
);
5861 /* skip picking commits whose parents are unchanged */
5862 static int skip_unnecessary_picks(struct repository
*r
,
5863 struct todo_list
*todo_list
,
5864 struct object_id
*base_oid
)
5866 struct object_id
*parent_oid
;
5869 for (i
= 0; i
< todo_list
->nr
; i
++) {
5870 struct todo_item
*item
= todo_list
->items
+ i
;
5872 if (item
->command
>= TODO_NOOP
)
5874 if (item
->command
!= TODO_PICK
)
5876 if (parse_commit(item
->commit
)) {
5877 return error(_("could not parse commit '%s'"),
5878 oid_to_hex(&item
->commit
->object
.oid
));
5880 if (!item
->commit
->parents
)
5881 break; /* root commit */
5882 if (item
->commit
->parents
->next
)
5883 break; /* merge commit */
5884 parent_oid
= &item
->commit
->parents
->item
->object
.oid
;
5885 if (!oideq(parent_oid
, base_oid
))
5887 oidcpy(base_oid
, &item
->commit
->object
.oid
);
5890 const char *done_path
= rebase_path_done();
5892 if (todo_list_write_to_file(r
, todo_list
, done_path
, NULL
, NULL
, i
, 0)) {
5893 error_errno(_("could not write to '%s'"), done_path
);
5897 MOVE_ARRAY(todo_list
->items
, todo_list
->items
+ i
, todo_list
->nr
- i
);
5899 todo_list
->current
= 0;
5900 todo_list
->done_nr
+= i
;
5902 if (is_fixup(peek_command(todo_list
, 0)))
5903 record_in_rewritten(base_oid
, peek_command(todo_list
, 0));
5909 struct todo_add_branch_context
{
5910 struct todo_item
*items
;
5914 struct commit
*commit
;
5915 struct string_list refs_to_oids
;
5918 static int add_decorations_to_list(const struct commit
*commit
,
5919 struct todo_add_branch_context
*ctx
)
5921 const struct name_decoration
*decoration
= get_name_decoration(&commit
->object
);
5922 const char *head_ref
= resolve_ref_unsafe("HEAD",
5923 RESOLVE_REF_READING
,
5927 while (decoration
) {
5928 struct todo_item
*item
;
5930 size_t base_offset
= ctx
->buf
->len
;
5933 * If the branch is the current HEAD, then it will be
5934 * updated by the default rebase behavior.
5936 if (head_ref
&& !strcmp(head_ref
, decoration
->name
)) {
5937 decoration
= decoration
->next
;
5941 ALLOC_GROW(ctx
->items
,
5944 item
= &ctx
->items
[ctx
->items_nr
];
5945 memset(item
, 0, sizeof(*item
));
5947 /* If the branch is checked out, then leave a comment instead. */
5948 if ((path
= branch_checked_out(decoration
->name
))) {
5949 item
->command
= TODO_COMMENT
;
5950 strbuf_addf(ctx
->buf
, "# Ref %s checked out at '%s'\n",
5951 decoration
->name
, path
);
5953 struct string_list_item
*sti
;
5954 item
->command
= TODO_UPDATE_REF
;
5955 strbuf_addf(ctx
->buf
, "%s\n", decoration
->name
);
5957 sti
= string_list_insert(&ctx
->refs_to_oids
,
5959 sti
->util
= init_update_ref_record(decoration
->name
);
5962 item
->offset_in_buf
= base_offset
;
5963 item
->arg_offset
= base_offset
;
5964 item
->arg_len
= ctx
->buf
->len
- base_offset
;
5967 decoration
= decoration
->next
;
5974 * For each 'pick' command, find out if the commit has a decoration in
5975 * refs/heads/. If so, then add a 'label for-update-refs/' command.
5977 static int todo_list_add_update_ref_commands(struct todo_list
*todo_list
)
5980 static struct string_list decorate_refs_exclude
= STRING_LIST_INIT_NODUP
;
5981 static struct string_list decorate_refs_exclude_config
= STRING_LIST_INIT_NODUP
;
5982 static struct string_list decorate_refs_include
= STRING_LIST_INIT_NODUP
;
5983 struct decoration_filter decoration_filter
= {
5984 .include_ref_pattern
= &decorate_refs_include
,
5985 .exclude_ref_pattern
= &decorate_refs_exclude
,
5986 .exclude_ref_config_pattern
= &decorate_refs_exclude_config
,
5988 struct todo_add_branch_context ctx
= {
5989 .buf
= &todo_list
->buf
,
5990 .refs_to_oids
= STRING_LIST_INIT_DUP
,
5993 ctx
.items_alloc
= 2 * todo_list
->nr
+ 1;
5994 ALLOC_ARRAY(ctx
.items
, ctx
.items_alloc
);
5996 string_list_append(&decorate_refs_include
, "refs/heads/");
5997 load_ref_decorations(&decoration_filter
, 0);
5999 for (i
= 0; i
< todo_list
->nr
; ) {
6000 struct todo_item
*item
= &todo_list
->items
[i
];
6002 /* insert ith item into new list */
6003 ALLOC_GROW(ctx
.items
,
6007 ctx
.items
[ctx
.items_nr
++] = todo_list
->items
[i
++];
6010 ctx
.commit
= item
->commit
;
6011 add_decorations_to_list(item
->commit
, &ctx
);
6015 res
= write_update_refs_state(&ctx
.refs_to_oids
);
6017 string_list_clear(&ctx
.refs_to_oids
, 1);
6020 /* we failed, so clean up the new list. */
6025 free(todo_list
->items
);
6026 todo_list
->items
= ctx
.items
;
6027 todo_list
->nr
= ctx
.items_nr
;
6028 todo_list
->alloc
= ctx
.items_alloc
;
6033 int complete_action(struct repository
*r
, struct replay_opts
*opts
, unsigned flags
,
6034 const char *shortrevisions
, const char *onto_name
,
6035 struct commit
*onto
, const struct object_id
*orig_head
,
6036 struct string_list
*commands
, unsigned autosquash
,
6037 unsigned update_refs
,
6038 struct todo_list
*todo_list
)
6040 char shortonto
[GIT_MAX_HEXSZ
+ 1];
6041 const char *todo_file
= rebase_path_todo();
6042 struct todo_list new_todo
= TODO_LIST_INIT
;
6043 struct strbuf
*buf
= &todo_list
->buf
, buf2
= STRBUF_INIT
;
6044 struct object_id oid
= onto
->object
.oid
;
6047 find_unique_abbrev_r(shortonto
, &oid
, DEFAULT_ABBREV
);
6049 if (buf
->len
== 0) {
6050 struct todo_item
*item
= append_new_todo(todo_list
);
6051 item
->command
= TODO_NOOP
;
6052 item
->commit
= NULL
;
6053 item
->arg_len
= item
->arg_offset
= item
->flags
= item
->offset_in_buf
= 0;
6056 if (update_refs
&& todo_list_add_update_ref_commands(todo_list
))
6059 if (autosquash
&& todo_list_rearrange_squash(todo_list
))
6063 todo_list_add_exec_commands(todo_list
, commands
);
6065 if (count_commands(todo_list
) == 0) {
6066 apply_autostash(rebase_path_autostash());
6067 sequencer_remove_state(opts
);
6069 return error(_("nothing to do"));
6072 res
= edit_todo_list(r
, todo_list
, &new_todo
, shortrevisions
,
6076 else if (res
== -2) {
6077 apply_autostash(rebase_path_autostash());
6078 sequencer_remove_state(opts
);
6081 } else if (res
== -3) {
6082 apply_autostash(rebase_path_autostash());
6083 sequencer_remove_state(opts
);
6084 todo_list_release(&new_todo
);
6086 return error(_("nothing to do"));
6087 } else if (res
== -4) {
6088 checkout_onto(r
, opts
, onto_name
, &onto
->object
.oid
, orig_head
);
6089 todo_list_release(&new_todo
);
6094 /* Expand the commit IDs */
6095 todo_list_to_strbuf(r
, &new_todo
, &buf2
, -1, 0);
6096 strbuf_swap(&new_todo
.buf
, &buf2
);
6097 strbuf_release(&buf2
);
6098 new_todo
.total_nr
-= new_todo
.nr
;
6099 if (todo_list_parse_insn_buffer(r
, new_todo
.buf
.buf
, &new_todo
) < 0)
6100 BUG("invalid todo list after expanding IDs:\n%s",
6103 if (opts
->allow_ff
&& skip_unnecessary_picks(r
, &new_todo
, &oid
)) {
6104 todo_list_release(&new_todo
);
6105 return error(_("could not skip unnecessary pick commands"));
6108 if (todo_list_write_to_file(r
, &new_todo
, todo_file
, NULL
, NULL
, -1,
6109 flags
& ~(TODO_LIST_SHORTEN_IDS
))) {
6110 todo_list_release(&new_todo
);
6111 return error_errno(_("could not write '%s'"), todo_file
);
6116 if (checkout_onto(r
, opts
, onto_name
, &oid
, orig_head
))
6119 if (require_clean_work_tree(r
, "rebase", "", 1, 1))
6122 todo_list_write_total_nr(&new_todo
);
6123 res
= pick_commits(r
, &new_todo
, opts
);
6126 todo_list_release(&new_todo
);
6131 struct subject2item_entry
{
6132 struct hashmap_entry entry
;
6134 char subject
[FLEX_ARRAY
];
6137 static int subject2item_cmp(const void *fndata UNUSED
,
6138 const struct hashmap_entry
*eptr
,
6139 const struct hashmap_entry
*entry_or_key
,
6142 const struct subject2item_entry
*a
, *b
;
6144 a
= container_of(eptr
, const struct subject2item_entry
, entry
);
6145 b
= container_of(entry_or_key
, const struct subject2item_entry
, entry
);
6147 return key
? strcmp(a
->subject
, key
) : strcmp(a
->subject
, b
->subject
);
6150 define_commit_slab(commit_todo_item
, struct todo_item
*);
6152 static int skip_fixupish(const char *subject
, const char **p
) {
6153 return skip_prefix(subject
, "fixup! ", p
) ||
6154 skip_prefix(subject
, "amend! ", p
) ||
6155 skip_prefix(subject
, "squash! ", p
);
6159 * Rearrange the todo list that has both "pick commit-id msg" and "pick
6160 * commit-id fixup!/squash! msg" in it so that the latter is put immediately
6161 * after the former, and change "pick" to "fixup"/"squash".
6163 * Note that if the config has specified a custom instruction format, each log
6164 * message will have to be retrieved from the commit (as the oneline in the
6165 * script cannot be trusted) in order to normalize the autosquash arrangement.
6167 int todo_list_rearrange_squash(struct todo_list
*todo_list
)
6169 struct hashmap subject2item
;
6170 int rearranged
= 0, *next
, *tail
, i
, nr
= 0, alloc
= 0;
6172 struct commit_todo_item commit_todo
;
6173 struct todo_item
*items
= NULL
;
6175 init_commit_todo_item(&commit_todo
);
6177 * The hashmap maps onelines to the respective todo list index.
6179 * If any items need to be rearranged, the next[i] value will indicate
6180 * which item was moved directly after the i'th.
6182 * In that case, last[i] will indicate the index of the latest item to
6183 * be moved to appear after the i'th.
6185 hashmap_init(&subject2item
, subject2item_cmp
, NULL
, todo_list
->nr
);
6186 ALLOC_ARRAY(next
, todo_list
->nr
);
6187 ALLOC_ARRAY(tail
, todo_list
->nr
);
6188 ALLOC_ARRAY(subjects
, todo_list
->nr
);
6189 for (i
= 0; i
< todo_list
->nr
; i
++) {
6190 struct strbuf buf
= STRBUF_INIT
;
6191 struct todo_item
*item
= todo_list
->items
+ i
;
6192 const char *commit_buffer
, *subject
, *p
;
6195 struct subject2item_entry
*entry
;
6197 next
[i
] = tail
[i
] = -1;
6198 if (!item
->commit
|| item
->command
== TODO_DROP
) {
6203 if (is_fixup(item
->command
)) {
6204 clear_commit_todo_item(&commit_todo
);
6205 return error(_("the script was already rearranged."));
6208 parse_commit(item
->commit
);
6209 commit_buffer
= logmsg_reencode(item
->commit
, NULL
, "UTF-8");
6210 find_commit_subject(commit_buffer
, &subject
);
6211 format_subject(&buf
, subject
, " ");
6212 subject
= subjects
[i
] = strbuf_detach(&buf
, &subject_len
);
6213 unuse_commit_buffer(item
->commit
, commit_buffer
);
6214 if (skip_fixupish(subject
, &p
)) {
6215 struct commit
*commit2
;
6220 if (!skip_fixupish(p
, &p
))
6224 entry
= hashmap_get_entry_from_hash(&subject2item
,
6226 struct subject2item_entry
,
6229 /* found by title */
6231 else if (!strchr(p
, ' ') &&
6233 lookup_commit_reference_by_name(p
)) &&
6234 *commit_todo_item_at(&commit_todo
, commit2
))
6235 /* found by commit name */
6236 i2
= *commit_todo_item_at(&commit_todo
, commit2
)
6239 /* copy can be a prefix of the commit subject */
6240 for (i2
= 0; i2
< i
; i2
++)
6242 starts_with(subjects
[i2
], p
))
6250 if (starts_with(subject
, "fixup!")) {
6251 todo_list
->items
[i
].command
= TODO_FIXUP
;
6252 } else if (starts_with(subject
, "amend!")) {
6253 todo_list
->items
[i
].command
= TODO_FIXUP
;
6254 todo_list
->items
[i
].flags
= TODO_REPLACE_FIXUP_MSG
;
6256 todo_list
->items
[i
].command
= TODO_SQUASH
;
6262 next
[i
] = next
[tail
[i2
]];
6266 } else if (!hashmap_get_from_hash(&subject2item
,
6267 strhash(subject
), subject
)) {
6268 FLEX_ALLOC_MEM(entry
, subject
, subject
, subject_len
);
6270 hashmap_entry_init(&entry
->entry
,
6271 strhash(entry
->subject
));
6272 hashmap_put(&subject2item
, &entry
->entry
);
6275 *commit_todo_item_at(&commit_todo
, item
->commit
) = item
;
6279 for (i
= 0; i
< todo_list
->nr
; i
++) {
6280 enum todo_command command
= todo_list
->items
[i
].command
;
6284 * Initially, all commands are 'pick's. If it is a
6285 * fixup or a squash now, we have rearranged it.
6287 if (is_fixup(command
))
6291 ALLOC_GROW(items
, nr
+ 1, alloc
);
6292 items
[nr
++] = todo_list
->items
[cur
];
6297 FREE_AND_NULL(todo_list
->items
);
6298 todo_list
->items
= items
;
6300 todo_list
->alloc
= alloc
;
6305 for (i
= 0; i
< todo_list
->nr
; i
++)
6308 hashmap_clear_and_free(&subject2item
, struct subject2item_entry
, entry
);
6310 clear_commit_todo_item(&commit_todo
);
6315 int sequencer_determine_whence(struct repository
*r
, enum commit_whence
*whence
)
6317 if (refs_ref_exists(get_main_ref_store(r
), "CHERRY_PICK_HEAD")) {
6318 struct object_id cherry_pick_head
, rebase_head
;
6320 if (file_exists(git_path_seq_dir()))
6321 *whence
= FROM_CHERRY_PICK_MULTI
;
6322 if (file_exists(rebase_path()) &&
6323 !get_oid("REBASE_HEAD", &rebase_head
) &&
6324 !get_oid("CHERRY_PICK_HEAD", &cherry_pick_head
) &&
6325 oideq(&rebase_head
, &cherry_pick_head
))
6326 *whence
= FROM_REBASE_PICK
;
6328 *whence
= FROM_CHERRY_PICK_SINGLE
;
6336 int sequencer_get_update_refs_state(const char *wt_dir
,
6337 struct string_list
*refs
)
6341 struct strbuf ref
= STRBUF_INIT
;
6342 struct strbuf hash
= STRBUF_INIT
;
6343 struct update_ref_record
*rec
= NULL
;
6345 char *path
= rebase_path_update_refs(wt_dir
);
6347 fp
= fopen(path
, "r");
6351 while (strbuf_getline(&ref
, fp
) != EOF
) {
6352 struct string_list_item
*item
;
6354 CALLOC_ARRAY(rec
, 1);
6356 if (strbuf_getline(&hash
, fp
) == EOF
||
6357 get_oid_hex(hash
.buf
, &rec
->before
)) {
6358 warning(_("update-refs file at '%s' is invalid"),
6364 if (strbuf_getline(&hash
, fp
) == EOF
||
6365 get_oid_hex(hash
.buf
, &rec
->after
)) {
6366 warning(_("update-refs file at '%s' is invalid"),
6372 item
= string_list_insert(refs
, ref
.buf
);
6382 strbuf_release(&ref
);
6383 strbuf_release(&hash
);