5 #include "object-store.h"
10 #include "run-command.h"
13 #include "cache-tree.h"
17 #include "merge-recursive.h"
19 #include "argv-array.h"
23 #include "wt-status.h"
25 #include "notes-utils.h"
27 #include "unpack-trees.h"
31 #include "commit-slab.h"
33 #include "commit-reach.h"
34 #include "rebase-interactive.h"
36 #define GIT_REFLOG_ACTION "GIT_REFLOG_ACTION"
38 static const char sign_off_header
[] = "Signed-off-by: ";
39 static const char cherry_picked_prefix
[] = "(cherry picked from commit ";
41 GIT_PATH_FUNC(git_path_commit_editmsg
, "COMMIT_EDITMSG")
43 GIT_PATH_FUNC(git_path_seq_dir
, "sequencer")
45 static GIT_PATH_FUNC(git_path_todo_file
, "sequencer/todo")
46 static GIT_PATH_FUNC(git_path_opts_file
, "sequencer/opts")
47 static GIT_PATH_FUNC(git_path_head_file
, "sequencer/head")
48 static GIT_PATH_FUNC(git_path_abort_safety_file
, "sequencer/abort-safety")
50 static GIT_PATH_FUNC(rebase_path
, "rebase-merge")
52 * The file containing rebase commands, comments, and empty lines.
53 * This file is created by "git rebase -i" then edited by the user. As
54 * the lines are processed, they are removed from the front of this
55 * file and written to the tail of 'done'.
57 GIT_PATH_FUNC(rebase_path_todo
, "rebase-merge/git-rebase-todo")
58 GIT_PATH_FUNC(rebase_path_todo_backup
, "rebase-merge/git-rebase-todo.backup")
61 * The rebase command lines that have already been processed. A line
62 * is moved here when it is first handled, before any associated user
65 static GIT_PATH_FUNC(rebase_path_done
, "rebase-merge/done")
67 * The file to keep track of how many commands were already processed (e.g.
70 static GIT_PATH_FUNC(rebase_path_msgnum
, "rebase-merge/msgnum")
72 * The file to keep track of how many commands are to be processed in total
73 * (e.g. for the prompt).
75 static GIT_PATH_FUNC(rebase_path_msgtotal
, "rebase-merge/end")
77 * The commit message that is planned to be used for any changes that
78 * need to be committed following a user interaction.
80 static GIT_PATH_FUNC(rebase_path_message
, "rebase-merge/message")
82 * The file into which is accumulated the suggested commit message for
83 * squash/fixup commands. When the first of a series of squash/fixups
84 * is seen, the file is created and the commit message from the
85 * previous commit and from the first squash/fixup commit are written
86 * to it. The commit message for each subsequent squash/fixup commit
87 * is appended to the file as it is processed.
89 static GIT_PATH_FUNC(rebase_path_squash_msg
, "rebase-merge/message-squash")
91 * If the current series of squash/fixups has not yet included a squash
92 * command, then this file exists and holds the commit message of the
93 * original "pick" commit. (If the series ends without a "squash"
94 * command, then this can be used as the commit message of the combined
95 * commit without opening the editor.)
97 static GIT_PATH_FUNC(rebase_path_fixup_msg
, "rebase-merge/message-fixup")
99 * This file contains the list fixup/squash commands that have been
100 * accumulated into message-fixup or message-squash so far.
102 static GIT_PATH_FUNC(rebase_path_current_fixups
, "rebase-merge/current-fixups")
104 * A script to set the GIT_AUTHOR_NAME, GIT_AUTHOR_EMAIL, and
105 * GIT_AUTHOR_DATE that will be used for the commit that is currently
108 static GIT_PATH_FUNC(rebase_path_author_script
, "rebase-merge/author-script")
110 * When an "edit" rebase command is being processed, the SHA1 of the
111 * commit to be edited is recorded in this file. When "git rebase
112 * --continue" is executed, if there are any staged changes then they
113 * will be amended to the HEAD commit, but only provided the HEAD
114 * commit is still the commit to be edited. When any other rebase
115 * command is processed, this file is deleted.
117 static GIT_PATH_FUNC(rebase_path_amend
, "rebase-merge/amend")
119 * When we stop at a given patch via the "edit" command, this file contains
120 * the abbreviated commit name of the corresponding patch.
122 static GIT_PATH_FUNC(rebase_path_stopped_sha
, "rebase-merge/stopped-sha")
124 * For the post-rewrite hook, we make a list of rewritten commits and
125 * their new sha1s. The rewritten-pending list keeps the sha1s of
126 * commits that have been processed, but not committed yet,
127 * e.g. because they are waiting for a 'squash' command.
129 static GIT_PATH_FUNC(rebase_path_rewritten_list
, "rebase-merge/rewritten-list")
130 static GIT_PATH_FUNC(rebase_path_rewritten_pending
,
131 "rebase-merge/rewritten-pending")
134 * The path of the file containig the OID of the "squash onto" commit, i.e.
135 * the dummy commit used for `reset [new root]`.
137 static GIT_PATH_FUNC(rebase_path_squash_onto
, "rebase-merge/squash-onto")
140 * The path of the file listing refs that need to be deleted after the rebase
141 * finishes. This is used by the `label` command to record the need for cleanup.
143 static GIT_PATH_FUNC(rebase_path_refs_to_delete
, "rebase-merge/refs-to-delete")
146 * The following files are written by git-rebase just after parsing the
149 static GIT_PATH_FUNC(rebase_path_gpg_sign_opt
, "rebase-merge/gpg_sign_opt")
150 static GIT_PATH_FUNC(rebase_path_orig_head
, "rebase-merge/orig-head")
151 static GIT_PATH_FUNC(rebase_path_verbose
, "rebase-merge/verbose")
152 static GIT_PATH_FUNC(rebase_path_quiet
, "rebase-merge/quiet")
153 static GIT_PATH_FUNC(rebase_path_signoff
, "rebase-merge/signoff")
154 static GIT_PATH_FUNC(rebase_path_head_name
, "rebase-merge/head-name")
155 static GIT_PATH_FUNC(rebase_path_onto
, "rebase-merge/onto")
156 static GIT_PATH_FUNC(rebase_path_autostash
, "rebase-merge/autostash")
157 static GIT_PATH_FUNC(rebase_path_strategy
, "rebase-merge/strategy")
158 static GIT_PATH_FUNC(rebase_path_strategy_opts
, "rebase-merge/strategy_opts")
159 static GIT_PATH_FUNC(rebase_path_allow_rerere_autoupdate
, "rebase-merge/allow_rerere_autoupdate")
160 static GIT_PATH_FUNC(rebase_path_reschedule_failed_exec
, "rebase-merge/reschedule-failed-exec")
162 static int git_sequencer_config(const char *k
, const char *v
, void *cb
)
164 struct replay_opts
*opts
= cb
;
167 if (!strcmp(k
, "commit.cleanup")) {
170 status
= git_config_string(&s
, k
, v
);
174 if (!strcmp(s
, "verbatim")) {
175 opts
->default_msg_cleanup
= COMMIT_MSG_CLEANUP_NONE
;
176 opts
->explicit_cleanup
= 1;
177 } else if (!strcmp(s
, "whitespace")) {
178 opts
->default_msg_cleanup
= COMMIT_MSG_CLEANUP_SPACE
;
179 opts
->explicit_cleanup
= 1;
180 } else if (!strcmp(s
, "strip")) {
181 opts
->default_msg_cleanup
= COMMIT_MSG_CLEANUP_ALL
;
182 opts
->explicit_cleanup
= 1;
183 } else if (!strcmp(s
, "scissors")) {
184 opts
->default_msg_cleanup
= COMMIT_MSG_CLEANUP_SCISSORS
;
185 opts
->explicit_cleanup
= 1;
187 warning(_("invalid commit message cleanup mode '%s'"),
195 if (!strcmp(k
, "commit.gpgsign")) {
196 opts
->gpg_sign
= git_config_bool(k
, v
) ? xstrdup("") : NULL
;
200 status
= git_gpg_config(k
, v
, NULL
);
204 return git_diff_basic_config(k
, v
, NULL
);
207 void sequencer_init_config(struct replay_opts
*opts
)
209 opts
->default_msg_cleanup
= COMMIT_MSG_CLEANUP_NONE
;
210 git_config(git_sequencer_config
, opts
);
213 static inline int is_rebase_i(const struct replay_opts
*opts
)
215 return opts
->action
== REPLAY_INTERACTIVE_REBASE
;
218 static const char *get_dir(const struct replay_opts
*opts
)
220 if (is_rebase_i(opts
))
221 return rebase_path();
222 return git_path_seq_dir();
225 static const char *get_todo_path(const struct replay_opts
*opts
)
227 if (is_rebase_i(opts
))
228 return rebase_path_todo();
229 return git_path_todo_file();
233 * Returns 0 for non-conforming footer
234 * Returns 1 for conforming footer
235 * Returns 2 when sob exists within conforming footer
236 * Returns 3 when sob exists within conforming footer as last entry
238 static int has_conforming_footer(struct strbuf
*sb
, struct strbuf
*sob
,
239 size_t ignore_footer
)
241 struct process_trailer_options opts
= PROCESS_TRAILER_OPTIONS_INIT
;
242 struct trailer_info info
;
244 int found_sob
= 0, found_sob_last
= 0;
248 trailer_info_get(&info
, sb
->buf
, &opts
);
250 if (info
.trailer_start
== info
.trailer_end
)
253 for (i
= 0; i
< info
.trailer_nr
; i
++)
254 if (sob
&& !strncmp(info
.trailers
[i
], sob
->buf
, sob
->len
)) {
256 if (i
== info
.trailer_nr
- 1)
260 trailer_info_release(&info
);
269 static const char *gpg_sign_opt_quoted(struct replay_opts
*opts
)
271 static struct strbuf buf
= STRBUF_INIT
;
275 sq_quotef(&buf
, "-S%s", opts
->gpg_sign
);
279 int sequencer_remove_state(struct replay_opts
*opts
)
281 struct strbuf buf
= STRBUF_INIT
;
284 if (is_rebase_i(opts
) &&
285 strbuf_read_file(&buf
, rebase_path_refs_to_delete(), 0) > 0) {
288 char *eol
= strchr(p
, '\n');
291 if (delete_ref("(rebase -i) cleanup", p
, NULL
, 0) < 0) {
292 warning(_("could not delete '%s'"), p
);
301 free(opts
->gpg_sign
);
302 free(opts
->strategy
);
303 for (i
= 0; i
< opts
->xopts_nr
; i
++)
304 free(opts
->xopts
[i
]);
306 strbuf_release(&opts
->current_fixups
);
309 strbuf_addstr(&buf
, get_dir(opts
));
310 if (remove_dir_recursively(&buf
, 0))
311 ret
= error(_("could not remove '%s'"), buf
.buf
);
312 strbuf_release(&buf
);
317 static const char *action_name(const struct replay_opts
*opts
)
319 switch (opts
->action
) {
323 return N_("cherry-pick");
324 case REPLAY_INTERACTIVE_REBASE
:
325 return N_("rebase -i");
327 die(_("unknown action: %d"), opts
->action
);
330 struct commit_message
{
337 static const char *short_commit_name(struct commit
*commit
)
339 return find_unique_abbrev(&commit
->object
.oid
, DEFAULT_ABBREV
);
342 static int get_message(struct commit
*commit
, struct commit_message
*out
)
344 const char *abbrev
, *subject
;
347 out
->message
= logmsg_reencode(commit
, NULL
, get_commit_output_encoding());
348 abbrev
= short_commit_name(commit
);
350 subject_len
= find_commit_subject(out
->message
, &subject
);
352 out
->subject
= xmemdupz(subject
, subject_len
);
353 out
->label
= xstrfmt("%s... %s", abbrev
, out
->subject
);
354 out
->parent_label
= xstrfmt("parent of %s", out
->label
);
359 static void free_message(struct commit
*commit
, struct commit_message
*msg
)
361 free(msg
->parent_label
);
364 unuse_commit_buffer(commit
, msg
->message
);
367 static void print_advice(struct repository
*r
, int show_hint
,
368 struct replay_opts
*opts
)
370 char *msg
= getenv("GIT_CHERRY_PICK_HELP");
373 fprintf(stderr
, "%s\n", msg
);
375 * A conflict has occurred but the porcelain
376 * (typically rebase --interactive) wants to take care
377 * of the commit itself so remove CHERRY_PICK_HEAD
379 unlink(git_path_cherry_pick_head(r
));
385 advise(_("after resolving the conflicts, mark the corrected paths\n"
386 "with 'git add <paths>' or 'git rm <paths>'"));
388 advise(_("after resolving the conflicts, mark the corrected paths\n"
389 "with 'git add <paths>' or 'git rm <paths>'\n"
390 "and commit the result with 'git commit'"));
394 static int write_message(const void *buf
, size_t len
, const char *filename
,
397 struct lock_file msg_file
= LOCK_INIT
;
399 int msg_fd
= hold_lock_file_for_update(&msg_file
, filename
, 0);
401 return error_errno(_("could not lock '%s'"), filename
);
402 if (write_in_full(msg_fd
, buf
, len
) < 0) {
403 error_errno(_("could not write to '%s'"), filename
);
404 rollback_lock_file(&msg_file
);
407 if (append_eol
&& write(msg_fd
, "\n", 1) < 0) {
408 error_errno(_("could not write eol to '%s'"), filename
);
409 rollback_lock_file(&msg_file
);
412 if (commit_lock_file(&msg_file
) < 0)
413 return error(_("failed to finalize '%s'"), filename
);
419 * Reads a file that was presumably written by a shell script, i.e. with an
420 * end-of-line marker that needs to be stripped.
422 * Note that only the last end-of-line marker is stripped, consistent with the
423 * behavior of "$(cat path)" in a shell script.
425 * Returns 1 if the file was read, 0 if it could not be read or does not exist.
427 static int read_oneliner(struct strbuf
*buf
,
428 const char *path
, int skip_if_empty
)
430 int orig_len
= buf
->len
;
432 if (!file_exists(path
))
435 if (strbuf_read_file(buf
, path
, 0) < 0) {
436 warning_errno(_("could not read '%s'"), path
);
440 if (buf
->len
> orig_len
&& buf
->buf
[buf
->len
- 1] == '\n') {
441 if (--buf
->len
> orig_len
&& buf
->buf
[buf
->len
- 1] == '\r')
443 buf
->buf
[buf
->len
] = '\0';
446 if (skip_if_empty
&& buf
->len
== orig_len
)
452 static struct tree
*empty_tree(struct repository
*r
)
454 return lookup_tree(r
, the_hash_algo
->empty_tree
);
457 static int error_dirty_index(struct repository
*repo
, struct replay_opts
*opts
)
459 if (repo_read_index_unmerged(repo
))
460 return error_resolve_conflict(_(action_name(opts
)));
462 error(_("your local changes would be overwritten by %s."),
463 _(action_name(opts
)));
465 if (advice_commit_before_merge
)
466 advise(_("commit your changes or stash them to proceed."));
470 static void update_abort_safety_file(void)
472 struct object_id head
;
474 /* Do nothing on a single-pick */
475 if (!file_exists(git_path_seq_dir()))
478 if (!get_oid("HEAD", &head
))
479 write_file(git_path_abort_safety_file(), "%s", oid_to_hex(&head
));
481 write_file(git_path_abort_safety_file(), "%s", "");
484 static int fast_forward_to(struct repository
*r
,
485 const struct object_id
*to
,
486 const struct object_id
*from
,
488 struct replay_opts
*opts
)
490 struct ref_transaction
*transaction
;
491 struct strbuf sb
= STRBUF_INIT
;
492 struct strbuf err
= STRBUF_INIT
;
495 if (checkout_fast_forward(r
, from
, to
, 1))
496 return -1; /* the callee should have complained already */
498 strbuf_addf(&sb
, _("%s: fast-forward"), _(action_name(opts
)));
500 transaction
= ref_transaction_begin(&err
);
502 ref_transaction_update(transaction
, "HEAD",
503 to
, unborn
&& !is_rebase_i(opts
) ?
506 ref_transaction_commit(transaction
, &err
)) {
507 ref_transaction_free(transaction
);
508 error("%s", err
.buf
);
510 strbuf_release(&err
);
515 strbuf_release(&err
);
516 ref_transaction_free(transaction
);
517 update_abort_safety_file();
521 enum commit_msg_cleanup_mode
get_cleanup_mode(const char *cleanup_arg
,
524 if (!cleanup_arg
|| !strcmp(cleanup_arg
, "default"))
525 return use_editor
? COMMIT_MSG_CLEANUP_ALL
:
526 COMMIT_MSG_CLEANUP_SPACE
;
527 else if (!strcmp(cleanup_arg
, "verbatim"))
528 return COMMIT_MSG_CLEANUP_NONE
;
529 else if (!strcmp(cleanup_arg
, "whitespace"))
530 return COMMIT_MSG_CLEANUP_SPACE
;
531 else if (!strcmp(cleanup_arg
, "strip"))
532 return COMMIT_MSG_CLEANUP_ALL
;
533 else if (!strcmp(cleanup_arg
, "scissors"))
534 return use_editor
? COMMIT_MSG_CLEANUP_SCISSORS
:
535 COMMIT_MSG_CLEANUP_SPACE
;
537 die(_("Invalid cleanup mode %s"), cleanup_arg
);
541 * NB using int rather than enum cleanup_mode to stop clang's
542 * -Wtautological-constant-out-of-range-compare complaining that the comparison
545 static const char *describe_cleanup_mode(int cleanup_mode
)
547 static const char *modes
[] = { "whitespace",
552 if (cleanup_mode
< ARRAY_SIZE(modes
))
553 return modes
[cleanup_mode
];
555 BUG("invalid cleanup_mode provided (%d)", cleanup_mode
);
558 void append_conflicts_hint(struct index_state
*istate
,
559 struct strbuf
*msgbuf
, enum commit_msg_cleanup_mode cleanup_mode
)
563 if (cleanup_mode
== COMMIT_MSG_CLEANUP_SCISSORS
) {
564 strbuf_addch(msgbuf
, '\n');
565 wt_status_append_cut_line(msgbuf
);
566 strbuf_addch(msgbuf
, comment_line_char
);
569 strbuf_addch(msgbuf
, '\n');
570 strbuf_commented_addf(msgbuf
, "Conflicts:\n");
571 for (i
= 0; i
< istate
->cache_nr
;) {
572 const struct cache_entry
*ce
= istate
->cache
[i
++];
574 strbuf_commented_addf(msgbuf
, "\t%s\n", ce
->name
);
575 while (i
< istate
->cache_nr
&&
576 !strcmp(ce
->name
, istate
->cache
[i
]->name
))
582 static int do_recursive_merge(struct repository
*r
,
583 struct commit
*base
, struct commit
*next
,
584 const char *base_label
, const char *next_label
,
585 struct object_id
*head
, struct strbuf
*msgbuf
,
586 struct replay_opts
*opts
)
588 struct merge_options o
;
589 struct tree
*next_tree
, *base_tree
, *head_tree
;
592 struct lock_file index_lock
= LOCK_INIT
;
594 if (repo_hold_locked_index(r
, &index_lock
, LOCK_REPORT_ON_ERROR
) < 0)
599 init_merge_options(&o
, r
);
600 o
.ancestor
= base
? base_label
: "(empty tree)";
602 o
.branch2
= next
? next_label
: "(empty tree)";
603 if (is_rebase_i(opts
))
605 o
.show_rename_progress
= 1;
607 head_tree
= parse_tree_indirect(head
);
608 next_tree
= next
? get_commit_tree(next
) : empty_tree(r
);
609 base_tree
= base
? get_commit_tree(base
) : empty_tree(r
);
611 for (xopt
= opts
->xopts
; xopt
!= opts
->xopts
+ opts
->xopts_nr
; xopt
++)
612 parse_merge_opt(&o
, *xopt
);
614 clean
= merge_trees(&o
,
616 next_tree
, base_tree
);
617 if (is_rebase_i(opts
) && clean
<= 0)
618 fputs(o
.obuf
.buf
, stdout
);
619 strbuf_release(&o
.obuf
);
621 rollback_lock_file(&index_lock
);
625 if (write_locked_index(r
->index
, &index_lock
,
626 COMMIT_LOCK
| SKIP_IF_UNCHANGED
))
628 * TRANSLATORS: %s will be "revert", "cherry-pick" or
631 return error(_("%s: Unable to write new index file"),
632 _(action_name(opts
)));
635 append_conflicts_hint(r
->index
, msgbuf
,
636 opts
->default_msg_cleanup
);
641 static struct object_id
*get_cache_tree_oid(struct index_state
*istate
)
643 if (!istate
->cache_tree
)
644 istate
->cache_tree
= cache_tree();
646 if (!cache_tree_fully_valid(istate
->cache_tree
))
647 if (cache_tree_update(istate
, 0)) {
648 error(_("unable to update cache tree"));
652 return &istate
->cache_tree
->oid
;
655 static int is_index_unchanged(struct repository
*r
)
657 struct object_id head_oid
, *cache_tree_oid
;
658 struct commit
*head_commit
;
659 struct index_state
*istate
= r
->index
;
661 if (!resolve_ref_unsafe("HEAD", RESOLVE_REF_READING
, &head_oid
, NULL
))
662 return error(_("could not resolve HEAD commit"));
664 head_commit
= lookup_commit(r
, &head_oid
);
667 * If head_commit is NULL, check_commit, called from
668 * lookup_commit, would have indicated that head_commit is not
669 * a commit object already. parse_commit() will return failure
670 * without further complaints in such a case. Otherwise, if
671 * the commit is invalid, parse_commit() will complain. So
672 * there is nothing for us to say here. Just return failure.
674 if (parse_commit(head_commit
))
677 if (!(cache_tree_oid
= get_cache_tree_oid(istate
)))
680 return oideq(cache_tree_oid
, get_commit_tree_oid(head_commit
));
683 static int write_author_script(const char *message
)
685 struct strbuf buf
= STRBUF_INIT
;
690 if (!*message
|| starts_with(message
, "\n")) {
692 /* Missing 'author' line? */
693 unlink(rebase_path_author_script());
695 } else if (skip_prefix(message
, "author ", &message
))
697 else if ((eol
= strchr(message
, '\n')))
702 strbuf_addstr(&buf
, "GIT_AUTHOR_NAME='");
703 while (*message
&& *message
!= '\n' && *message
!= '\r')
704 if (skip_prefix(message
, " <", &message
))
706 else if (*message
!= '\'')
707 strbuf_addch(&buf
, *(message
++));
709 strbuf_addf(&buf
, "'\\%c'", *(message
++));
710 strbuf_addstr(&buf
, "'\nGIT_AUTHOR_EMAIL='");
711 while (*message
&& *message
!= '\n' && *message
!= '\r')
712 if (skip_prefix(message
, "> ", &message
))
714 else if (*message
!= '\'')
715 strbuf_addch(&buf
, *(message
++));
717 strbuf_addf(&buf
, "'\\%c'", *(message
++));
718 strbuf_addstr(&buf
, "'\nGIT_AUTHOR_DATE='@");
719 while (*message
&& *message
!= '\n' && *message
!= '\r')
720 if (*message
!= '\'')
721 strbuf_addch(&buf
, *(message
++));
723 strbuf_addf(&buf
, "'\\%c'", *(message
++));
724 strbuf_addch(&buf
, '\'');
725 res
= write_message(buf
.buf
, buf
.len
, rebase_path_author_script(), 1);
726 strbuf_release(&buf
);
731 * Take a series of KEY='VALUE' lines where VALUE part is
732 * sq-quoted, and append <KEY, VALUE> at the end of the string list
734 static int parse_key_value_squoted(char *buf
, struct string_list
*list
)
737 struct string_list_item
*item
;
739 char *cp
= strchr(buf
, '=');
741 np
= strchrnul(buf
, '\n');
742 return error(_("no key present in '%.*s'"),
743 (int) (np
- buf
), buf
);
745 np
= strchrnul(cp
, '\n');
747 item
= string_list_append(list
, buf
);
749 buf
= np
+ (*np
== '\n');
753 return error(_("unable to dequote value of '%s'"),
755 item
->util
= xstrdup(cp
);
761 * Reads and parses the state directory's "author-script" file, and sets name,
762 * email and date accordingly.
763 * Returns 0 on success, -1 if the file could not be parsed.
765 * The author script is of the format:
767 * GIT_AUTHOR_NAME='$author_name'
768 * GIT_AUTHOR_EMAIL='$author_email'
769 * GIT_AUTHOR_DATE='$author_date'
771 * where $author_name, $author_email and $author_date are quoted. We are strict
772 * with our parsing, as the file was meant to be eval'd in the now-removed
773 * git-am.sh/git-rebase--interactive.sh scripts, and thus if the file differs
774 * from what this function expects, it is better to bail out than to do
775 * something that the user does not expect.
777 int read_author_script(const char *path
, char **name
, char **email
, char **date
,
780 struct strbuf buf
= STRBUF_INIT
;
781 struct string_list kv
= STRING_LIST_INIT_DUP
;
782 int retval
= -1; /* assume failure */
783 int i
, name_i
= -2, email_i
= -2, date_i
= -2, err
= 0;
785 if (strbuf_read_file(&buf
, path
, 256) <= 0) {
786 strbuf_release(&buf
);
787 if (errno
== ENOENT
&& allow_missing
)
790 return error_errno(_("could not open '%s' for reading"),
794 if (parse_key_value_squoted(buf
.buf
, &kv
))
797 for (i
= 0; i
< kv
.nr
; i
++) {
798 if (!strcmp(kv
.items
[i
].string
, "GIT_AUTHOR_NAME")) {
800 name_i
= error(_("'GIT_AUTHOR_NAME' already given"));
803 } else if (!strcmp(kv
.items
[i
].string
, "GIT_AUTHOR_EMAIL")) {
805 email_i
= error(_("'GIT_AUTHOR_EMAIL' already given"));
808 } else if (!strcmp(kv
.items
[i
].string
, "GIT_AUTHOR_DATE")) {
810 date_i
= error(_("'GIT_AUTHOR_DATE' already given"));
814 err
= error(_("unknown variable '%s'"),
819 error(_("missing 'GIT_AUTHOR_NAME'"));
821 error(_("missing 'GIT_AUTHOR_EMAIL'"));
823 error(_("missing 'GIT_AUTHOR_DATE'"));
824 if (date_i
< 0 || email_i
< 0 || date_i
< 0 || err
)
826 *name
= kv
.items
[name_i
].util
;
827 *email
= kv
.items
[email_i
].util
;
828 *date
= kv
.items
[date_i
].util
;
831 string_list_clear(&kv
, !!retval
);
832 strbuf_release(&buf
);
837 * Read a GIT_AUTHOR_NAME, GIT_AUTHOR_EMAIL AND GIT_AUTHOR_DATE from a
838 * file with shell quoting into struct argv_array. Returns -1 on
839 * error, 0 otherwise.
841 static int read_env_script(struct argv_array
*env
)
843 char *name
, *email
, *date
;
845 if (read_author_script(rebase_path_author_script(),
846 &name
, &email
, &date
, 0))
849 argv_array_pushf(env
, "GIT_AUTHOR_NAME=%s", name
);
850 argv_array_pushf(env
, "GIT_AUTHOR_EMAIL=%s", email
);
851 argv_array_pushf(env
, "GIT_AUTHOR_DATE=%s", date
);
859 static char *get_author(const char *message
)
864 a
= find_commit_header(message
, "author", &len
);
866 return xmemdupz(a
, len
);
871 /* Read author-script and return an ident line (author <email> timestamp) */
872 static const char *read_author_ident(struct strbuf
*buf
)
874 struct strbuf out
= STRBUF_INIT
;
875 char *name
, *email
, *date
;
877 if (read_author_script(rebase_path_author_script(),
878 &name
, &email
, &date
, 0))
881 /* validate date since fmt_ident() will die() on bad value */
882 if (parse_date(date
, &out
)){
883 warning(_("invalid date format '%s' in '%s'"),
884 date
, rebase_path_author_script());
885 strbuf_release(&out
);
890 strbuf_addstr(&out
, fmt_ident(name
, email
, WANT_AUTHOR_IDENT
, date
, 0));
891 strbuf_swap(buf
, &out
);
892 strbuf_release(&out
);
899 static const char staged_changes_advice
[] =
900 N_("you have staged changes in your working tree\n"
901 "If these changes are meant to be squashed into the previous commit, run:\n"
903 " git commit --amend %s\n"
905 "If they are meant to go into a new commit, run:\n"
909 "In both cases, once you're done, continue with:\n"
911 " git rebase --continue\n");
913 #define ALLOW_EMPTY (1<<0)
914 #define EDIT_MSG (1<<1)
915 #define AMEND_MSG (1<<2)
916 #define CLEANUP_MSG (1<<3)
917 #define VERIFY_MSG (1<<4)
918 #define CREATE_ROOT_COMMIT (1<<5)
920 static int run_command_silent_on_success(struct child_process
*cmd
)
922 struct strbuf buf
= STRBUF_INIT
;
925 cmd
->stdout_to_stderr
= 1;
926 rc
= pipe_command(cmd
,
932 fputs(buf
.buf
, stderr
);
933 strbuf_release(&buf
);
938 * If we are cherry-pick, and if the merge did not result in
939 * hand-editing, we will hit this commit and inherit the original
940 * author date and name.
942 * If we are revert, or if our cherry-pick results in a hand merge,
943 * we had better say that the current user is responsible for that.
945 * An exception is when run_git_commit() is called during an
946 * interactive rebase: in that case, we will want to retain the
949 static int run_git_commit(struct repository
*r
,
951 struct replay_opts
*opts
,
954 struct child_process cmd
= CHILD_PROCESS_INIT
;
956 if ((flags
& CREATE_ROOT_COMMIT
) && !(flags
& AMEND_MSG
)) {
957 struct strbuf msg
= STRBUF_INIT
, script
= STRBUF_INIT
;
958 const char *author
= NULL
;
959 struct object_id root_commit
, *cache_tree_oid
;
962 if (is_rebase_i(opts
)) {
963 author
= read_author_ident(&script
);
965 strbuf_release(&script
);
971 BUG("root commit without message");
973 if (!(cache_tree_oid
= get_cache_tree_oid(r
->index
)))
977 res
= strbuf_read_file(&msg
, defmsg
, 0);
980 res
= error_errno(_("could not read '%s'"), defmsg
);
982 res
= commit_tree(msg
.buf
, msg
.len
, cache_tree_oid
,
983 NULL
, &root_commit
, author
,
986 strbuf_release(&msg
);
987 strbuf_release(&script
);
989 update_ref(NULL
, "CHERRY_PICK_HEAD", &root_commit
, NULL
,
990 REF_NO_DEREF
, UPDATE_REFS_MSG_ON_ERR
);
991 res
= update_ref(NULL
, "HEAD", &root_commit
, NULL
, 0,
992 UPDATE_REFS_MSG_ON_ERR
);
994 return res
< 0 ? error(_("writing root commit")) : 0;
999 if (is_rebase_i(opts
) && read_env_script(&cmd
.env_array
)) {
1000 const char *gpg_opt
= gpg_sign_opt_quoted(opts
);
1002 return error(_(staged_changes_advice
),
1006 argv_array_push(&cmd
.args
, "commit");
1008 if (!(flags
& VERIFY_MSG
))
1009 argv_array_push(&cmd
.args
, "-n");
1010 if ((flags
& AMEND_MSG
))
1011 argv_array_push(&cmd
.args
, "--amend");
1013 argv_array_pushf(&cmd
.args
, "-S%s", opts
->gpg_sign
);
1015 argv_array_pushl(&cmd
.args
, "-F", defmsg
, NULL
);
1016 else if (!(flags
& EDIT_MSG
))
1017 argv_array_pushl(&cmd
.args
, "-C", "HEAD", NULL
);
1018 if ((flags
& CLEANUP_MSG
))
1019 argv_array_push(&cmd
.args
, "--cleanup=strip");
1020 if ((flags
& EDIT_MSG
))
1021 argv_array_push(&cmd
.args
, "-e");
1022 else if (!(flags
& CLEANUP_MSG
) &&
1023 !opts
->signoff
&& !opts
->record_origin
&&
1024 !opts
->explicit_cleanup
)
1025 argv_array_push(&cmd
.args
, "--cleanup=verbatim");
1027 if ((flags
& ALLOW_EMPTY
))
1028 argv_array_push(&cmd
.args
, "--allow-empty");
1030 if (!(flags
& EDIT_MSG
))
1031 argv_array_push(&cmd
.args
, "--allow-empty-message");
1033 if (is_rebase_i(opts
) && !(flags
& EDIT_MSG
))
1034 return run_command_silent_on_success(&cmd
);
1036 return run_command(&cmd
);
1039 static int rest_is_empty(const struct strbuf
*sb
, int start
)
1044 /* Check if the rest is just whitespace and Signed-off-by's. */
1045 for (i
= start
; i
< sb
->len
; i
++) {
1046 nl
= memchr(sb
->buf
+ i
, '\n', sb
->len
- i
);
1052 if (strlen(sign_off_header
) <= eol
- i
&&
1053 starts_with(sb
->buf
+ i
, sign_off_header
)) {
1058 if (!isspace(sb
->buf
[i
++]))
1065 void cleanup_message(struct strbuf
*msgbuf
,
1066 enum commit_msg_cleanup_mode cleanup_mode
, int verbose
)
1068 if (verbose
|| /* Truncate the message just before the diff, if any. */
1069 cleanup_mode
== COMMIT_MSG_CLEANUP_SCISSORS
)
1070 strbuf_setlen(msgbuf
, wt_status_locate_end(msgbuf
->buf
, msgbuf
->len
));
1071 if (cleanup_mode
!= COMMIT_MSG_CLEANUP_NONE
)
1072 strbuf_stripspace(msgbuf
, cleanup_mode
== COMMIT_MSG_CLEANUP_ALL
);
1076 * Find out if the message in the strbuf contains only whitespace and
1077 * Signed-off-by lines.
1079 int message_is_empty(const struct strbuf
*sb
,
1080 enum commit_msg_cleanup_mode cleanup_mode
)
1082 if (cleanup_mode
== COMMIT_MSG_CLEANUP_NONE
&& sb
->len
)
1084 return rest_is_empty(sb
, 0);
1088 * See if the user edited the message in the editor or left what
1089 * was in the template intact
1091 int template_untouched(const struct strbuf
*sb
, const char *template_file
,
1092 enum commit_msg_cleanup_mode cleanup_mode
)
1094 struct strbuf tmpl
= STRBUF_INIT
;
1097 if (cleanup_mode
== COMMIT_MSG_CLEANUP_NONE
&& sb
->len
)
1100 if (!template_file
|| strbuf_read_file(&tmpl
, template_file
, 0) <= 0)
1103 strbuf_stripspace(&tmpl
, cleanup_mode
== COMMIT_MSG_CLEANUP_ALL
);
1104 if (!skip_prefix(sb
->buf
, tmpl
.buf
, &start
))
1106 strbuf_release(&tmpl
);
1107 return rest_is_empty(sb
, start
- sb
->buf
);
1110 int update_head_with_reflog(const struct commit
*old_head
,
1111 const struct object_id
*new_head
,
1112 const char *action
, const struct strbuf
*msg
,
1115 struct ref_transaction
*transaction
;
1116 struct strbuf sb
= STRBUF_INIT
;
1121 strbuf_addstr(&sb
, action
);
1122 strbuf_addstr(&sb
, ": ");
1125 nl
= strchr(msg
->buf
, '\n');
1127 strbuf_add(&sb
, msg
->buf
, nl
+ 1 - msg
->buf
);
1129 strbuf_addbuf(&sb
, msg
);
1130 strbuf_addch(&sb
, '\n');
1133 transaction
= ref_transaction_begin(err
);
1135 ref_transaction_update(transaction
, "HEAD", new_head
,
1136 old_head
? &old_head
->object
.oid
: &null_oid
,
1138 ref_transaction_commit(transaction
, err
)) {
1141 ref_transaction_free(transaction
);
1142 strbuf_release(&sb
);
1147 static int run_rewrite_hook(const struct object_id
*oldoid
,
1148 const struct object_id
*newoid
)
1150 struct child_process proc
= CHILD_PROCESS_INIT
;
1151 const char *argv
[3];
1153 struct strbuf sb
= STRBUF_INIT
;
1155 argv
[0] = find_hook("post-rewrite");
1164 proc
.stdout_to_stderr
= 1;
1165 proc
.trace2_hook_name
= "post-rewrite";
1167 code
= start_command(&proc
);
1170 strbuf_addf(&sb
, "%s %s\n", oid_to_hex(oldoid
), oid_to_hex(newoid
));
1171 sigchain_push(SIGPIPE
, SIG_IGN
);
1172 write_in_full(proc
.in
, sb
.buf
, sb
.len
);
1174 strbuf_release(&sb
);
1175 sigchain_pop(SIGPIPE
);
1176 return finish_command(&proc
);
1179 void commit_post_rewrite(struct repository
*r
,
1180 const struct commit
*old_head
,
1181 const struct object_id
*new_head
)
1183 struct notes_rewrite_cfg
*cfg
;
1185 cfg
= init_copy_notes_for_rewrite("amend");
1187 /* we are amending, so old_head is not NULL */
1188 copy_note_for_rewrite(cfg
, &old_head
->object
.oid
, new_head
);
1189 finish_copy_notes_for_rewrite(r
, cfg
, "Notes added by 'git commit --amend'");
1191 run_rewrite_hook(&old_head
->object
.oid
, new_head
);
1194 static int run_prepare_commit_msg_hook(struct repository
*r
,
1198 struct argv_array hook_env
= ARGV_ARRAY_INIT
;
1202 name
= git_path_commit_editmsg();
1203 if (write_message(msg
->buf
, msg
->len
, name
, 0))
1206 argv_array_pushf(&hook_env
, "GIT_INDEX_FILE=%s", r
->index_file
);
1207 argv_array_push(&hook_env
, "GIT_EDITOR=:");
1209 ret
= run_hook_le(hook_env
.argv
, "prepare-commit-msg", name
,
1210 "commit", commit
, NULL
);
1212 ret
= run_hook_le(hook_env
.argv
, "prepare-commit-msg", name
,
1215 ret
= error(_("'prepare-commit-msg' hook failed"));
1216 argv_array_clear(&hook_env
);
1221 static const char implicit_ident_advice_noconfig
[] =
1222 N_("Your name and email address were configured automatically based\n"
1223 "on your username and hostname. Please check that they are accurate.\n"
1224 "You can suppress this message by setting them explicitly. Run the\n"
1225 "following command and follow the instructions in your editor to edit\n"
1226 "your configuration file:\n"
1228 " git config --global --edit\n"
1230 "After doing this, you may fix the identity used for this commit with:\n"
1232 " git commit --amend --reset-author\n");
1234 static const char implicit_ident_advice_config
[] =
1235 N_("Your name and email address were configured automatically based\n"
1236 "on your username and hostname. Please check that they are accurate.\n"
1237 "You can suppress this message by setting them explicitly:\n"
1239 " git config --global user.name \"Your Name\"\n"
1240 " git config --global user.email you@example.com\n"
1242 "After doing this, you may fix the identity used for this commit with:\n"
1244 " git commit --amend --reset-author\n");
1246 static const char *implicit_ident_advice(void)
1248 char *user_config
= expand_user_path("~/.gitconfig", 0);
1249 char *xdg_config
= xdg_config_home("config");
1250 int config_exists
= file_exists(user_config
) || file_exists(xdg_config
);
1256 return _(implicit_ident_advice_config
);
1258 return _(implicit_ident_advice_noconfig
);
1262 void print_commit_summary(struct repository
*r
,
1264 const struct object_id
*oid
,
1267 struct rev_info rev
;
1268 struct commit
*commit
;
1269 struct strbuf format
= STRBUF_INIT
;
1271 struct pretty_print_context pctx
= {0};
1272 struct strbuf author_ident
= STRBUF_INIT
;
1273 struct strbuf committer_ident
= STRBUF_INIT
;
1275 commit
= lookup_commit(r
, oid
);
1277 die(_("couldn't look up newly created commit"));
1278 if (parse_commit(commit
))
1279 die(_("could not parse newly created commit"));
1281 strbuf_addstr(&format
, "format:%h] %s");
1283 format_commit_message(commit
, "%an <%ae>", &author_ident
, &pctx
);
1284 format_commit_message(commit
, "%cn <%ce>", &committer_ident
, &pctx
);
1285 if (strbuf_cmp(&author_ident
, &committer_ident
)) {
1286 strbuf_addstr(&format
, "\n Author: ");
1287 strbuf_addbuf_percentquote(&format
, &author_ident
);
1289 if (flags
& SUMMARY_SHOW_AUTHOR_DATE
) {
1290 struct strbuf date
= STRBUF_INIT
;
1292 format_commit_message(commit
, "%ad", &date
, &pctx
);
1293 strbuf_addstr(&format
, "\n Date: ");
1294 strbuf_addbuf_percentquote(&format
, &date
);
1295 strbuf_release(&date
);
1297 if (!committer_ident_sufficiently_given()) {
1298 strbuf_addstr(&format
, "\n Committer: ");
1299 strbuf_addbuf_percentquote(&format
, &committer_ident
);
1300 if (advice_implicit_identity
) {
1301 strbuf_addch(&format
, '\n');
1302 strbuf_addstr(&format
, implicit_ident_advice());
1305 strbuf_release(&author_ident
);
1306 strbuf_release(&committer_ident
);
1308 repo_init_revisions(r
, &rev
, prefix
);
1309 setup_revisions(0, NULL
, &rev
, NULL
);
1312 rev
.diffopt
.output_format
=
1313 DIFF_FORMAT_SHORTSTAT
| DIFF_FORMAT_SUMMARY
;
1315 rev
.verbose_header
= 1;
1316 rev
.show_root_diff
= 1;
1317 get_commit_format(format
.buf
, &rev
);
1318 rev
.always_show_header
= 0;
1319 rev
.diffopt
.detect_rename
= DIFF_DETECT_RENAME
;
1320 rev
.diffopt
.break_opt
= 0;
1321 diff_setup_done(&rev
.diffopt
);
1323 head
= resolve_ref_unsafe("HEAD", 0, NULL
, NULL
);
1325 die_errno(_("unable to resolve HEAD after creating commit"));
1326 if (!strcmp(head
, "HEAD"))
1327 head
= _("detached HEAD");
1329 skip_prefix(head
, "refs/heads/", &head
);
1330 printf("[%s%s ", head
, (flags
& SUMMARY_INITIAL_COMMIT
) ?
1331 _(" (root-commit)") : "");
1333 if (!log_tree_commit(&rev
, commit
)) {
1334 rev
.always_show_header
= 1;
1335 rev
.use_terminator
= 1;
1336 log_tree_commit(&rev
, commit
);
1339 strbuf_release(&format
);
1342 static int parse_head(struct repository
*r
, struct commit
**head
)
1344 struct commit
*current_head
;
1345 struct object_id oid
;
1347 if (get_oid("HEAD", &oid
)) {
1348 current_head
= NULL
;
1350 current_head
= lookup_commit_reference(r
, &oid
);
1352 return error(_("could not parse HEAD"));
1353 if (!oideq(&oid
, ¤t_head
->object
.oid
)) {
1354 warning(_("HEAD %s is not a commit!"),
1357 if (parse_commit(current_head
))
1358 return error(_("could not parse HEAD commit"));
1360 *head
= current_head
;
1366 * Try to commit without forking 'git commit'. In some cases we need
1367 * to run 'git commit' to display an error message
1370 * -1 - error unable to commit
1372 * 1 - run 'git commit'
1374 static int try_to_commit(struct repository
*r
,
1375 struct strbuf
*msg
, const char *author
,
1376 struct replay_opts
*opts
, unsigned int flags
,
1377 struct object_id
*oid
)
1379 struct object_id tree
;
1380 struct commit
*current_head
;
1381 struct commit_list
*parents
= NULL
;
1382 struct commit_extra_header
*extra
= NULL
;
1383 struct strbuf err
= STRBUF_INIT
;
1384 struct strbuf commit_msg
= STRBUF_INIT
;
1385 char *amend_author
= NULL
;
1386 const char *hook_commit
= NULL
;
1387 enum commit_msg_cleanup_mode cleanup
;
1390 if (parse_head(r
, ¤t_head
))
1393 if (flags
& AMEND_MSG
) {
1394 const char *exclude_gpgsig
[] = { "gpgsig", NULL
};
1395 const char *out_enc
= get_commit_output_encoding();
1396 const char *message
= logmsg_reencode(current_head
, NULL
,
1400 const char *orig_message
= NULL
;
1402 find_commit_subject(message
, &orig_message
);
1404 strbuf_addstr(msg
, orig_message
);
1405 hook_commit
= "HEAD";
1407 author
= amend_author
= get_author(message
);
1408 unuse_commit_buffer(current_head
, message
);
1410 res
= error(_("unable to parse commit author"));
1413 parents
= copy_commit_list(current_head
->parents
);
1414 extra
= read_commit_extra_headers(current_head
, exclude_gpgsig
);
1415 } else if (current_head
) {
1416 commit_list_insert(current_head
, &parents
);
1419 if (write_index_as_tree(&tree
, r
->index
, r
->index_file
, 0, NULL
)) {
1420 res
= error(_("git write-tree failed to write a tree"));
1424 if (!(flags
& ALLOW_EMPTY
) && oideq(current_head
?
1425 get_commit_tree_oid(current_head
) :
1426 the_hash_algo
->empty_tree
, &tree
)) {
1427 res
= 1; /* run 'git commit' to display error message */
1431 if (find_hook("prepare-commit-msg")) {
1432 res
= run_prepare_commit_msg_hook(r
, msg
, hook_commit
);
1435 if (strbuf_read_file(&commit_msg
, git_path_commit_editmsg(),
1437 res
= error_errno(_("unable to read commit message "
1439 git_path_commit_editmsg());
1445 if (flags
& CLEANUP_MSG
)
1446 cleanup
= COMMIT_MSG_CLEANUP_ALL
;
1447 else if ((opts
->signoff
|| opts
->record_origin
) &&
1448 !opts
->explicit_cleanup
)
1449 cleanup
= COMMIT_MSG_CLEANUP_SPACE
;
1451 cleanup
= opts
->default_msg_cleanup
;
1453 if (cleanup
!= COMMIT_MSG_CLEANUP_NONE
)
1454 strbuf_stripspace(msg
, cleanup
== COMMIT_MSG_CLEANUP_ALL
);
1455 if ((flags
& EDIT_MSG
) && message_is_empty(msg
, cleanup
)) {
1456 res
= 1; /* run 'git commit' to display error message */
1462 if (commit_tree_extended(msg
->buf
, msg
->len
, &tree
, parents
,
1463 oid
, author
, opts
->gpg_sign
, extra
)) {
1464 res
= error(_("failed to write commit object"));
1468 if (update_head_with_reflog(current_head
, oid
,
1469 getenv("GIT_REFLOG_ACTION"), msg
, &err
)) {
1470 res
= error("%s", err
.buf
);
1474 if (flags
& AMEND_MSG
)
1475 commit_post_rewrite(r
, current_head
, oid
);
1478 free_commit_extra_headers(extra
);
1479 strbuf_release(&err
);
1480 strbuf_release(&commit_msg
);
1486 static int do_commit(struct repository
*r
,
1487 const char *msg_file
, const char *author
,
1488 struct replay_opts
*opts
, unsigned int flags
)
1492 if (!(flags
& EDIT_MSG
) && !(flags
& VERIFY_MSG
) &&
1493 !(flags
& CREATE_ROOT_COMMIT
)) {
1494 struct object_id oid
;
1495 struct strbuf sb
= STRBUF_INIT
;
1497 if (msg_file
&& strbuf_read_file(&sb
, msg_file
, 2048) < 0)
1498 return error_errno(_("unable to read commit message "
1502 res
= try_to_commit(r
, msg_file
? &sb
: NULL
,
1503 author
, opts
, flags
, &oid
);
1504 strbuf_release(&sb
);
1506 unlink(git_path_cherry_pick_head(r
));
1507 unlink(git_path_merge_msg(r
));
1508 if (!is_rebase_i(opts
))
1509 print_commit_summary(r
, NULL
, &oid
,
1510 SUMMARY_SHOW_AUTHOR_DATE
);
1515 return run_git_commit(r
, msg_file
, opts
, flags
);
1520 static int is_original_commit_empty(struct commit
*commit
)
1522 const struct object_id
*ptree_oid
;
1524 if (parse_commit(commit
))
1525 return error(_("could not parse commit %s"),
1526 oid_to_hex(&commit
->object
.oid
));
1527 if (commit
->parents
) {
1528 struct commit
*parent
= commit
->parents
->item
;
1529 if (parse_commit(parent
))
1530 return error(_("could not parse parent commit %s"),
1531 oid_to_hex(&parent
->object
.oid
));
1532 ptree_oid
= get_commit_tree_oid(parent
);
1534 ptree_oid
= the_hash_algo
->empty_tree
; /* commit is root */
1537 return oideq(ptree_oid
, get_commit_tree_oid(commit
));
1541 * Do we run "git commit" with "--allow-empty"?
1543 static int allow_empty(struct repository
*r
,
1544 struct replay_opts
*opts
,
1545 struct commit
*commit
)
1547 int index_unchanged
, empty_commit
;
1552 * (1) we do not allow empty at all and error out.
1554 * (2) we allow ones that were initially empty, but
1555 * forbid the ones that become empty;
1557 * (3) we allow both.
1559 if (!opts
->allow_empty
)
1560 return 0; /* let "git commit" barf as necessary */
1562 index_unchanged
= is_index_unchanged(r
);
1563 if (index_unchanged
< 0)
1564 return index_unchanged
;
1565 if (!index_unchanged
)
1566 return 0; /* we do not have to say --allow-empty */
1568 if (opts
->keep_redundant_commits
)
1571 empty_commit
= is_original_commit_empty(commit
);
1572 if (empty_commit
< 0)
1573 return empty_commit
;
1583 } todo_command_info
[] = {
1600 static const char *command_to_string(const enum todo_command command
)
1602 if (command
< TODO_COMMENT
)
1603 return todo_command_info
[command
].str
;
1604 die(_("unknown command: %d"), command
);
1607 static char command_to_char(const enum todo_command command
)
1609 if (command
< TODO_COMMENT
&& todo_command_info
[command
].c
)
1610 return todo_command_info
[command
].c
;
1611 return comment_line_char
;
1614 static int is_noop(const enum todo_command command
)
1616 return TODO_NOOP
<= command
;
1619 static int is_fixup(enum todo_command command
)
1621 return command
== TODO_FIXUP
|| command
== TODO_SQUASH
;
1624 /* Does this command create a (non-merge) commit? */
1625 static int is_pick_or_similar(enum todo_command command
)
1640 static int update_squash_messages(struct repository
*r
,
1641 enum todo_command command
,
1642 struct commit
*commit
,
1643 struct replay_opts
*opts
)
1645 struct strbuf buf
= STRBUF_INIT
;
1647 const char *message
, *body
;
1649 if (opts
->current_fixup_count
> 0) {
1650 struct strbuf header
= STRBUF_INIT
;
1653 if (strbuf_read_file(&buf
, rebase_path_squash_msg(), 9) <= 0)
1654 return error(_("could not read '%s'"),
1655 rebase_path_squash_msg());
1657 eol
= buf
.buf
[0] != comment_line_char
?
1658 buf
.buf
: strchrnul(buf
.buf
, '\n');
1660 strbuf_addf(&header
, "%c ", comment_line_char
);
1661 strbuf_addf(&header
, _("This is a combination of %d commits."),
1662 opts
->current_fixup_count
+ 2);
1663 strbuf_splice(&buf
, 0, eol
- buf
.buf
, header
.buf
, header
.len
);
1664 strbuf_release(&header
);
1666 struct object_id head
;
1667 struct commit
*head_commit
;
1668 const char *head_message
, *body
;
1670 if (get_oid("HEAD", &head
))
1671 return error(_("need a HEAD to fixup"));
1672 if (!(head_commit
= lookup_commit_reference(r
, &head
)))
1673 return error(_("could not read HEAD"));
1674 if (!(head_message
= get_commit_buffer(head_commit
, NULL
)))
1675 return error(_("could not read HEAD's commit message"));
1677 find_commit_subject(head_message
, &body
);
1678 if (write_message(body
, strlen(body
),
1679 rebase_path_fixup_msg(), 0)) {
1680 unuse_commit_buffer(head_commit
, head_message
);
1681 return error(_("cannot write '%s'"),
1682 rebase_path_fixup_msg());
1685 strbuf_addf(&buf
, "%c ", comment_line_char
);
1686 strbuf_addf(&buf
, _("This is a combination of %d commits."), 2);
1687 strbuf_addf(&buf
, "\n%c ", comment_line_char
);
1688 strbuf_addstr(&buf
, _("This is the 1st commit message:"));
1689 strbuf_addstr(&buf
, "\n\n");
1690 strbuf_addstr(&buf
, body
);
1692 unuse_commit_buffer(head_commit
, head_message
);
1695 if (!(message
= get_commit_buffer(commit
, NULL
)))
1696 return error(_("could not read commit message of %s"),
1697 oid_to_hex(&commit
->object
.oid
));
1698 find_commit_subject(message
, &body
);
1700 if (command
== TODO_SQUASH
) {
1701 unlink(rebase_path_fixup_msg());
1702 strbuf_addf(&buf
, "\n%c ", comment_line_char
);
1703 strbuf_addf(&buf
, _("This is the commit message #%d:"),
1704 ++opts
->current_fixup_count
+ 1);
1705 strbuf_addstr(&buf
, "\n\n");
1706 strbuf_addstr(&buf
, body
);
1707 } else if (command
== TODO_FIXUP
) {
1708 strbuf_addf(&buf
, "\n%c ", comment_line_char
);
1709 strbuf_addf(&buf
, _("The commit message #%d will be skipped:"),
1710 ++opts
->current_fixup_count
+ 1);
1711 strbuf_addstr(&buf
, "\n\n");
1712 strbuf_add_commented_lines(&buf
, body
, strlen(body
));
1714 return error(_("unknown command: %d"), command
);
1715 unuse_commit_buffer(commit
, message
);
1717 res
= write_message(buf
.buf
, buf
.len
, rebase_path_squash_msg(), 0);
1718 strbuf_release(&buf
);
1721 strbuf_addf(&opts
->current_fixups
, "%s%s %s",
1722 opts
->current_fixups
.len
? "\n" : "",
1723 command_to_string(command
),
1724 oid_to_hex(&commit
->object
.oid
));
1725 res
= write_message(opts
->current_fixups
.buf
,
1726 opts
->current_fixups
.len
,
1727 rebase_path_current_fixups(), 0);
1733 static void flush_rewritten_pending(void)
1735 struct strbuf buf
= STRBUF_INIT
;
1736 struct object_id newoid
;
1739 if (strbuf_read_file(&buf
, rebase_path_rewritten_pending(), (GIT_MAX_HEXSZ
+ 1) * 2) > 0 &&
1740 !get_oid("HEAD", &newoid
) &&
1741 (out
= fopen_or_warn(rebase_path_rewritten_list(), "a"))) {
1742 char *bol
= buf
.buf
, *eol
;
1745 eol
= strchrnul(bol
, '\n');
1746 fprintf(out
, "%.*s %s\n", (int)(eol
- bol
),
1747 bol
, oid_to_hex(&newoid
));
1753 unlink(rebase_path_rewritten_pending());
1755 strbuf_release(&buf
);
1758 static void record_in_rewritten(struct object_id
*oid
,
1759 enum todo_command next_command
)
1761 FILE *out
= fopen_or_warn(rebase_path_rewritten_pending(), "a");
1766 fprintf(out
, "%s\n", oid_to_hex(oid
));
1769 if (!is_fixup(next_command
))
1770 flush_rewritten_pending();
1773 static int do_pick_commit(struct repository
*r
,
1774 enum todo_command command
,
1775 struct commit
*commit
,
1776 struct replay_opts
*opts
,
1779 unsigned int flags
= opts
->edit
? EDIT_MSG
: 0;
1780 const char *msg_file
= opts
->edit
? NULL
: git_path_merge_msg(r
);
1781 struct object_id head
;
1782 struct commit
*base
, *next
, *parent
;
1783 const char *base_label
, *next_label
;
1784 char *author
= NULL
;
1785 struct commit_message msg
= { NULL
, NULL
, NULL
, NULL
};
1786 struct strbuf msgbuf
= STRBUF_INIT
;
1787 int res
, unborn
= 0, allow
;
1789 if (opts
->no_commit
) {
1791 * We do not intend to commit immediately. We just want to
1792 * merge the differences in, so let's compute the tree
1793 * that represents the "current" state for merge-recursive
1796 if (write_index_as_tree(&head
, r
->index
, r
->index_file
, 0, NULL
))
1797 return error(_("your index file is unmerged."));
1799 unborn
= get_oid("HEAD", &head
);
1800 /* Do we want to generate a root commit? */
1801 if (is_pick_or_similar(command
) && opts
->have_squash_onto
&&
1802 oideq(&head
, &opts
->squash_onto
)) {
1803 if (is_fixup(command
))
1804 return error(_("cannot fixup root commit"));
1805 flags
|= CREATE_ROOT_COMMIT
;
1808 oidcpy(&head
, the_hash_algo
->empty_tree
);
1809 if (index_differs_from(r
, unborn
? empty_tree_oid_hex() : "HEAD",
1811 return error_dirty_index(r
, opts
);
1813 discard_index(r
->index
);
1815 if (!commit
->parents
)
1817 else if (commit
->parents
->next
) {
1818 /* Reverting or cherry-picking a merge commit */
1820 struct commit_list
*p
;
1822 if (!opts
->mainline
)
1823 return error(_("commit %s is a merge but no -m option was given."),
1824 oid_to_hex(&commit
->object
.oid
));
1826 for (cnt
= 1, p
= commit
->parents
;
1827 cnt
!= opts
->mainline
&& p
;
1830 if (cnt
!= opts
->mainline
|| !p
)
1831 return error(_("commit %s does not have parent %d"),
1832 oid_to_hex(&commit
->object
.oid
), opts
->mainline
);
1834 } else if (1 < opts
->mainline
)
1836 * Non-first parent explicitly specified as mainline for
1839 return error(_("commit %s does not have parent %d"),
1840 oid_to_hex(&commit
->object
.oid
), opts
->mainline
);
1842 parent
= commit
->parents
->item
;
1844 if (get_message(commit
, &msg
) != 0)
1845 return error(_("cannot get commit message for %s"),
1846 oid_to_hex(&commit
->object
.oid
));
1848 if (opts
->allow_ff
&& !is_fixup(command
) &&
1849 ((parent
&& oideq(&parent
->object
.oid
, &head
)) ||
1850 (!parent
&& unborn
))) {
1851 if (is_rebase_i(opts
))
1852 write_author_script(msg
.message
);
1853 res
= fast_forward_to(r
, &commit
->object
.oid
, &head
, unborn
,
1855 if (res
|| command
!= TODO_REWORD
)
1857 flags
|= EDIT_MSG
| AMEND_MSG
| VERIFY_MSG
;
1859 goto fast_forward_edit
;
1861 if (parent
&& parse_commit(parent
) < 0)
1862 /* TRANSLATORS: The first %s will be a "todo" command like
1863 "revert" or "pick", the second %s a SHA1. */
1864 return error(_("%s: cannot parse parent commit %s"),
1865 command_to_string(command
),
1866 oid_to_hex(&parent
->object
.oid
));
1869 * "commit" is an existing commit. We would want to apply
1870 * the difference it introduces since its first parent "prev"
1871 * on top of the current HEAD if we are cherry-pick. Or the
1872 * reverse of it if we are revert.
1875 if (command
== TODO_REVERT
) {
1877 base_label
= msg
.label
;
1879 next_label
= msg
.parent_label
;
1880 strbuf_addstr(&msgbuf
, "Revert \"");
1881 strbuf_addstr(&msgbuf
, msg
.subject
);
1882 strbuf_addstr(&msgbuf
, "\"\n\nThis reverts commit ");
1883 strbuf_addstr(&msgbuf
, oid_to_hex(&commit
->object
.oid
));
1885 if (commit
->parents
&& commit
->parents
->next
) {
1886 strbuf_addstr(&msgbuf
, ", reversing\nchanges made to ");
1887 strbuf_addstr(&msgbuf
, oid_to_hex(&parent
->object
.oid
));
1889 strbuf_addstr(&msgbuf
, ".\n");
1894 base_label
= msg
.parent_label
;
1896 next_label
= msg
.label
;
1898 /* Append the commit log message to msgbuf. */
1899 if (find_commit_subject(msg
.message
, &p
))
1900 strbuf_addstr(&msgbuf
, p
);
1902 if (opts
->record_origin
) {
1903 strbuf_complete_line(&msgbuf
);
1904 if (!has_conforming_footer(&msgbuf
, NULL
, 0))
1905 strbuf_addch(&msgbuf
, '\n');
1906 strbuf_addstr(&msgbuf
, cherry_picked_prefix
);
1907 strbuf_addstr(&msgbuf
, oid_to_hex(&commit
->object
.oid
));
1908 strbuf_addstr(&msgbuf
, ")\n");
1910 if (!is_fixup(command
))
1911 author
= get_author(msg
.message
);
1914 if (command
== TODO_REWORD
)
1915 flags
|= EDIT_MSG
| VERIFY_MSG
;
1916 else if (is_fixup(command
)) {
1917 if (update_squash_messages(r
, command
, commit
, opts
))
1921 msg_file
= rebase_path_squash_msg();
1922 else if (file_exists(rebase_path_fixup_msg())) {
1923 flags
|= CLEANUP_MSG
;
1924 msg_file
= rebase_path_fixup_msg();
1926 const char *dest
= git_path_squash_msg(r
);
1928 if (copy_file(dest
, rebase_path_squash_msg(), 0666))
1929 return error(_("could not rename '%s' to '%s'"),
1930 rebase_path_squash_msg(), dest
);
1931 unlink(git_path_merge_msg(r
));
1937 if (opts
->signoff
&& !is_fixup(command
))
1938 append_signoff(&msgbuf
, 0, 0);
1940 if (is_rebase_i(opts
) && write_author_script(msg
.message
) < 0)
1942 else if (!opts
->strategy
|| !strcmp(opts
->strategy
, "recursive") || command
== TODO_REVERT
) {
1943 res
= do_recursive_merge(r
, base
, next
, base_label
, next_label
,
1944 &head
, &msgbuf
, opts
);
1948 res
|= write_message(msgbuf
.buf
, msgbuf
.len
,
1949 git_path_merge_msg(r
), 0);
1951 struct commit_list
*common
= NULL
;
1952 struct commit_list
*remotes
= NULL
;
1954 res
= write_message(msgbuf
.buf
, msgbuf
.len
,
1955 git_path_merge_msg(r
), 0);
1957 commit_list_insert(base
, &common
);
1958 commit_list_insert(next
, &remotes
);
1959 res
|= try_merge_command(r
, opts
->strategy
,
1960 opts
->xopts_nr
, (const char **)opts
->xopts
,
1961 common
, oid_to_hex(&head
), remotes
);
1962 free_commit_list(common
);
1963 free_commit_list(remotes
);
1965 strbuf_release(&msgbuf
);
1968 * If the merge was clean or if it failed due to conflict, we write
1969 * CHERRY_PICK_HEAD for the subsequent invocation of commit to use.
1970 * However, if the merge did not even start, then we don't want to
1973 if (command
== TODO_PICK
&& !opts
->no_commit
&& (res
== 0 || res
== 1) &&
1974 update_ref(NULL
, "CHERRY_PICK_HEAD", &commit
->object
.oid
, NULL
,
1975 REF_NO_DEREF
, UPDATE_REFS_MSG_ON_ERR
))
1977 if (command
== TODO_REVERT
&& ((opts
->no_commit
&& res
== 0) || res
== 1) &&
1978 update_ref(NULL
, "REVERT_HEAD", &commit
->object
.oid
, NULL
,
1979 REF_NO_DEREF
, UPDATE_REFS_MSG_ON_ERR
))
1983 error(command
== TODO_REVERT
1984 ? _("could not revert %s... %s")
1985 : _("could not apply %s... %s"),
1986 short_commit_name(commit
), msg
.subject
);
1987 print_advice(r
, res
== 1, opts
);
1988 repo_rerere(r
, opts
->allow_rerere_auto
);
1992 allow
= allow_empty(r
, opts
, commit
);
1997 flags
|= ALLOW_EMPTY
;
1998 if (!opts
->no_commit
) {
2000 if (author
|| command
== TODO_REVERT
|| (flags
& AMEND_MSG
))
2001 res
= do_commit(r
, msg_file
, author
, opts
, flags
);
2003 res
= error(_("unable to parse commit author"));
2006 if (!res
&& final_fixup
) {
2007 unlink(rebase_path_fixup_msg());
2008 unlink(rebase_path_squash_msg());
2009 unlink(rebase_path_current_fixups());
2010 strbuf_reset(&opts
->current_fixups
);
2011 opts
->current_fixup_count
= 0;
2015 free_message(commit
, &msg
);
2017 update_abort_safety_file();
2022 static int prepare_revs(struct replay_opts
*opts
)
2025 * picking (but not reverting) ranges (but not individual revisions)
2026 * should be done in reverse
2028 if (opts
->action
== REPLAY_PICK
&& !opts
->revs
->no_walk
)
2029 opts
->revs
->reverse
^= 1;
2031 if (prepare_revision_walk(opts
->revs
))
2032 return error(_("revision walk setup failed"));
2037 static int read_and_refresh_cache(struct repository
*r
,
2038 struct replay_opts
*opts
)
2040 struct lock_file index_lock
= LOCK_INIT
;
2041 int index_fd
= repo_hold_locked_index(r
, &index_lock
, 0);
2042 if (repo_read_index(r
) < 0) {
2043 rollback_lock_file(&index_lock
);
2044 return error(_("git %s: failed to read the index"),
2045 _(action_name(opts
)));
2047 refresh_index(r
->index
, REFRESH_QUIET
|REFRESH_UNMERGED
, NULL
, NULL
, NULL
);
2048 if (index_fd
>= 0) {
2049 if (write_locked_index(r
->index
, &index_lock
,
2050 COMMIT_LOCK
| SKIP_IF_UNCHANGED
)) {
2051 return error(_("git %s: failed to refresh the index"),
2052 _(action_name(opts
)));
2058 enum todo_item_flags
{
2059 TODO_EDIT_MERGE_MSG
= 1
2062 void todo_list_release(struct todo_list
*todo_list
)
2064 strbuf_release(&todo_list
->buf
);
2065 FREE_AND_NULL(todo_list
->items
);
2066 todo_list
->nr
= todo_list
->alloc
= 0;
2069 static struct todo_item
*append_new_todo(struct todo_list
*todo_list
)
2071 ALLOC_GROW(todo_list
->items
, todo_list
->nr
+ 1, todo_list
->alloc
);
2072 return todo_list
->items
+ todo_list
->nr
++;
2075 const char *todo_item_get_arg(struct todo_list
*todo_list
,
2076 struct todo_item
*item
)
2078 return todo_list
->buf
.buf
+ item
->arg_offset
;
2081 static int is_command(enum todo_command command
, const char **bol
)
2083 const char *str
= todo_command_info
[command
].str
;
2084 const char nick
= todo_command_info
[command
].c
;
2085 const char *p
= *bol
+ 1;
2087 return skip_prefix(*bol
, str
, bol
) ||
2088 ((nick
&& **bol
== nick
) &&
2089 (*p
== ' ' || *p
== '\t' || *p
== '\n' || *p
== '\r' || !*p
) &&
2093 static int parse_insn_line(struct repository
*r
, struct todo_item
*item
,
2094 const char *buf
, const char *bol
, char *eol
)
2096 struct object_id commit_oid
;
2097 char *end_of_object_name
;
2098 int i
, saved
, status
, padding
;
2103 bol
+= strspn(bol
, " \t");
2105 if (bol
== eol
|| *bol
== '\r' || *bol
== comment_line_char
) {
2106 item
->command
= TODO_COMMENT
;
2107 item
->commit
= NULL
;
2108 item
->arg_offset
= bol
- buf
;
2109 item
->arg_len
= eol
- bol
;
2113 for (i
= 0; i
< TODO_COMMENT
; i
++)
2114 if (is_command(i
, &bol
)) {
2118 if (i
>= TODO_COMMENT
)
2121 /* Eat up extra spaces/ tabs before object name */
2122 padding
= strspn(bol
, " \t");
2125 if (item
->command
== TODO_NOOP
|| item
->command
== TODO_BREAK
) {
2127 return error(_("%s does not accept arguments: '%s'"),
2128 command_to_string(item
->command
), bol
);
2129 item
->commit
= NULL
;
2130 item
->arg_offset
= bol
- buf
;
2131 item
->arg_len
= eol
- bol
;
2136 return error(_("missing arguments for %s"),
2137 command_to_string(item
->command
));
2139 if (item
->command
== TODO_EXEC
|| item
->command
== TODO_LABEL
||
2140 item
->command
== TODO_RESET
) {
2141 item
->commit
= NULL
;
2142 item
->arg_offset
= bol
- buf
;
2143 item
->arg_len
= (int)(eol
- bol
);
2147 if (item
->command
== TODO_MERGE
) {
2148 if (skip_prefix(bol
, "-C", &bol
))
2149 bol
+= strspn(bol
, " \t");
2150 else if (skip_prefix(bol
, "-c", &bol
)) {
2151 bol
+= strspn(bol
, " \t");
2152 item
->flags
|= TODO_EDIT_MERGE_MSG
;
2154 item
->flags
|= TODO_EDIT_MERGE_MSG
;
2155 item
->commit
= NULL
;
2156 item
->arg_offset
= bol
- buf
;
2157 item
->arg_len
= (int)(eol
- bol
);
2162 end_of_object_name
= (char *) bol
+ strcspn(bol
, " \t\n");
2163 saved
= *end_of_object_name
;
2164 *end_of_object_name
= '\0';
2165 status
= get_oid(bol
, &commit_oid
);
2166 *end_of_object_name
= saved
;
2168 bol
= end_of_object_name
+ strspn(end_of_object_name
, " \t");
2169 item
->arg_offset
= bol
- buf
;
2170 item
->arg_len
= (int)(eol
- bol
);
2173 return error(_("could not parse '%.*s'"),
2174 (int)(end_of_object_name
- bol
), bol
);
2176 item
->commit
= lookup_commit_reference(r
, &commit_oid
);
2177 return !item
->commit
;
2180 int sequencer_get_last_command(struct repository
*r
, enum replay_action
*action
)
2182 const char *todo_file
, *bol
;
2183 struct strbuf buf
= STRBUF_INIT
;
2186 todo_file
= git_path_todo_file();
2187 if (strbuf_read_file(&buf
, todo_file
, 0) < 0) {
2188 if (errno
== ENOENT
|| errno
== ENOTDIR
)
2191 return error_errno("unable to open '%s'", todo_file
);
2193 bol
= buf
.buf
+ strspn(buf
.buf
, " \t\r\n");
2194 if (is_command(TODO_PICK
, &bol
) && (*bol
== ' ' || *bol
== '\t'))
2195 *action
= REPLAY_PICK
;
2196 else if (is_command(TODO_REVERT
, &bol
) &&
2197 (*bol
== ' ' || *bol
== '\t'))
2198 *action
= REPLAY_REVERT
;
2202 strbuf_release(&buf
);
2207 int todo_list_parse_insn_buffer(struct repository
*r
, char *buf
,
2208 struct todo_list
*todo_list
)
2210 struct todo_item
*item
;
2211 char *p
= buf
, *next_p
;
2212 int i
, res
= 0, fixup_okay
= file_exists(rebase_path_done());
2214 todo_list
->current
= todo_list
->nr
= 0;
2216 for (i
= 1; *p
; i
++, p
= next_p
) {
2217 char *eol
= strchrnul(p
, '\n');
2219 next_p
= *eol
? eol
+ 1 /* skip LF */ : eol
;
2221 if (p
!= eol
&& eol
[-1] == '\r')
2222 eol
--; /* strip Carriage Return */
2224 item
= append_new_todo(todo_list
);
2225 item
->offset_in_buf
= p
- todo_list
->buf
.buf
;
2226 if (parse_insn_line(r
, item
, buf
, p
, eol
)) {
2227 res
= error(_("invalid line %d: %.*s"),
2228 i
, (int)(eol
- p
), p
);
2229 item
->command
= TODO_COMMENT
+ 1;
2230 item
->arg_offset
= p
- buf
;
2231 item
->arg_len
= (int)(eol
- p
);
2232 item
->commit
= NULL
;
2237 else if (is_fixup(item
->command
))
2238 return error(_("cannot '%s' without a previous commit"),
2239 command_to_string(item
->command
));
2240 else if (!is_noop(item
->command
))
2247 static int count_commands(struct todo_list
*todo_list
)
2251 for (i
= 0; i
< todo_list
->nr
; i
++)
2252 if (todo_list
->items
[i
].command
!= TODO_COMMENT
)
2258 static int get_item_line_offset(struct todo_list
*todo_list
, int index
)
2260 return index
< todo_list
->nr
?
2261 todo_list
->items
[index
].offset_in_buf
: todo_list
->buf
.len
;
2264 static const char *get_item_line(struct todo_list
*todo_list
, int index
)
2266 return todo_list
->buf
.buf
+ get_item_line_offset(todo_list
, index
);
2269 static int get_item_line_length(struct todo_list
*todo_list
, int index
)
2271 return get_item_line_offset(todo_list
, index
+ 1)
2272 - get_item_line_offset(todo_list
, index
);
2275 static ssize_t
strbuf_read_file_or_whine(struct strbuf
*sb
, const char *path
)
2280 fd
= open(path
, O_RDONLY
);
2282 return error_errno(_("could not open '%s'"), path
);
2283 len
= strbuf_read(sb
, fd
, 0);
2286 return error(_("could not read '%s'."), path
);
2290 static int have_finished_the_last_pick(void)
2292 struct strbuf buf
= STRBUF_INIT
;
2294 const char *todo_path
= git_path_todo_file();
2297 if (strbuf_read_file(&buf
, todo_path
, 0) < 0) {
2298 if (errno
== ENOENT
) {
2301 error_errno("unable to open '%s'", todo_path
);
2305 /* If there is only one line then we are done */
2306 eol
= strchr(buf
.buf
, '\n');
2307 if (!eol
|| !eol
[1])
2310 strbuf_release(&buf
);
2315 void sequencer_post_commit_cleanup(struct repository
*r
, int verbose
)
2317 struct replay_opts opts
= REPLAY_OPTS_INIT
;
2318 int need_cleanup
= 0;
2320 if (file_exists(git_path_cherry_pick_head(r
))) {
2321 if (!unlink(git_path_cherry_pick_head(r
)) && verbose
)
2322 warning(_("cancelling a cherry picking in progress"));
2323 opts
.action
= REPLAY_PICK
;
2327 if (file_exists(git_path_revert_head(r
))) {
2328 if (!unlink(git_path_revert_head(r
)) && verbose
)
2329 warning(_("cancelling a revert in progress"));
2330 opts
.action
= REPLAY_REVERT
;
2337 if (!have_finished_the_last_pick())
2340 sequencer_remove_state(&opts
);
2343 static int read_populate_todo(struct repository
*r
,
2344 struct todo_list
*todo_list
,
2345 struct replay_opts
*opts
)
2348 const char *todo_file
= get_todo_path(opts
);
2351 strbuf_reset(&todo_list
->buf
);
2352 if (strbuf_read_file_or_whine(&todo_list
->buf
, todo_file
) < 0)
2355 res
= stat(todo_file
, &st
);
2357 return error(_("could not stat '%s'"), todo_file
);
2358 fill_stat_data(&todo_list
->stat
, &st
);
2360 res
= todo_list_parse_insn_buffer(r
, todo_list
->buf
.buf
, todo_list
);
2362 if (is_rebase_i(opts
))
2363 return error(_("please fix this using "
2364 "'git rebase --edit-todo'."));
2365 return error(_("unusable instruction sheet: '%s'"), todo_file
);
2368 if (!todo_list
->nr
&&
2369 (!is_rebase_i(opts
) || !file_exists(rebase_path_done())))
2370 return error(_("no commits parsed."));
2372 if (!is_rebase_i(opts
)) {
2373 enum todo_command valid
=
2374 opts
->action
== REPLAY_PICK
? TODO_PICK
: TODO_REVERT
;
2377 for (i
= 0; i
< todo_list
->nr
; i
++)
2378 if (valid
== todo_list
->items
[i
].command
)
2380 else if (valid
== TODO_PICK
)
2381 return error(_("cannot cherry-pick during a revert."));
2383 return error(_("cannot revert during a cherry-pick."));
2386 if (is_rebase_i(opts
)) {
2387 struct todo_list done
= TODO_LIST_INIT
;
2388 FILE *f
= fopen_or_warn(rebase_path_msgtotal(), "w");
2390 if (strbuf_read_file(&done
.buf
, rebase_path_done(), 0) > 0 &&
2391 !todo_list_parse_insn_buffer(r
, done
.buf
.buf
, &done
))
2392 todo_list
->done_nr
= count_commands(&done
);
2394 todo_list
->done_nr
= 0;
2396 todo_list
->total_nr
= todo_list
->done_nr
2397 + count_commands(todo_list
);
2398 todo_list_release(&done
);
2401 fprintf(f
, "%d\n", todo_list
->total_nr
);
2409 static int git_config_string_dup(char **dest
,
2410 const char *var
, const char *value
)
2413 return config_error_nonbool(var
);
2415 *dest
= xstrdup(value
);
2419 static int populate_opts_cb(const char *key
, const char *value
, void *data
)
2421 struct replay_opts
*opts
= data
;
2426 else if (!strcmp(key
, "options.no-commit"))
2427 opts
->no_commit
= git_config_bool_or_int(key
, value
, &error_flag
);
2428 else if (!strcmp(key
, "options.edit"))
2429 opts
->edit
= git_config_bool_or_int(key
, value
, &error_flag
);
2430 else if (!strcmp(key
, "options.allow-empty"))
2432 git_config_bool_or_int(key
, value
, &error_flag
);
2433 else if (!strcmp(key
, "options.allow-empty-message"))
2434 opts
->allow_empty_message
=
2435 git_config_bool_or_int(key
, value
, &error_flag
);
2436 else if (!strcmp(key
, "options.keep-redundant-commits"))
2437 opts
->keep_redundant_commits
=
2438 git_config_bool_or_int(key
, value
, &error_flag
);
2439 else if (!strcmp(key
, "options.signoff"))
2440 opts
->signoff
= git_config_bool_or_int(key
, value
, &error_flag
);
2441 else if (!strcmp(key
, "options.record-origin"))
2442 opts
->record_origin
= git_config_bool_or_int(key
, value
, &error_flag
);
2443 else if (!strcmp(key
, "options.allow-ff"))
2444 opts
->allow_ff
= git_config_bool_or_int(key
, value
, &error_flag
);
2445 else if (!strcmp(key
, "options.mainline"))
2446 opts
->mainline
= git_config_int(key
, value
);
2447 else if (!strcmp(key
, "options.strategy"))
2448 git_config_string_dup(&opts
->strategy
, key
, value
);
2449 else if (!strcmp(key
, "options.gpg-sign"))
2450 git_config_string_dup(&opts
->gpg_sign
, key
, value
);
2451 else if (!strcmp(key
, "options.strategy-option")) {
2452 ALLOC_GROW(opts
->xopts
, opts
->xopts_nr
+ 1, opts
->xopts_alloc
);
2453 opts
->xopts
[opts
->xopts_nr
++] = xstrdup(value
);
2454 } else if (!strcmp(key
, "options.allow-rerere-auto"))
2455 opts
->allow_rerere_auto
=
2456 git_config_bool_or_int(key
, value
, &error_flag
) ?
2457 RERERE_AUTOUPDATE
: RERERE_NOAUTOUPDATE
;
2458 else if (!strcmp(key
, "options.default-msg-cleanup")) {
2459 opts
->explicit_cleanup
= 1;
2460 opts
->default_msg_cleanup
= get_cleanup_mode(value
, 1);
2462 return error(_("invalid key: %s"), key
);
2465 return error(_("invalid value for %s: %s"), key
, value
);
2470 void parse_strategy_opts(struct replay_opts
*opts
, char *raw_opts
)
2473 char *strategy_opts_string
= raw_opts
;
2475 if (*strategy_opts_string
== ' ')
2476 strategy_opts_string
++;
2478 opts
->xopts_nr
= split_cmdline(strategy_opts_string
,
2479 (const char ***)&opts
->xopts
);
2480 for (i
= 0; i
< opts
->xopts_nr
; i
++) {
2481 const char *arg
= opts
->xopts
[i
];
2483 skip_prefix(arg
, "--", &arg
);
2484 opts
->xopts
[i
] = xstrdup(arg
);
2488 static void read_strategy_opts(struct replay_opts
*opts
, struct strbuf
*buf
)
2491 if (!read_oneliner(buf
, rebase_path_strategy(), 0))
2493 opts
->strategy
= strbuf_detach(buf
, NULL
);
2494 if (!read_oneliner(buf
, rebase_path_strategy_opts(), 0))
2497 parse_strategy_opts(opts
, buf
->buf
);
2500 static int read_populate_opts(struct replay_opts
*opts
)
2502 if (is_rebase_i(opts
)) {
2503 struct strbuf buf
= STRBUF_INIT
;
2505 if (read_oneliner(&buf
, rebase_path_gpg_sign_opt(), 1)) {
2506 if (!starts_with(buf
.buf
, "-S"))
2509 free(opts
->gpg_sign
);
2510 opts
->gpg_sign
= xstrdup(buf
.buf
+ 2);
2515 if (read_oneliner(&buf
, rebase_path_allow_rerere_autoupdate(), 1)) {
2516 if (!strcmp(buf
.buf
, "--rerere-autoupdate"))
2517 opts
->allow_rerere_auto
= RERERE_AUTOUPDATE
;
2518 else if (!strcmp(buf
.buf
, "--no-rerere-autoupdate"))
2519 opts
->allow_rerere_auto
= RERERE_NOAUTOUPDATE
;
2523 if (file_exists(rebase_path_verbose()))
2526 if (file_exists(rebase_path_quiet()))
2529 if (file_exists(rebase_path_signoff())) {
2534 if (file_exists(rebase_path_reschedule_failed_exec()))
2535 opts
->reschedule_failed_exec
= 1;
2537 read_strategy_opts(opts
, &buf
);
2538 strbuf_release(&buf
);
2540 if (read_oneliner(&opts
->current_fixups
,
2541 rebase_path_current_fixups(), 1)) {
2542 const char *p
= opts
->current_fixups
.buf
;
2543 opts
->current_fixup_count
= 1;
2544 while ((p
= strchr(p
, '\n'))) {
2545 opts
->current_fixup_count
++;
2550 if (read_oneliner(&buf
, rebase_path_squash_onto(), 0)) {
2551 if (get_oid_hex(buf
.buf
, &opts
->squash_onto
) < 0)
2552 return error(_("unusable squash-onto"));
2553 opts
->have_squash_onto
= 1;
2559 if (!file_exists(git_path_opts_file()))
2562 * The function git_parse_source(), called from git_config_from_file(),
2563 * may die() in case of a syntactically incorrect file. We do not care
2564 * about this case, though, because we wrote that file ourselves, so we
2565 * are pretty certain that it is syntactically correct.
2567 if (git_config_from_file(populate_opts_cb
, git_path_opts_file(), opts
) < 0)
2568 return error(_("malformed options sheet: '%s'"),
2569 git_path_opts_file());
2573 static void write_strategy_opts(struct replay_opts
*opts
)
2576 struct strbuf buf
= STRBUF_INIT
;
2578 for (i
= 0; i
< opts
->xopts_nr
; ++i
)
2579 strbuf_addf(&buf
, " --%s", opts
->xopts
[i
]);
2581 write_file(rebase_path_strategy_opts(), "%s\n", buf
.buf
);
2582 strbuf_release(&buf
);
2585 int write_basic_state(struct replay_opts
*opts
, const char *head_name
,
2586 struct commit
*onto
, const char *orig_head
)
2588 const char *quiet
= getenv("GIT_QUIET");
2591 write_file(rebase_path_head_name(), "%s\n", head_name
);
2593 write_file(rebase_path_onto(), "%s\n",
2594 oid_to_hex(&onto
->object
.oid
));
2596 write_file(rebase_path_orig_head(), "%s\n", orig_head
);
2599 write_file(rebase_path_quiet(), "%s\n", quiet
);
2601 write_file(rebase_path_verbose(), "%s", "");
2603 write_file(rebase_path_strategy(), "%s\n", opts
->strategy
);
2604 if (opts
->xopts_nr
> 0)
2605 write_strategy_opts(opts
);
2607 if (opts
->allow_rerere_auto
== RERERE_AUTOUPDATE
)
2608 write_file(rebase_path_allow_rerere_autoupdate(), "--rerere-autoupdate\n");
2609 else if (opts
->allow_rerere_auto
== RERERE_NOAUTOUPDATE
)
2610 write_file(rebase_path_allow_rerere_autoupdate(), "--no-rerere-autoupdate\n");
2613 write_file(rebase_path_gpg_sign_opt(), "-S%s\n", opts
->gpg_sign
);
2615 write_file(rebase_path_signoff(), "--signoff\n");
2616 if (opts
->reschedule_failed_exec
)
2617 write_file(rebase_path_reschedule_failed_exec(), "%s", "");
2622 static int walk_revs_populate_todo(struct todo_list
*todo_list
,
2623 struct replay_opts
*opts
)
2625 enum todo_command command
= opts
->action
== REPLAY_PICK
?
2626 TODO_PICK
: TODO_REVERT
;
2627 const char *command_string
= todo_command_info
[command
].str
;
2628 struct commit
*commit
;
2630 if (prepare_revs(opts
))
2633 while ((commit
= get_revision(opts
->revs
))) {
2634 struct todo_item
*item
= append_new_todo(todo_list
);
2635 const char *commit_buffer
= get_commit_buffer(commit
, NULL
);
2636 const char *subject
;
2639 item
->command
= command
;
2640 item
->commit
= commit
;
2641 item
->arg_offset
= 0;
2643 item
->offset_in_buf
= todo_list
->buf
.len
;
2644 subject_len
= find_commit_subject(commit_buffer
, &subject
);
2645 strbuf_addf(&todo_list
->buf
, "%s %s %.*s\n", command_string
,
2646 short_commit_name(commit
), subject_len
, subject
);
2647 unuse_commit_buffer(commit
, commit_buffer
);
2651 return error(_("empty commit set passed"));
2656 static int create_seq_dir(struct repository
*r
)
2658 enum replay_action action
;
2659 const char *in_progress_error
= NULL
;
2660 const char *in_progress_advice
= NULL
;
2661 unsigned int advise_skip
= file_exists(git_path_revert_head(r
)) ||
2662 file_exists(git_path_cherry_pick_head(r
));
2664 if (!sequencer_get_last_command(r
, &action
)) {
2667 in_progress_error
= _("revert is already in progress");
2668 in_progress_advice
=
2669 _("try \"git revert (--continue | %s--abort | --quit)\"");
2672 in_progress_error
= _("cherry-pick is already in progress");
2673 in_progress_advice
=
2674 _("try \"git cherry-pick (--continue | %s--abort | --quit)\"");
2677 BUG("unexpected action in create_seq_dir");
2680 if (in_progress_error
) {
2681 error("%s", in_progress_error
);
2682 if (advice_sequencer_in_use
)
2683 advise(in_progress_advice
,
2684 advise_skip
? "--skip | " : "");
2687 if (mkdir(git_path_seq_dir(), 0777) < 0)
2688 return error_errno(_("could not create sequencer directory '%s'"),
2689 git_path_seq_dir());
2694 static int save_head(const char *head
)
2696 struct lock_file head_lock
= LOCK_INIT
;
2697 struct strbuf buf
= STRBUF_INIT
;
2701 fd
= hold_lock_file_for_update(&head_lock
, git_path_head_file(), 0);
2703 return error_errno(_("could not lock HEAD"));
2704 strbuf_addf(&buf
, "%s\n", head
);
2705 written
= write_in_full(fd
, buf
.buf
, buf
.len
);
2706 strbuf_release(&buf
);
2708 error_errno(_("could not write to '%s'"), git_path_head_file());
2709 rollback_lock_file(&head_lock
);
2712 if (commit_lock_file(&head_lock
) < 0)
2713 return error(_("failed to finalize '%s'"), git_path_head_file());
2717 static int rollback_is_safe(void)
2719 struct strbuf sb
= STRBUF_INIT
;
2720 struct object_id expected_head
, actual_head
;
2722 if (strbuf_read_file(&sb
, git_path_abort_safety_file(), 0) >= 0) {
2724 if (get_oid_hex(sb
.buf
, &expected_head
)) {
2725 strbuf_release(&sb
);
2726 die(_("could not parse %s"), git_path_abort_safety_file());
2728 strbuf_release(&sb
);
2730 else if (errno
== ENOENT
)
2731 oidclr(&expected_head
);
2733 die_errno(_("could not read '%s'"), git_path_abort_safety_file());
2735 if (get_oid("HEAD", &actual_head
))
2736 oidclr(&actual_head
);
2738 return oideq(&actual_head
, &expected_head
);
2741 static int reset_merge(const struct object_id
*oid
)
2744 struct argv_array argv
= ARGV_ARRAY_INIT
;
2746 argv_array_pushl(&argv
, "reset", "--merge", NULL
);
2748 if (!is_null_oid(oid
))
2749 argv_array_push(&argv
, oid_to_hex(oid
));
2751 ret
= run_command_v_opt(argv
.argv
, RUN_GIT_CMD
);
2752 argv_array_clear(&argv
);
2757 static int rollback_single_pick(struct repository
*r
)
2759 struct object_id head_oid
;
2761 if (!file_exists(git_path_cherry_pick_head(r
)) &&
2762 !file_exists(git_path_revert_head(r
)))
2763 return error(_("no cherry-pick or revert in progress"));
2764 if (read_ref_full("HEAD", 0, &head_oid
, NULL
))
2765 return error(_("cannot resolve HEAD"));
2766 if (is_null_oid(&head_oid
))
2767 return error(_("cannot abort from a branch yet to be born"));
2768 return reset_merge(&head_oid
);
2771 static int skip_single_pick(void)
2773 struct object_id head
;
2775 if (read_ref_full("HEAD", 0, &head
, NULL
))
2776 return error(_("cannot resolve HEAD"));
2777 return reset_merge(&head
);
2780 int sequencer_rollback(struct repository
*r
, struct replay_opts
*opts
)
2783 struct object_id oid
;
2784 struct strbuf buf
= STRBUF_INIT
;
2787 f
= fopen(git_path_head_file(), "r");
2788 if (!f
&& errno
== ENOENT
) {
2790 * There is no multiple-cherry-pick in progress.
2791 * If CHERRY_PICK_HEAD or REVERT_HEAD indicates
2792 * a single-cherry-pick in progress, abort that.
2794 return rollback_single_pick(r
);
2797 return error_errno(_("cannot open '%s'"), git_path_head_file());
2798 if (strbuf_getline_lf(&buf
, f
)) {
2799 error(_("cannot read '%s': %s"), git_path_head_file(),
2800 ferror(f
) ? strerror(errno
) : _("unexpected end of file"));
2805 if (parse_oid_hex(buf
.buf
, &oid
, &p
) || *p
!= '\0') {
2806 error(_("stored pre-cherry-pick HEAD file '%s' is corrupt"),
2807 git_path_head_file());
2810 if (is_null_oid(&oid
)) {
2811 error(_("cannot abort from a branch yet to be born"));
2815 if (!rollback_is_safe()) {
2816 /* Do not error, just do not rollback */
2817 warning(_("You seem to have moved HEAD. "
2818 "Not rewinding, check your HEAD!"));
2820 if (reset_merge(&oid
))
2822 strbuf_release(&buf
);
2823 return sequencer_remove_state(opts
);
2825 strbuf_release(&buf
);
2829 int sequencer_skip(struct repository
*r
, struct replay_opts
*opts
)
2831 enum replay_action action
= -1;
2832 sequencer_get_last_command(r
, &action
);
2835 * Check whether the subcommand requested to skip the commit is actually
2836 * in progress and that it's safe to skip the commit.
2838 * opts->action tells us which subcommand requested to skip the commit.
2839 * If the corresponding .git/<ACTION>_HEAD exists, we know that the
2840 * action is in progress and we can skip the commit.
2842 * Otherwise we check that the last instruction was related to the
2843 * particular subcommand we're trying to execute and barf if that's not
2846 * Finally we check that the rollback is "safe", i.e., has the HEAD
2847 * moved? In this case, it doesn't make sense to "reset the merge" and
2848 * "skip the commit" as the user already handled this by committing. But
2849 * we'd not want to barf here, instead give advice on how to proceed. We
2850 * only need to check that when .git/<ACTION>_HEAD doesn't exist because
2851 * it gets removed when the user commits, so if it still exists we're
2852 * sure the user can't have committed before.
2854 switch (opts
->action
) {
2856 if (!file_exists(git_path_revert_head(r
))) {
2857 if (action
!= REPLAY_REVERT
)
2858 return error(_("no revert in progress"));
2859 if (!rollback_is_safe())
2864 if (!file_exists(git_path_cherry_pick_head(r
))) {
2865 if (action
!= REPLAY_PICK
)
2866 return error(_("no cherry-pick in progress"));
2867 if (!rollback_is_safe())
2872 BUG("unexpected action in sequencer_skip");
2875 if (skip_single_pick())
2876 return error(_("failed to skip the commit"));
2877 if (!is_directory(git_path_seq_dir()))
2880 return sequencer_continue(r
, opts
);
2883 error(_("there is nothing to skip"));
2885 if (advice_resolve_conflict
) {
2886 advise(_("have you committed already?\n"
2887 "try \"git %s --continue\""),
2888 action
== REPLAY_REVERT
? "revert" : "cherry-pick");
2893 static int save_todo(struct todo_list
*todo_list
, struct replay_opts
*opts
)
2895 struct lock_file todo_lock
= LOCK_INIT
;
2896 const char *todo_path
= get_todo_path(opts
);
2897 int next
= todo_list
->current
, offset
, fd
;
2900 * rebase -i writes "git-rebase-todo" without the currently executing
2901 * command, appending it to "done" instead.
2903 if (is_rebase_i(opts
))
2906 fd
= hold_lock_file_for_update(&todo_lock
, todo_path
, 0);
2908 return error_errno(_("could not lock '%s'"), todo_path
);
2909 offset
= get_item_line_offset(todo_list
, next
);
2910 if (write_in_full(fd
, todo_list
->buf
.buf
+ offset
,
2911 todo_list
->buf
.len
- offset
) < 0)
2912 return error_errno(_("could not write to '%s'"), todo_path
);
2913 if (commit_lock_file(&todo_lock
) < 0)
2914 return error(_("failed to finalize '%s'"), todo_path
);
2916 if (is_rebase_i(opts
) && next
> 0) {
2917 const char *done
= rebase_path_done();
2918 int fd
= open(done
, O_CREAT
| O_WRONLY
| O_APPEND
, 0666);
2923 if (write_in_full(fd
, get_item_line(todo_list
, next
- 1),
2924 get_item_line_length(todo_list
, next
- 1))
2926 ret
= error_errno(_("could not write to '%s'"), done
);
2928 ret
= error_errno(_("failed to finalize '%s'"), done
);
2934 static int save_opts(struct replay_opts
*opts
)
2936 const char *opts_file
= git_path_opts_file();
2939 if (opts
->no_commit
)
2940 res
|= git_config_set_in_file_gently(opts_file
,
2941 "options.no-commit", "true");
2943 res
|= git_config_set_in_file_gently(opts_file
,
2944 "options.edit", "true");
2945 if (opts
->allow_empty
)
2946 res
|= git_config_set_in_file_gently(opts_file
,
2947 "options.allow-empty", "true");
2948 if (opts
->allow_empty_message
)
2949 res
|= git_config_set_in_file_gently(opts_file
,
2950 "options.allow-empty-message", "true");
2951 if (opts
->keep_redundant_commits
)
2952 res
|= git_config_set_in_file_gently(opts_file
,
2953 "options.keep-redundant-commits", "true");
2955 res
|= git_config_set_in_file_gently(opts_file
,
2956 "options.signoff", "true");
2957 if (opts
->record_origin
)
2958 res
|= git_config_set_in_file_gently(opts_file
,
2959 "options.record-origin", "true");
2961 res
|= git_config_set_in_file_gently(opts_file
,
2962 "options.allow-ff", "true");
2963 if (opts
->mainline
) {
2964 struct strbuf buf
= STRBUF_INIT
;
2965 strbuf_addf(&buf
, "%d", opts
->mainline
);
2966 res
|= git_config_set_in_file_gently(opts_file
,
2967 "options.mainline", buf
.buf
);
2968 strbuf_release(&buf
);
2971 res
|= git_config_set_in_file_gently(opts_file
,
2972 "options.strategy", opts
->strategy
);
2974 res
|= git_config_set_in_file_gently(opts_file
,
2975 "options.gpg-sign", opts
->gpg_sign
);
2978 for (i
= 0; i
< opts
->xopts_nr
; i
++)
2979 res
|= git_config_set_multivar_in_file_gently(opts_file
,
2980 "options.strategy-option",
2981 opts
->xopts
[i
], "^$", 0);
2983 if (opts
->allow_rerere_auto
)
2984 res
|= git_config_set_in_file_gently(opts_file
,
2985 "options.allow-rerere-auto",
2986 opts
->allow_rerere_auto
== RERERE_AUTOUPDATE
?
2989 if (opts
->explicit_cleanup
)
2990 res
|= git_config_set_in_file_gently(opts_file
,
2991 "options.default-msg-cleanup",
2992 describe_cleanup_mode(opts
->default_msg_cleanup
));
2996 static int make_patch(struct repository
*r
,
2997 struct commit
*commit
,
2998 struct replay_opts
*opts
)
3000 struct strbuf buf
= STRBUF_INIT
;
3001 struct rev_info log_tree_opt
;
3002 const char *subject
, *p
;
3005 p
= short_commit_name(commit
);
3006 if (write_message(p
, strlen(p
), rebase_path_stopped_sha(), 1) < 0)
3008 if (update_ref("rebase", "REBASE_HEAD", &commit
->object
.oid
,
3009 NULL
, REF_NO_DEREF
, UPDATE_REFS_MSG_ON_ERR
))
3010 res
|= error(_("could not update %s"), "REBASE_HEAD");
3012 strbuf_addf(&buf
, "%s/patch", get_dir(opts
));
3013 memset(&log_tree_opt
, 0, sizeof(log_tree_opt
));
3014 repo_init_revisions(r
, &log_tree_opt
, NULL
);
3015 log_tree_opt
.abbrev
= 0;
3016 log_tree_opt
.diff
= 1;
3017 log_tree_opt
.diffopt
.output_format
= DIFF_FORMAT_PATCH
;
3018 log_tree_opt
.disable_stdin
= 1;
3019 log_tree_opt
.no_commit_id
= 1;
3020 log_tree_opt
.diffopt
.file
= fopen(buf
.buf
, "w");
3021 log_tree_opt
.diffopt
.use_color
= GIT_COLOR_NEVER
;
3022 if (!log_tree_opt
.diffopt
.file
)
3023 res
|= error_errno(_("could not open '%s'"), buf
.buf
);
3025 res
|= log_tree_commit(&log_tree_opt
, commit
);
3026 fclose(log_tree_opt
.diffopt
.file
);
3030 strbuf_addf(&buf
, "%s/message", get_dir(opts
));
3031 if (!file_exists(buf
.buf
)) {
3032 const char *commit_buffer
= get_commit_buffer(commit
, NULL
);
3033 find_commit_subject(commit_buffer
, &subject
);
3034 res
|= write_message(subject
, strlen(subject
), buf
.buf
, 1);
3035 unuse_commit_buffer(commit
, commit_buffer
);
3037 strbuf_release(&buf
);
3042 static int intend_to_amend(void)
3044 struct object_id head
;
3047 if (get_oid("HEAD", &head
))
3048 return error(_("cannot read HEAD"));
3050 p
= oid_to_hex(&head
);
3051 return write_message(p
, strlen(p
), rebase_path_amend(), 1);
3054 static int error_with_patch(struct repository
*r
,
3055 struct commit
*commit
,
3056 const char *subject
, int subject_len
,
3057 struct replay_opts
*opts
,
3058 int exit_code
, int to_amend
)
3061 if (make_patch(r
, commit
, opts
))
3063 } else if (copy_file(rebase_path_message(),
3064 git_path_merge_msg(r
), 0666))
3065 return error(_("unable to copy '%s' to '%s'"),
3066 git_path_merge_msg(r
), rebase_path_message());
3069 if (intend_to_amend())
3073 _("You can amend the commit now, with\n"
3075 " git commit --amend %s\n"
3077 "Once you are satisfied with your changes, run\n"
3079 " git rebase --continue\n"),
3080 gpg_sign_opt_quoted(opts
));
3081 } else if (exit_code
) {
3083 fprintf_ln(stderr
, _("Could not apply %s... %.*s"),
3084 short_commit_name(commit
), subject_len
, subject
);
3087 * We don't have the hash of the parent so
3088 * just print the line from the todo file.
3090 fprintf_ln(stderr
, _("Could not merge %.*s"),
3091 subject_len
, subject
);
3097 static int error_failed_squash(struct repository
*r
,
3098 struct commit
*commit
,
3099 struct replay_opts
*opts
,
3101 const char *subject
)
3103 if (copy_file(rebase_path_message(), rebase_path_squash_msg(), 0666))
3104 return error(_("could not copy '%s' to '%s'"),
3105 rebase_path_squash_msg(), rebase_path_message());
3106 unlink(git_path_merge_msg(r
));
3107 if (copy_file(git_path_merge_msg(r
), rebase_path_message(), 0666))
3108 return error(_("could not copy '%s' to '%s'"),
3109 rebase_path_message(),
3110 git_path_merge_msg(r
));
3111 return error_with_patch(r
, commit
, subject
, subject_len
, opts
, 1, 0);
3114 static int do_exec(struct repository
*r
, const char *command_line
)
3116 struct argv_array child_env
= ARGV_ARRAY_INIT
;
3117 const char *child_argv
[] = { NULL
, NULL
};
3120 fprintf(stderr
, "Executing: %s\n", command_line
);
3121 child_argv
[0] = command_line
;
3122 argv_array_pushf(&child_env
, "GIT_DIR=%s", absolute_path(get_git_dir()));
3123 argv_array_pushf(&child_env
, "GIT_WORK_TREE=%s",
3124 absolute_path(get_git_work_tree()));
3125 status
= run_command_v_opt_cd_env(child_argv
, RUN_USING_SHELL
, NULL
,
3128 /* force re-reading of the cache */
3129 if (discard_index(r
->index
) < 0 || repo_read_index(r
) < 0)
3130 return error(_("could not read index"));
3132 dirty
= require_clean_work_tree(r
, "rebase", NULL
, 1, 1);
3135 warning(_("execution failed: %s\n%s"
3136 "You can fix the problem, and then run\n"
3138 " git rebase --continue\n"
3141 dirty
? N_("and made changes to the index and/or the "
3142 "working tree\n") : "");
3144 /* command not found */
3147 warning(_("execution succeeded: %s\nbut "
3148 "left changes to the index and/or the working tree\n"
3149 "Commit or stash your changes, and then run\n"
3151 " git rebase --continue\n"
3152 "\n"), command_line
);
3156 argv_array_clear(&child_env
);
3161 static int safe_append(const char *filename
, const char *fmt
, ...)
3164 struct lock_file lock
= LOCK_INIT
;
3165 int fd
= hold_lock_file_for_update(&lock
, filename
,
3166 LOCK_REPORT_ON_ERROR
);
3167 struct strbuf buf
= STRBUF_INIT
;
3172 if (strbuf_read_file(&buf
, filename
, 0) < 0 && errno
!= ENOENT
) {
3173 error_errno(_("could not read '%s'"), filename
);
3174 rollback_lock_file(&lock
);
3177 strbuf_complete(&buf
, '\n');
3179 strbuf_vaddf(&buf
, fmt
, ap
);
3182 if (write_in_full(fd
, buf
.buf
, buf
.len
) < 0) {
3183 error_errno(_("could not write to '%s'"), filename
);
3184 strbuf_release(&buf
);
3185 rollback_lock_file(&lock
);
3188 if (commit_lock_file(&lock
) < 0) {
3189 strbuf_release(&buf
);
3190 rollback_lock_file(&lock
);
3191 return error(_("failed to finalize '%s'"), filename
);
3194 strbuf_release(&buf
);
3198 static int do_label(struct repository
*r
, const char *name
, int len
)
3200 struct ref_store
*refs
= get_main_ref_store(r
);
3201 struct ref_transaction
*transaction
;
3202 struct strbuf ref_name
= STRBUF_INIT
, err
= STRBUF_INIT
;
3203 struct strbuf msg
= STRBUF_INIT
;
3205 struct object_id head_oid
;
3207 if (len
== 1 && *name
== '#')
3208 return error(_("illegal label name: '%.*s'"), len
, name
);
3210 strbuf_addf(&ref_name
, "refs/rewritten/%.*s", len
, name
);
3211 strbuf_addf(&msg
, "rebase -i (label) '%.*s'", len
, name
);
3213 transaction
= ref_store_transaction_begin(refs
, &err
);
3215 error("%s", err
.buf
);
3217 } else if (get_oid("HEAD", &head_oid
)) {
3218 error(_("could not read HEAD"));
3220 } else if (ref_transaction_update(transaction
, ref_name
.buf
, &head_oid
,
3221 NULL
, 0, msg
.buf
, &err
) < 0 ||
3222 ref_transaction_commit(transaction
, &err
)) {
3223 error("%s", err
.buf
);
3226 ref_transaction_free(transaction
);
3227 strbuf_release(&err
);
3228 strbuf_release(&msg
);
3231 ret
= safe_append(rebase_path_refs_to_delete(),
3232 "%s\n", ref_name
.buf
);
3233 strbuf_release(&ref_name
);
3238 static const char *reflog_message(struct replay_opts
*opts
,
3239 const char *sub_action
, const char *fmt
, ...);
3241 static int do_reset(struct repository
*r
,
3242 const char *name
, int len
,
3243 struct replay_opts
*opts
)
3245 struct strbuf ref_name
= STRBUF_INIT
;
3246 struct object_id oid
;
3247 struct lock_file lock
= LOCK_INIT
;
3248 struct tree_desc desc
;
3250 struct unpack_trees_options unpack_tree_opts
;
3253 if (repo_hold_locked_index(r
, &lock
, LOCK_REPORT_ON_ERROR
) < 0)
3256 if (len
== 10 && !strncmp("[new root]", name
, len
)) {
3257 if (!opts
->have_squash_onto
) {
3259 if (commit_tree("", 0, the_hash_algo
->empty_tree
,
3260 NULL
, &opts
->squash_onto
,
3262 return error(_("writing fake root commit"));
3263 opts
->have_squash_onto
= 1;
3264 hex
= oid_to_hex(&opts
->squash_onto
);
3265 if (write_message(hex
, strlen(hex
),
3266 rebase_path_squash_onto(), 0))
3267 return error(_("writing squash-onto"));
3269 oidcpy(&oid
, &opts
->squash_onto
);
3273 /* Determine the length of the label */
3274 for (i
= 0; i
< len
; i
++)
3275 if (isspace(name
[i
]))
3279 strbuf_addf(&ref_name
, "refs/rewritten/%.*s", len
, name
);
3280 if (get_oid(ref_name
.buf
, &oid
) &&
3281 get_oid(ref_name
.buf
+ strlen("refs/rewritten/"), &oid
)) {
3282 error(_("could not read '%s'"), ref_name
.buf
);
3283 rollback_lock_file(&lock
);
3284 strbuf_release(&ref_name
);
3289 memset(&unpack_tree_opts
, 0, sizeof(unpack_tree_opts
));
3290 setup_unpack_trees_porcelain(&unpack_tree_opts
, "reset");
3291 unpack_tree_opts
.head_idx
= 1;
3292 unpack_tree_opts
.src_index
= r
->index
;
3293 unpack_tree_opts
.dst_index
= r
->index
;
3294 unpack_tree_opts
.fn
= oneway_merge
;
3295 unpack_tree_opts
.merge
= 1;
3296 unpack_tree_opts
.update
= 1;
3298 if (repo_read_index_unmerged(r
)) {
3299 rollback_lock_file(&lock
);
3300 strbuf_release(&ref_name
);
3301 return error_resolve_conflict(_(action_name(opts
)));
3304 if (!fill_tree_descriptor(r
, &desc
, &oid
)) {
3305 error(_("failed to find tree of %s"), oid_to_hex(&oid
));
3306 rollback_lock_file(&lock
);
3307 free((void *)desc
.buffer
);
3308 strbuf_release(&ref_name
);
3312 if (unpack_trees(1, &desc
, &unpack_tree_opts
)) {
3313 rollback_lock_file(&lock
);
3314 free((void *)desc
.buffer
);
3315 strbuf_release(&ref_name
);
3319 tree
= parse_tree_indirect(&oid
);
3320 prime_cache_tree(r
, r
->index
, tree
);
3322 if (write_locked_index(r
->index
, &lock
, COMMIT_LOCK
) < 0)
3323 ret
= error(_("could not write index"));
3324 free((void *)desc
.buffer
);
3327 ret
= update_ref(reflog_message(opts
, "reset", "'%.*s'",
3328 len
, name
), "HEAD", &oid
,
3329 NULL
, 0, UPDATE_REFS_MSG_ON_ERR
);
3331 strbuf_release(&ref_name
);
3335 static struct commit
*lookup_label(const char *label
, int len
,
3338 struct commit
*commit
;
3341 strbuf_addf(buf
, "refs/rewritten/%.*s", len
, label
);
3342 commit
= lookup_commit_reference_by_name(buf
->buf
);
3344 /* fall back to non-rewritten ref or commit */
3345 strbuf_splice(buf
, 0, strlen("refs/rewritten/"), "", 0);
3346 commit
= lookup_commit_reference_by_name(buf
->buf
);
3350 error(_("could not resolve '%s'"), buf
->buf
);
3355 static int do_merge(struct repository
*r
,
3356 struct commit
*commit
,
3357 const char *arg
, int arg_len
,
3358 int flags
, struct replay_opts
*opts
)
3360 int run_commit_flags
= (flags
& TODO_EDIT_MERGE_MSG
) ?
3361 EDIT_MSG
| VERIFY_MSG
: 0;
3362 struct strbuf ref_name
= STRBUF_INIT
;
3363 struct commit
*head_commit
, *merge_commit
, *i
;
3364 struct commit_list
*bases
, *j
, *reversed
= NULL
;
3365 struct commit_list
*to_merge
= NULL
, **tail
= &to_merge
;
3366 struct merge_options o
;
3367 int merge_arg_len
, oneline_offset
, can_fast_forward
, ret
, k
;
3368 static struct lock_file lock
;
3371 if (repo_hold_locked_index(r
, &lock
, LOCK_REPORT_ON_ERROR
) < 0) {
3376 head_commit
= lookup_commit_reference_by_name("HEAD");
3378 ret
= error(_("cannot merge without a current revision"));
3383 * For octopus merges, the arg starts with the list of revisions to be
3384 * merged. The list is optionally followed by '#' and the oneline.
3386 merge_arg_len
= oneline_offset
= arg_len
;
3387 for (p
= arg
; p
- arg
< arg_len
; p
+= strspn(p
, " \t\n")) {
3390 if (*p
== '#' && (!p
[1] || isspace(p
[1]))) {
3391 p
+= 1 + strspn(p
+ 1, " \t\n");
3392 oneline_offset
= p
- arg
;
3395 k
= strcspn(p
, " \t\n");
3398 merge_commit
= lookup_label(p
, k
, &ref_name
);
3399 if (!merge_commit
) {
3400 ret
= error(_("unable to parse '%.*s'"), k
, p
);
3403 tail
= &commit_list_insert(merge_commit
, tail
)->next
;
3405 merge_arg_len
= p
- arg
;
3409 ret
= error(_("nothing to merge: '%.*s'"), arg_len
, arg
);
3413 if (opts
->have_squash_onto
&&
3414 oideq(&head_commit
->object
.oid
, &opts
->squash_onto
)) {
3416 * When the user tells us to "merge" something into a
3417 * "[new root]", let's simply fast-forward to the merge head.
3419 rollback_lock_file(&lock
);
3421 ret
= error(_("octopus merge cannot be executed on "
3422 "top of a [new root]"));
3424 ret
= fast_forward_to(r
, &to_merge
->item
->object
.oid
,
3425 &head_commit
->object
.oid
, 0,
3431 const char *message
= get_commit_buffer(commit
, NULL
);
3436 ret
= error(_("could not get commit message of '%s'"),
3437 oid_to_hex(&commit
->object
.oid
));
3440 write_author_script(message
);
3441 find_commit_subject(message
, &body
);
3443 ret
= write_message(body
, len
, git_path_merge_msg(r
), 0);
3444 unuse_commit_buffer(commit
, message
);
3446 error_errno(_("could not write '%s'"),
3447 git_path_merge_msg(r
));
3451 struct strbuf buf
= STRBUF_INIT
;
3454 strbuf_addf(&buf
, "author %s", git_author_info(0));
3455 write_author_script(buf
.buf
);
3458 if (oneline_offset
< arg_len
) {
3459 p
= arg
+ oneline_offset
;
3460 len
= arg_len
- oneline_offset
;
3462 strbuf_addf(&buf
, "Merge %s '%.*s'",
3463 to_merge
->next
? "branches" : "branch",
3464 merge_arg_len
, arg
);
3469 ret
= write_message(p
, len
, git_path_merge_msg(r
), 0);
3470 strbuf_release(&buf
);
3472 error_errno(_("could not write '%s'"),
3473 git_path_merge_msg(r
));
3479 * If HEAD is not identical to the first parent of the original merge
3480 * commit, we cannot fast-forward.
3482 can_fast_forward
= opts
->allow_ff
&& commit
&& commit
->parents
&&
3483 oideq(&commit
->parents
->item
->object
.oid
,
3484 &head_commit
->object
.oid
);
3487 * If any merge head is different from the original one, we cannot
3490 if (can_fast_forward
) {
3491 struct commit_list
*p
= commit
->parents
->next
;
3493 for (j
= to_merge
; j
&& p
; j
= j
->next
, p
= p
->next
)
3494 if (!oideq(&j
->item
->object
.oid
,
3495 &p
->item
->object
.oid
)) {
3496 can_fast_forward
= 0;
3500 * If the number of merge heads differs from the original merge
3501 * commit, we cannot fast-forward.
3504 can_fast_forward
= 0;
3507 if (can_fast_forward
) {
3508 rollback_lock_file(&lock
);
3509 ret
= fast_forward_to(r
, &commit
->object
.oid
,
3510 &head_commit
->object
.oid
, 0, opts
);
3511 if (flags
& TODO_EDIT_MERGE_MSG
) {
3512 run_commit_flags
|= AMEND_MSG
;
3513 goto fast_forward_edit
;
3518 if (to_merge
->next
) {
3520 struct child_process cmd
= CHILD_PROCESS_INIT
;
3522 if (read_env_script(&cmd
.env_array
)) {
3523 const char *gpg_opt
= gpg_sign_opt_quoted(opts
);
3525 ret
= error(_(staged_changes_advice
), gpg_opt
, gpg_opt
);
3530 argv_array_push(&cmd
.args
, "merge");
3531 argv_array_push(&cmd
.args
, "-s");
3532 argv_array_push(&cmd
.args
, "octopus");
3533 argv_array_push(&cmd
.args
, "--no-edit");
3534 argv_array_push(&cmd
.args
, "--no-ff");
3535 argv_array_push(&cmd
.args
, "--no-log");
3536 argv_array_push(&cmd
.args
, "--no-stat");
3537 argv_array_push(&cmd
.args
, "-F");
3538 argv_array_push(&cmd
.args
, git_path_merge_msg(r
));
3540 argv_array_push(&cmd
.args
, opts
->gpg_sign
);
3542 /* Add the tips to be merged */
3543 for (j
= to_merge
; j
; j
= j
->next
)
3544 argv_array_push(&cmd
.args
,
3545 oid_to_hex(&j
->item
->object
.oid
));
3547 strbuf_release(&ref_name
);
3548 unlink(git_path_cherry_pick_head(r
));
3549 rollback_lock_file(&lock
);
3551 rollback_lock_file(&lock
);
3552 ret
= run_command(&cmd
);
3554 /* force re-reading of the cache */
3555 if (!ret
&& (discard_index(r
->index
) < 0 ||
3556 repo_read_index(r
) < 0))
3557 ret
= error(_("could not read index"));
3561 merge_commit
= to_merge
->item
;
3562 bases
= get_merge_bases(head_commit
, merge_commit
);
3563 if (bases
&& oideq(&merge_commit
->object
.oid
,
3564 &bases
->item
->object
.oid
)) {
3566 /* skip merging an ancestor of HEAD */
3570 write_message(oid_to_hex(&merge_commit
->object
.oid
), GIT_SHA1_HEXSZ
,
3571 git_path_merge_head(r
), 0);
3572 write_message("no-ff", 5, git_path_merge_mode(r
), 0);
3574 for (j
= bases
; j
; j
= j
->next
)
3575 commit_list_insert(j
->item
, &reversed
);
3576 free_commit_list(bases
);
3579 init_merge_options(&o
, r
);
3581 o
.branch2
= ref_name
.buf
;
3582 o
.buffer_output
= 2;
3584 ret
= merge_recursive(&o
, head_commit
, merge_commit
, reversed
, &i
);
3586 fputs(o
.obuf
.buf
, stdout
);
3587 strbuf_release(&o
.obuf
);
3589 error(_("could not even attempt to merge '%.*s'"),
3590 merge_arg_len
, arg
);
3594 * The return value of merge_recursive() is 1 on clean, and 0 on
3597 * Let's reverse that, so that do_merge() returns 0 upon success and
3598 * 1 upon failed merge (keeping the return value -1 for the cases where
3599 * we will want to reschedule the `merge` command).
3603 if (r
->index
->cache_changed
&&
3604 write_locked_index(r
->index
, &lock
, COMMIT_LOCK
)) {
3605 ret
= error(_("merge: Unable to write new index file"));
3609 rollback_lock_file(&lock
);
3611 repo_rerere(r
, opts
->allow_rerere_auto
);
3614 * In case of problems, we now want to return a positive
3615 * value (a negative one would indicate that the `merge`
3616 * command needs to be rescheduled).
3619 ret
= !!run_git_commit(r
, git_path_merge_msg(r
), opts
,
3623 strbuf_release(&ref_name
);
3624 rollback_lock_file(&lock
);
3625 free_commit_list(to_merge
);
3629 static int is_final_fixup(struct todo_list
*todo_list
)
3631 int i
= todo_list
->current
;
3633 if (!is_fixup(todo_list
->items
[i
].command
))
3636 while (++i
< todo_list
->nr
)
3637 if (is_fixup(todo_list
->items
[i
].command
))
3639 else if (!is_noop(todo_list
->items
[i
].command
))
3644 static enum todo_command
peek_command(struct todo_list
*todo_list
, int offset
)
3648 for (i
= todo_list
->current
+ offset
; i
< todo_list
->nr
; i
++)
3649 if (!is_noop(todo_list
->items
[i
].command
))
3650 return todo_list
->items
[i
].command
;
3655 static int apply_autostash(struct replay_opts
*opts
)
3657 struct strbuf stash_sha1
= STRBUF_INIT
;
3658 struct child_process child
= CHILD_PROCESS_INIT
;
3661 if (!read_oneliner(&stash_sha1
, rebase_path_autostash(), 1)) {
3662 strbuf_release(&stash_sha1
);
3665 strbuf_trim(&stash_sha1
);
3668 child
.no_stdout
= 1;
3669 child
.no_stderr
= 1;
3670 argv_array_push(&child
.args
, "stash");
3671 argv_array_push(&child
.args
, "apply");
3672 argv_array_push(&child
.args
, stash_sha1
.buf
);
3673 if (!run_command(&child
))
3674 fprintf(stderr
, _("Applied autostash.\n"));
3676 struct child_process store
= CHILD_PROCESS_INIT
;
3679 argv_array_push(&store
.args
, "stash");
3680 argv_array_push(&store
.args
, "store");
3681 argv_array_push(&store
.args
, "-m");
3682 argv_array_push(&store
.args
, "autostash");
3683 argv_array_push(&store
.args
, "-q");
3684 argv_array_push(&store
.args
, stash_sha1
.buf
);
3685 if (run_command(&store
))
3686 ret
= error(_("cannot store %s"), stash_sha1
.buf
);
3689 _("Applying autostash resulted in conflicts.\n"
3690 "Your changes are safe in the stash.\n"
3691 "You can run \"git stash pop\" or"
3692 " \"git stash drop\" at any time.\n"));
3695 strbuf_release(&stash_sha1
);
3699 static const char *reflog_message(struct replay_opts
*opts
,
3700 const char *sub_action
, const char *fmt
, ...)
3703 static struct strbuf buf
= STRBUF_INIT
;
3707 strbuf_addstr(&buf
, action_name(opts
));
3709 strbuf_addf(&buf
, " (%s)", sub_action
);
3711 strbuf_addstr(&buf
, ": ");
3712 strbuf_vaddf(&buf
, fmt
, ap
);
3719 static int run_git_checkout(struct repository
*r
, struct replay_opts
*opts
,
3720 const char *commit
, const char *action
)
3722 struct child_process cmd
= CHILD_PROCESS_INIT
;
3727 argv_array_push(&cmd
.args
, "checkout");
3728 argv_array_push(&cmd
.args
, commit
);
3729 argv_array_pushf(&cmd
.env_array
, GIT_REFLOG_ACTION
"=%s", action
);
3732 ret
= run_command(&cmd
);
3734 ret
= run_command_silent_on_success(&cmd
);
3737 discard_index(r
->index
);
3742 int prepare_branch_to_be_rebased(struct repository
*r
, struct replay_opts
*opts
,
3747 if (commit
&& *commit
) {
3748 action
= reflog_message(opts
, "start", "checkout %s", commit
);
3749 if (run_git_checkout(r
, opts
, commit
, action
))
3750 return error(_("could not checkout %s"), commit
);
3756 static int checkout_onto(struct repository
*r
, struct replay_opts
*opts
,
3757 const char *onto_name
, const struct object_id
*onto
,
3758 const char *orig_head
)
3760 struct object_id oid
;
3761 const char *action
= reflog_message(opts
, "start", "checkout %s", onto_name
);
3763 if (get_oid(orig_head
, &oid
))
3764 return error(_("%s: not a valid OID"), orig_head
);
3766 if (run_git_checkout(r
, opts
, oid_to_hex(onto
), action
)) {
3767 apply_autostash(opts
);
3768 sequencer_remove_state(opts
);
3769 return error(_("could not detach HEAD"));
3772 return update_ref(NULL
, "ORIG_HEAD", &oid
, NULL
, 0, UPDATE_REFS_MSG_ON_ERR
);
3775 static int stopped_at_head(struct repository
*r
)
3777 struct object_id head
;
3778 struct commit
*commit
;
3779 struct commit_message message
;
3781 if (get_oid("HEAD", &head
) ||
3782 !(commit
= lookup_commit(r
, &head
)) ||
3783 parse_commit(commit
) || get_message(commit
, &message
))
3784 fprintf(stderr
, _("Stopped at HEAD\n"));
3786 fprintf(stderr
, _("Stopped at %s\n"), message
.label
);
3787 free_message(commit
, &message
);
3793 static const char rescheduled_advice
[] =
3794 N_("Could not execute the todo command\n"
3798 "It has been rescheduled; To edit the command before continuing, please\n"
3799 "edit the todo list first:\n"
3801 " git rebase --edit-todo\n"
3802 " git rebase --continue\n");
3804 static int pick_commits(struct repository
*r
,
3805 struct todo_list
*todo_list
,
3806 struct replay_opts
*opts
)
3808 int res
= 0, reschedule
= 0;
3810 setenv(GIT_REFLOG_ACTION
, action_name(opts
), 0);
3812 assert(!(opts
->signoff
|| opts
->no_commit
||
3813 opts
->record_origin
|| opts
->edit
));
3814 if (read_and_refresh_cache(r
, opts
))
3817 while (todo_list
->current
< todo_list
->nr
) {
3818 struct todo_item
*item
= todo_list
->items
+ todo_list
->current
;
3819 const char *arg
= todo_item_get_arg(todo_list
, item
);
3821 if (save_todo(todo_list
, opts
))
3823 if (is_rebase_i(opts
)) {
3824 if (item
->command
!= TODO_COMMENT
) {
3825 FILE *f
= fopen(rebase_path_msgnum(), "w");
3827 todo_list
->done_nr
++;
3830 fprintf(f
, "%d\n", todo_list
->done_nr
);
3834 fprintf(stderr
, "Rebasing (%d/%d)%s",
3836 todo_list
->total_nr
,
3837 opts
->verbose
? "\n" : "\r");
3839 unlink(rebase_path_message());
3840 unlink(rebase_path_author_script());
3841 unlink(rebase_path_stopped_sha());
3842 unlink(rebase_path_amend());
3843 unlink(git_path_merge_head(r
));
3844 delete_ref(NULL
, "REBASE_HEAD", NULL
, REF_NO_DEREF
);
3846 if (item
->command
== TODO_BREAK
) {
3849 return stopped_at_head(r
);
3852 if (item
->command
<= TODO_SQUASH
) {
3853 if (is_rebase_i(opts
))
3854 setenv("GIT_REFLOG_ACTION", reflog_message(opts
,
3855 command_to_string(item
->command
), NULL
),
3857 res
= do_pick_commit(r
, item
->command
, item
->commit
,
3858 opts
, is_final_fixup(todo_list
));
3859 if (is_rebase_i(opts
) && res
< 0) {
3861 advise(_(rescheduled_advice
),
3862 get_item_line_length(todo_list
,
3863 todo_list
->current
),
3864 get_item_line(todo_list
,
3865 todo_list
->current
));
3866 todo_list
->current
--;
3867 if (save_todo(todo_list
, opts
))
3870 if (item
->command
== TODO_EDIT
) {
3871 struct commit
*commit
= item
->commit
;
3876 _("Stopped at %s... %.*s\n"),
3877 short_commit_name(commit
),
3878 item
->arg_len
, arg
);
3880 return error_with_patch(r
, commit
,
3881 arg
, item
->arg_len
, opts
, res
, !res
);
3883 if (is_rebase_i(opts
) && !res
)
3884 record_in_rewritten(&item
->commit
->object
.oid
,
3885 peek_command(todo_list
, 1));
3886 if (res
&& is_fixup(item
->command
)) {
3889 return error_failed_squash(r
, item
->commit
, opts
,
3890 item
->arg_len
, arg
);
3891 } else if (res
&& is_rebase_i(opts
) && item
->commit
) {
3893 struct object_id oid
;
3896 * If we are rewording and have either
3897 * fast-forwarded already, or are about to
3898 * create a new root commit, we want to amend,
3899 * otherwise we do not.
3901 if (item
->command
== TODO_REWORD
&&
3902 !get_oid("HEAD", &oid
) &&
3903 (oideq(&item
->commit
->object
.oid
, &oid
) ||
3904 (opts
->have_squash_onto
&&
3905 oideq(&opts
->squash_onto
, &oid
))))
3908 return res
| error_with_patch(r
, item
->commit
,
3909 arg
, item
->arg_len
, opts
,
3912 } else if (item
->command
== TODO_EXEC
) {
3913 char *end_of_arg
= (char *)(arg
+ item
->arg_len
);
3914 int saved
= *end_of_arg
;
3920 res
= do_exec(r
, arg
);
3921 *end_of_arg
= saved
;
3924 if (opts
->reschedule_failed_exec
)
3926 } else if (stat(get_todo_path(opts
), &st
))
3927 res
= error_errno(_("could not stat '%s'"),
3928 get_todo_path(opts
));
3929 else if (match_stat_data(&todo_list
->stat
, &st
)) {
3930 /* Reread the todo file if it has changed. */
3931 todo_list_release(todo_list
);
3932 if (read_populate_todo(r
, todo_list
, opts
))
3933 res
= -1; /* message was printed */
3934 /* `current` will be incremented below */
3935 todo_list
->current
= -1;
3937 } else if (item
->command
== TODO_LABEL
) {
3938 if ((res
= do_label(r
, arg
, item
->arg_len
)))
3940 } else if (item
->command
== TODO_RESET
) {
3941 if ((res
= do_reset(r
, arg
, item
->arg_len
, opts
)))
3943 } else if (item
->command
== TODO_MERGE
) {
3944 if ((res
= do_merge(r
, item
->commit
,
3946 item
->flags
, opts
)) < 0)
3948 else if (item
->commit
)
3949 record_in_rewritten(&item
->commit
->object
.oid
,
3950 peek_command(todo_list
, 1));
3952 /* failed with merge conflicts */
3953 return error_with_patch(r
, item
->commit
,
3956 } else if (!is_noop(item
->command
))
3957 return error(_("unknown command %d"), item
->command
);
3960 advise(_(rescheduled_advice
),
3961 get_item_line_length(todo_list
,
3962 todo_list
->current
),
3963 get_item_line(todo_list
, todo_list
->current
));
3964 todo_list
->current
--;
3965 if (save_todo(todo_list
, opts
))
3968 return error_with_patch(r
,
3974 todo_list
->current
++;
3979 if (is_rebase_i(opts
)) {
3980 struct strbuf head_ref
= STRBUF_INIT
, buf
= STRBUF_INIT
;
3983 /* Stopped in the middle, as planned? */
3984 if (todo_list
->current
< todo_list
->nr
)
3987 if (read_oneliner(&head_ref
, rebase_path_head_name(), 0) &&
3988 starts_with(head_ref
.buf
, "refs/")) {
3990 struct object_id head
, orig
;
3993 if (get_oid("HEAD", &head
)) {
3994 res
= error(_("cannot read HEAD"));
3996 strbuf_release(&head_ref
);
3997 strbuf_release(&buf
);
4000 if (!read_oneliner(&buf
, rebase_path_orig_head(), 0) ||
4001 get_oid_hex(buf
.buf
, &orig
)) {
4002 res
= error(_("could not read orig-head"));
4003 goto cleanup_head_ref
;
4006 if (!read_oneliner(&buf
, rebase_path_onto(), 0)) {
4007 res
= error(_("could not read 'onto'"));
4008 goto cleanup_head_ref
;
4010 msg
= reflog_message(opts
, "finish", "%s onto %s",
4011 head_ref
.buf
, buf
.buf
);
4012 if (update_ref(msg
, head_ref
.buf
, &head
, &orig
,
4013 REF_NO_DEREF
, UPDATE_REFS_MSG_ON_ERR
)) {
4014 res
= error(_("could not update %s"),
4016 goto cleanup_head_ref
;
4018 msg
= reflog_message(opts
, "finish", "returning to %s",
4020 if (create_symref("HEAD", head_ref
.buf
, msg
)) {
4021 res
= error(_("could not update HEAD to %s"),
4023 goto cleanup_head_ref
;
4028 if (opts
->verbose
) {
4029 struct rev_info log_tree_opt
;
4030 struct object_id orig
, head
;
4032 memset(&log_tree_opt
, 0, sizeof(log_tree_opt
));
4033 repo_init_revisions(r
, &log_tree_opt
, NULL
);
4034 log_tree_opt
.diff
= 1;
4035 log_tree_opt
.diffopt
.output_format
=
4036 DIFF_FORMAT_DIFFSTAT
;
4037 log_tree_opt
.disable_stdin
= 1;
4039 if (read_oneliner(&buf
, rebase_path_orig_head(), 0) &&
4040 !get_oid(buf
.buf
, &orig
) &&
4041 !get_oid("HEAD", &head
)) {
4042 diff_tree_oid(&orig
, &head
, "",
4043 &log_tree_opt
.diffopt
);
4044 log_tree_diff_flush(&log_tree_opt
);
4047 flush_rewritten_pending();
4048 if (!stat(rebase_path_rewritten_list(), &st
) &&
4050 struct child_process child
= CHILD_PROCESS_INIT
;
4051 const char *post_rewrite_hook
=
4052 find_hook("post-rewrite");
4054 child
.in
= open(rebase_path_rewritten_list(), O_RDONLY
);
4056 argv_array_push(&child
.args
, "notes");
4057 argv_array_push(&child
.args
, "copy");
4058 argv_array_push(&child
.args
, "--for-rewrite=rebase");
4059 /* we don't care if this copying failed */
4060 run_command(&child
);
4062 if (post_rewrite_hook
) {
4063 struct child_process hook
= CHILD_PROCESS_INIT
;
4065 hook
.in
= open(rebase_path_rewritten_list(),
4067 hook
.stdout_to_stderr
= 1;
4068 hook
.trace2_hook_name
= "post-rewrite";
4069 argv_array_push(&hook
.args
, post_rewrite_hook
);
4070 argv_array_push(&hook
.args
, "rebase");
4071 /* we don't care if this hook failed */
4075 apply_autostash(opts
);
4081 "Successfully rebased and updated %s.\n",
4085 strbuf_release(&buf
);
4086 strbuf_release(&head_ref
);
4090 * Sequence of picks finished successfully; cleanup by
4091 * removing the .git/sequencer directory
4093 return sequencer_remove_state(opts
);
4096 static int continue_single_pick(struct repository
*r
)
4098 const char *argv
[] = { "commit", NULL
};
4100 if (!file_exists(git_path_cherry_pick_head(r
)) &&
4101 !file_exists(git_path_revert_head(r
)))
4102 return error(_("no cherry-pick or revert in progress"));
4103 return run_command_v_opt(argv
, RUN_GIT_CMD
);
4106 static int commit_staged_changes(struct repository
*r
,
4107 struct replay_opts
*opts
,
4108 struct todo_list
*todo_list
)
4110 unsigned int flags
= ALLOW_EMPTY
| EDIT_MSG
;
4111 unsigned int final_fixup
= 0, is_clean
;
4113 if (has_unstaged_changes(r
, 1))
4114 return error(_("cannot rebase: You have unstaged changes."));
4116 is_clean
= !has_uncommitted_changes(r
, 0);
4118 if (file_exists(rebase_path_amend())) {
4119 struct strbuf rev
= STRBUF_INIT
;
4120 struct object_id head
, to_amend
;
4122 if (get_oid("HEAD", &head
))
4123 return error(_("cannot amend non-existing commit"));
4124 if (!read_oneliner(&rev
, rebase_path_amend(), 0))
4125 return error(_("invalid file: '%s'"), rebase_path_amend());
4126 if (get_oid_hex(rev
.buf
, &to_amend
))
4127 return error(_("invalid contents: '%s'"),
4128 rebase_path_amend());
4129 if (!is_clean
&& !oideq(&head
, &to_amend
))
4130 return error(_("\nYou have uncommitted changes in your "
4131 "working tree. Please, commit them\n"
4132 "first and then run 'git rebase "
4133 "--continue' again."));
4135 * When skipping a failed fixup/squash, we need to edit the
4136 * commit message, the current fixup list and count, and if it
4137 * was the last fixup/squash in the chain, we need to clean up
4138 * the commit message and if there was a squash, let the user
4141 if (!is_clean
|| !opts
->current_fixup_count
)
4142 ; /* this is not the final fixup */
4143 else if (!oideq(&head
, &to_amend
) ||
4144 !file_exists(rebase_path_stopped_sha())) {
4145 /* was a final fixup or squash done manually? */
4146 if (!is_fixup(peek_command(todo_list
, 0))) {
4147 unlink(rebase_path_fixup_msg());
4148 unlink(rebase_path_squash_msg());
4149 unlink(rebase_path_current_fixups());
4150 strbuf_reset(&opts
->current_fixups
);
4151 opts
->current_fixup_count
= 0;
4154 /* we are in a fixup/squash chain */
4155 const char *p
= opts
->current_fixups
.buf
;
4156 int len
= opts
->current_fixups
.len
;
4158 opts
->current_fixup_count
--;
4160 BUG("Incorrect current_fixups:\n%s", p
);
4161 while (len
&& p
[len
- 1] != '\n')
4163 strbuf_setlen(&opts
->current_fixups
, len
);
4164 if (write_message(p
, len
, rebase_path_current_fixups(),
4166 return error(_("could not write file: '%s'"),
4167 rebase_path_current_fixups());
4170 * If a fixup/squash in a fixup/squash chain failed, the
4171 * commit message is already correct, no need to commit
4174 * Only if it is the final command in the fixup/squash
4175 * chain, and only if the chain is longer than a single
4176 * fixup/squash command (which was just skipped), do we
4177 * actually need to re-commit with a cleaned up commit
4180 if (opts
->current_fixup_count
> 0 &&
4181 !is_fixup(peek_command(todo_list
, 0))) {
4184 * If there was not a single "squash" in the
4185 * chain, we only need to clean up the commit
4186 * message, no need to bother the user with
4187 * opening the commit message in the editor.
4189 if (!starts_with(p
, "squash ") &&
4190 !strstr(p
, "\nsquash "))
4191 flags
= (flags
& ~EDIT_MSG
) | CLEANUP_MSG
;
4192 } else if (is_fixup(peek_command(todo_list
, 0))) {
4194 * We need to update the squash message to skip
4195 * the latest commit message.
4197 struct commit
*commit
;
4198 const char *path
= rebase_path_squash_msg();
4200 if (parse_head(r
, &commit
) ||
4201 !(p
= get_commit_buffer(commit
, NULL
)) ||
4202 write_message(p
, strlen(p
), path
, 0)) {
4203 unuse_commit_buffer(commit
, p
);
4204 return error(_("could not write file: "
4207 unuse_commit_buffer(commit
, p
);
4211 strbuf_release(&rev
);
4216 const char *cherry_pick_head
= git_path_cherry_pick_head(r
);
4218 if (file_exists(cherry_pick_head
) && unlink(cherry_pick_head
))
4219 return error(_("could not remove CHERRY_PICK_HEAD"));
4224 if (run_git_commit(r
, final_fixup
? NULL
: rebase_path_message(),
4226 return error(_("could not commit staged changes."));
4227 unlink(rebase_path_amend());
4228 unlink(git_path_merge_head(r
));
4230 unlink(rebase_path_fixup_msg());
4231 unlink(rebase_path_squash_msg());
4233 if (opts
->current_fixup_count
> 0) {
4235 * Whether final fixup or not, we just cleaned up the commit
4238 unlink(rebase_path_current_fixups());
4239 strbuf_reset(&opts
->current_fixups
);
4240 opts
->current_fixup_count
= 0;
4245 int sequencer_continue(struct repository
*r
, struct replay_opts
*opts
)
4247 struct todo_list todo_list
= TODO_LIST_INIT
;
4250 if (read_and_refresh_cache(r
, opts
))
4253 if (read_populate_opts(opts
))
4255 if (is_rebase_i(opts
)) {
4256 if ((res
= read_populate_todo(r
, &todo_list
, opts
)))
4257 goto release_todo_list
;
4258 if (commit_staged_changes(r
, opts
, &todo_list
))
4260 } else if (!file_exists(get_todo_path(opts
)))
4261 return continue_single_pick(r
);
4262 else if ((res
= read_populate_todo(r
, &todo_list
, opts
)))
4263 goto release_todo_list
;
4265 if (!is_rebase_i(opts
)) {
4266 /* Verify that the conflict has been resolved */
4267 if (file_exists(git_path_cherry_pick_head(r
)) ||
4268 file_exists(git_path_revert_head(r
))) {
4269 res
= continue_single_pick(r
);
4271 goto release_todo_list
;
4273 if (index_differs_from(r
, "HEAD", NULL
, 0)) {
4274 res
= error_dirty_index(r
, opts
);
4275 goto release_todo_list
;
4277 todo_list
.current
++;
4278 } else if (file_exists(rebase_path_stopped_sha())) {
4279 struct strbuf buf
= STRBUF_INIT
;
4280 struct object_id oid
;
4282 if (read_oneliner(&buf
, rebase_path_stopped_sha(), 1) &&
4283 !get_oid_committish(buf
.buf
, &oid
))
4284 record_in_rewritten(&oid
, peek_command(&todo_list
, 0));
4285 strbuf_release(&buf
);
4288 res
= pick_commits(r
, &todo_list
, opts
);
4290 todo_list_release(&todo_list
);
4294 static int single_pick(struct repository
*r
,
4295 struct commit
*cmit
,
4296 struct replay_opts
*opts
)
4298 setenv(GIT_REFLOG_ACTION
, action_name(opts
), 0);
4299 return do_pick_commit(r
, opts
->action
== REPLAY_PICK
?
4300 TODO_PICK
: TODO_REVERT
, cmit
, opts
, 0);
4303 int sequencer_pick_revisions(struct repository
*r
,
4304 struct replay_opts
*opts
)
4306 struct todo_list todo_list
= TODO_LIST_INIT
;
4307 struct object_id oid
;
4311 if (read_and_refresh_cache(r
, opts
))
4314 for (i
= 0; i
< opts
->revs
->pending
.nr
; i
++) {
4315 struct object_id oid
;
4316 const char *name
= opts
->revs
->pending
.objects
[i
].name
;
4318 /* This happens when using --stdin. */
4322 if (!get_oid(name
, &oid
)) {
4323 if (!lookup_commit_reference_gently(r
, &oid
, 1)) {
4324 enum object_type type
= oid_object_info(r
,
4327 return error(_("%s: can't cherry-pick a %s"),
4328 name
, type_name(type
));
4331 return error(_("%s: bad revision"), name
);
4335 * If we were called as "git cherry-pick <commit>", just
4336 * cherry-pick/revert it, set CHERRY_PICK_HEAD /
4337 * REVERT_HEAD, and don't touch the sequencer state.
4338 * This means it is possible to cherry-pick in the middle
4339 * of a cherry-pick sequence.
4341 if (opts
->revs
->cmdline
.nr
== 1 &&
4342 opts
->revs
->cmdline
.rev
->whence
== REV_CMD_REV
&&
4343 opts
->revs
->no_walk
&&
4344 !opts
->revs
->cmdline
.rev
->flags
) {
4345 struct commit
*cmit
;
4346 if (prepare_revision_walk(opts
->revs
))
4347 return error(_("revision walk setup failed"));
4348 cmit
= get_revision(opts
->revs
);
4350 return error(_("empty commit set passed"));
4351 if (get_revision(opts
->revs
))
4352 BUG("unexpected extra commit from walk");
4353 return single_pick(r
, cmit
, opts
);
4357 * Start a new cherry-pick/ revert sequence; but
4358 * first, make sure that an existing one isn't in
4362 if (walk_revs_populate_todo(&todo_list
, opts
) ||
4363 create_seq_dir(r
) < 0)
4365 if (get_oid("HEAD", &oid
) && (opts
->action
== REPLAY_REVERT
))
4366 return error(_("can't revert as initial commit"));
4367 if (save_head(oid_to_hex(&oid
)))
4369 if (save_opts(opts
))
4371 update_abort_safety_file();
4372 res
= pick_commits(r
, &todo_list
, opts
);
4373 todo_list_release(&todo_list
);
4377 void append_signoff(struct strbuf
*msgbuf
, size_t ignore_footer
, unsigned flag
)
4379 unsigned no_dup_sob
= flag
& APPEND_SIGNOFF_DEDUP
;
4380 struct strbuf sob
= STRBUF_INIT
;
4383 strbuf_addstr(&sob
, sign_off_header
);
4384 strbuf_addstr(&sob
, fmt_name(WANT_COMMITTER_IDENT
));
4385 strbuf_addch(&sob
, '\n');
4388 strbuf_complete_line(msgbuf
);
4391 * If the whole message buffer is equal to the sob, pretend that we
4392 * found a conforming footer with a matching sob
4394 if (msgbuf
->len
- ignore_footer
== sob
.len
&&
4395 !strncmp(msgbuf
->buf
, sob
.buf
, sob
.len
))
4398 has_footer
= has_conforming_footer(msgbuf
, &sob
, ignore_footer
);
4401 const char *append_newlines
= NULL
;
4402 size_t len
= msgbuf
->len
- ignore_footer
;
4406 * The buffer is completely empty. Leave foom for
4407 * the title and body to be filled in by the user.
4409 append_newlines
= "\n\n";
4410 } else if (len
== 1) {
4412 * Buffer contains a single newline. Add another
4413 * so that we leave room for the title and body.
4415 append_newlines
= "\n";
4416 } else if (msgbuf
->buf
[len
- 2] != '\n') {
4418 * Buffer ends with a single newline. Add another
4419 * so that there is an empty line between the message
4422 append_newlines
= "\n";
4423 } /* else, the buffer already ends with two newlines. */
4425 if (append_newlines
)
4426 strbuf_splice(msgbuf
, msgbuf
->len
- ignore_footer
, 0,
4427 append_newlines
, strlen(append_newlines
));
4430 if (has_footer
!= 3 && (!no_dup_sob
|| has_footer
!= 2))
4431 strbuf_splice(msgbuf
, msgbuf
->len
- ignore_footer
, 0,
4434 strbuf_release(&sob
);
4437 struct labels_entry
{
4438 struct hashmap_entry entry
;
4439 char label
[FLEX_ARRAY
];
4442 static int labels_cmp(const void *fndata
, const struct labels_entry
*a
,
4443 const struct labels_entry
*b
, const void *key
)
4445 return key
? strcmp(a
->label
, key
) : strcmp(a
->label
, b
->label
);
4448 struct string_entry
{
4449 struct oidmap_entry entry
;
4450 char string
[FLEX_ARRAY
];
4453 struct label_state
{
4454 struct oidmap commit2label
;
4455 struct hashmap labels
;
4459 static const char *label_oid(struct object_id
*oid
, const char *label
,
4460 struct label_state
*state
)
4462 struct labels_entry
*labels_entry
;
4463 struct string_entry
*string_entry
;
4464 struct object_id dummy
;
4468 string_entry
= oidmap_get(&state
->commit2label
, oid
);
4470 return string_entry
->string
;
4473 * For "uninteresting" commits, i.e. commits that are not to be
4474 * rebased, and which can therefore not be labeled, we use a unique
4475 * abbreviation of the commit name. This is slightly more complicated
4476 * than calling find_unique_abbrev() because we also need to make
4477 * sure that the abbreviation does not conflict with any other
4480 * We disallow "interesting" commits to be labeled by a string that
4481 * is a valid full-length hash, to ensure that we always can find an
4482 * abbreviation for any uninteresting commit's names that does not
4483 * clash with any other label.
4488 strbuf_reset(&state
->buf
);
4489 strbuf_grow(&state
->buf
, GIT_SHA1_HEXSZ
);
4490 label
= p
= state
->buf
.buf
;
4492 find_unique_abbrev_r(p
, oid
, default_abbrev
);
4495 * We may need to extend the abbreviated hash so that there is
4496 * no conflicting label.
4498 if (hashmap_get_from_hash(&state
->labels
, strihash(p
), p
)) {
4499 size_t i
= strlen(p
) + 1;
4501 oid_to_hex_r(p
, oid
);
4502 for (; i
< GIT_SHA1_HEXSZ
; i
++) {
4505 if (!hashmap_get_from_hash(&state
->labels
,
4511 } else if (((len
= strlen(label
)) == the_hash_algo
->hexsz
&&
4512 !get_oid_hex(label
, &dummy
)) ||
4513 (len
== 1 && *label
== '#') ||
4514 hashmap_get_from_hash(&state
->labels
,
4515 strihash(label
), label
)) {
4517 * If the label already exists, or if the label is a valid full
4518 * OID, or the label is a '#' (which we use as a separator
4519 * between merge heads and oneline), we append a dash and a
4520 * number to make it unique.
4522 struct strbuf
*buf
= &state
->buf
;
4525 strbuf_add(buf
, label
, len
);
4527 for (i
= 2; ; i
++) {
4528 strbuf_setlen(buf
, len
);
4529 strbuf_addf(buf
, "-%d", i
);
4530 if (!hashmap_get_from_hash(&state
->labels
,
4539 FLEX_ALLOC_STR(labels_entry
, label
, label
);
4540 hashmap_entry_init(labels_entry
, strihash(label
));
4541 hashmap_add(&state
->labels
, labels_entry
);
4543 FLEX_ALLOC_STR(string_entry
, string
, label
);
4544 oidcpy(&string_entry
->entry
.oid
, oid
);
4545 oidmap_put(&state
->commit2label
, string_entry
);
4547 return string_entry
->string
;
4550 static int make_script_with_merges(struct pretty_print_context
*pp
,
4551 struct rev_info
*revs
, struct strbuf
*out
,
4554 int keep_empty
= flags
& TODO_LIST_KEEP_EMPTY
;
4555 int rebase_cousins
= flags
& TODO_LIST_REBASE_COUSINS
;
4556 struct strbuf buf
= STRBUF_INIT
, oneline
= STRBUF_INIT
;
4557 struct strbuf label
= STRBUF_INIT
;
4558 struct commit_list
*commits
= NULL
, **tail
= &commits
, *iter
;
4559 struct commit_list
*tips
= NULL
, **tips_tail
= &tips
;
4560 struct commit
*commit
;
4561 struct oidmap commit2todo
= OIDMAP_INIT
;
4562 struct string_entry
*entry
;
4563 struct oidset interesting
= OIDSET_INIT
, child_seen
= OIDSET_INIT
,
4564 shown
= OIDSET_INIT
;
4565 struct label_state state
= { OIDMAP_INIT
, { NULL
}, STRBUF_INIT
};
4567 int abbr
= flags
& TODO_LIST_ABBREVIATE_CMDS
;
4568 const char *cmd_pick
= abbr
? "p" : "pick",
4569 *cmd_label
= abbr
? "l" : "label",
4570 *cmd_reset
= abbr
? "t" : "reset",
4571 *cmd_merge
= abbr
? "m" : "merge";
4573 oidmap_init(&commit2todo
, 0);
4574 oidmap_init(&state
.commit2label
, 0);
4575 hashmap_init(&state
.labels
, (hashmap_cmp_fn
) labels_cmp
, NULL
, 0);
4576 strbuf_init(&state
.buf
, 32);
4578 if (revs
->cmdline
.nr
&& (revs
->cmdline
.rev
[0].flags
& BOTTOM
)) {
4579 struct object_id
*oid
= &revs
->cmdline
.rev
[0].item
->oid
;
4580 FLEX_ALLOC_STR(entry
, string
, "onto");
4581 oidcpy(&entry
->entry
.oid
, oid
);
4582 oidmap_put(&state
.commit2label
, entry
);
4587 * - get onelines for all commits
4588 * - gather all branch tips (i.e. 2nd or later parents of merges)
4589 * - label all branch tips
4591 while ((commit
= get_revision(revs
))) {
4592 struct commit_list
*to_merge
;
4593 const char *p1
, *p2
;
4594 struct object_id
*oid
;
4597 tail
= &commit_list_insert(commit
, tail
)->next
;
4598 oidset_insert(&interesting
, &commit
->object
.oid
);
4600 is_empty
= is_original_commit_empty(commit
);
4601 if (!is_empty
&& (commit
->object
.flags
& PATCHSAME
))
4604 strbuf_reset(&oneline
);
4605 pretty_print_commit(pp
, commit
, &oneline
);
4607 to_merge
= commit
->parents
? commit
->parents
->next
: NULL
;
4609 /* non-merge commit: easy case */
4611 if (!keep_empty
&& is_empty
)
4612 strbuf_addf(&buf
, "%c ", comment_line_char
);
4613 strbuf_addf(&buf
, "%s %s %s", cmd_pick
,
4614 oid_to_hex(&commit
->object
.oid
),
4617 FLEX_ALLOC_STR(entry
, string
, buf
.buf
);
4618 oidcpy(&entry
->entry
.oid
, &commit
->object
.oid
);
4619 oidmap_put(&commit2todo
, entry
);
4624 /* Create a label */
4625 strbuf_reset(&label
);
4626 if (skip_prefix(oneline
.buf
, "Merge ", &p1
) &&
4627 (p1
= strchr(p1
, '\'')) &&
4628 (p2
= strchr(++p1
, '\'')))
4629 strbuf_add(&label
, p1
, p2
- p1
);
4630 else if (skip_prefix(oneline
.buf
, "Merge pull request ",
4632 (p1
= strstr(p1
, " from ")))
4633 strbuf_addstr(&label
, p1
+ strlen(" from "));
4635 strbuf_addbuf(&label
, &oneline
);
4637 for (p1
= label
.buf
; *p1
; p1
++)
4642 strbuf_addf(&buf
, "%s -C %s",
4643 cmd_merge
, oid_to_hex(&commit
->object
.oid
));
4645 /* label the tips of merged branches */
4646 for (; to_merge
; to_merge
= to_merge
->next
) {
4647 oid
= &to_merge
->item
->object
.oid
;
4648 strbuf_addch(&buf
, ' ');
4650 if (!oidset_contains(&interesting
, oid
)) {
4651 strbuf_addstr(&buf
, label_oid(oid
, NULL
,
4656 tips_tail
= &commit_list_insert(to_merge
->item
,
4659 strbuf_addstr(&buf
, label_oid(oid
, label
.buf
, &state
));
4661 strbuf_addf(&buf
, " # %s", oneline
.buf
);
4663 FLEX_ALLOC_STR(entry
, string
, buf
.buf
);
4664 oidcpy(&entry
->entry
.oid
, &commit
->object
.oid
);
4665 oidmap_put(&commit2todo
, entry
);
4670 * - label branch points
4671 * - add HEAD to the branch tips
4673 for (iter
= commits
; iter
; iter
= iter
->next
) {
4674 struct commit_list
*parent
= iter
->item
->parents
;
4675 for (; parent
; parent
= parent
->next
) {
4676 struct object_id
*oid
= &parent
->item
->object
.oid
;
4677 if (!oidset_contains(&interesting
, oid
))
4679 if (oidset_insert(&child_seen
, oid
))
4680 label_oid(oid
, "branch-point", &state
);
4683 /* Add HEAD as implict "tip of branch" */
4685 tips_tail
= &commit_list_insert(iter
->item
,
4690 * Third phase: output the todo list. This is a bit tricky, as we
4691 * want to avoid jumping back and forth between revisions. To
4692 * accomplish that goal, we walk backwards from the branch tips,
4693 * gathering commits not yet shown, reversing the list on the fly,
4694 * then outputting that list (labeling revisions as needed).
4696 strbuf_addf(out
, "%s onto\n", cmd_label
);
4697 for (iter
= tips
; iter
; iter
= iter
->next
) {
4698 struct commit_list
*list
= NULL
, *iter2
;
4700 commit
= iter
->item
;
4701 if (oidset_contains(&shown
, &commit
->object
.oid
))
4703 entry
= oidmap_get(&state
.commit2label
, &commit
->object
.oid
);
4706 strbuf_addf(out
, "\n%c Branch %s\n", comment_line_char
, entry
->string
);
4708 strbuf_addch(out
, '\n');
4710 while (oidset_contains(&interesting
, &commit
->object
.oid
) &&
4711 !oidset_contains(&shown
, &commit
->object
.oid
)) {
4712 commit_list_insert(commit
, &list
);
4713 if (!commit
->parents
) {
4717 commit
= commit
->parents
->item
;
4721 strbuf_addf(out
, "%s %s\n", cmd_reset
,
4722 rebase_cousins
? "onto" : "[new root]");
4724 const char *to
= NULL
;
4726 entry
= oidmap_get(&state
.commit2label
,
4727 &commit
->object
.oid
);
4730 else if (!rebase_cousins
)
4731 to
= label_oid(&commit
->object
.oid
, NULL
,
4734 if (!to
|| !strcmp(to
, "onto"))
4735 strbuf_addf(out
, "%s onto\n", cmd_reset
);
4737 strbuf_reset(&oneline
);
4738 pretty_print_commit(pp
, commit
, &oneline
);
4739 strbuf_addf(out
, "%s %s # %s\n",
4740 cmd_reset
, to
, oneline
.buf
);
4744 for (iter2
= list
; iter2
; iter2
= iter2
->next
) {
4745 struct object_id
*oid
= &iter2
->item
->object
.oid
;
4746 entry
= oidmap_get(&commit2todo
, oid
);
4747 /* only show if not already upstream */
4749 strbuf_addf(out
, "%s\n", entry
->string
);
4750 entry
= oidmap_get(&state
.commit2label
, oid
);
4752 strbuf_addf(out
, "%s %s\n",
4753 cmd_label
, entry
->string
);
4754 oidset_insert(&shown
, oid
);
4757 free_commit_list(list
);
4760 free_commit_list(commits
);
4761 free_commit_list(tips
);
4763 strbuf_release(&label
);
4764 strbuf_release(&oneline
);
4765 strbuf_release(&buf
);
4767 oidmap_free(&commit2todo
, 1);
4768 oidmap_free(&state
.commit2label
, 1);
4769 hashmap_free(&state
.labels
, 1);
4770 strbuf_release(&state
.buf
);
4775 int sequencer_make_script(struct repository
*r
, struct strbuf
*out
, int argc
,
4776 const char **argv
, unsigned flags
)
4778 char *format
= NULL
;
4779 struct pretty_print_context pp
= {0};
4780 struct rev_info revs
;
4781 struct commit
*commit
;
4782 int keep_empty
= flags
& TODO_LIST_KEEP_EMPTY
;
4783 const char *insn
= flags
& TODO_LIST_ABBREVIATE_CMDS
? "p" : "pick";
4784 int rebase_merges
= flags
& TODO_LIST_REBASE_MERGES
;
4786 repo_init_revisions(r
, &revs
, NULL
);
4787 revs
.verbose_header
= 1;
4789 revs
.max_parents
= 1;
4790 revs
.cherry_mark
= 1;
4793 revs
.right_only
= 1;
4794 revs
.sort_order
= REV_SORT_IN_GRAPH_ORDER
;
4795 revs
.topo_order
= 1;
4797 revs
.pretty_given
= 1;
4798 git_config_get_string("rebase.instructionFormat", &format
);
4799 if (!format
|| !*format
) {
4801 format
= xstrdup("%s");
4803 get_commit_format(format
, &revs
);
4805 pp
.fmt
= revs
.commit_format
;
4806 pp
.output_encoding
= get_log_output_encoding();
4808 if (setup_revisions(argc
, argv
, &revs
, NULL
) > 1)
4809 return error(_("make_script: unhandled options"));
4811 if (prepare_revision_walk(&revs
) < 0)
4812 return error(_("make_script: error preparing revisions"));
4815 return make_script_with_merges(&pp
, &revs
, out
, flags
);
4817 while ((commit
= get_revision(&revs
))) {
4818 int is_empty
= is_original_commit_empty(commit
);
4820 if (!is_empty
&& (commit
->object
.flags
& PATCHSAME
))
4822 if (!keep_empty
&& is_empty
)
4823 strbuf_addf(out
, "%c ", comment_line_char
);
4824 strbuf_addf(out
, "%s %s ", insn
,
4825 oid_to_hex(&commit
->object
.oid
));
4826 pretty_print_commit(&pp
, commit
, out
);
4827 strbuf_addch(out
, '\n');
4833 * Add commands after pick and (series of) squash/fixup commands
4836 void todo_list_add_exec_commands(struct todo_list
*todo_list
,
4837 struct string_list
*commands
)
4839 struct strbuf
*buf
= &todo_list
->buf
;
4840 size_t base_offset
= buf
->len
;
4841 int i
, insert
, nr
= 0, alloc
= 0;
4842 struct todo_item
*items
= NULL
, *base_items
= NULL
;
4844 base_items
= xcalloc(commands
->nr
, sizeof(struct todo_item
));
4845 for (i
= 0; i
< commands
->nr
; i
++) {
4846 size_t command_len
= strlen(commands
->items
[i
].string
);
4848 strbuf_addstr(buf
, commands
->items
[i
].string
);
4849 strbuf_addch(buf
, '\n');
4851 base_items
[i
].command
= TODO_EXEC
;
4852 base_items
[i
].offset_in_buf
= base_offset
;
4853 base_items
[i
].arg_offset
= base_offset
+ strlen("exec ");
4854 base_items
[i
].arg_len
= command_len
- strlen("exec ");
4856 base_offset
+= command_len
+ 1;
4860 * Insert <commands> after every pick. Here, fixup/squash chains
4861 * are considered part of the pick, so we insert the commands *after*
4862 * those chains if there are any.
4864 * As we insert the exec commands immediatly after rearranging
4865 * any fixups and before the user edits the list, a fixup chain
4866 * can never contain comments (any comments are empty picks that
4867 * have been commented out because the user did not specify
4868 * --keep-empty). So, it is safe to insert an exec command
4869 * without looking at the command following a comment.
4872 for (i
= 0; i
< todo_list
->nr
; i
++) {
4873 enum todo_command command
= todo_list
->items
[i
].command
;
4874 if (insert
&& !is_fixup(command
)) {
4875 ALLOC_GROW(items
, nr
+ commands
->nr
, alloc
);
4876 COPY_ARRAY(items
+ nr
, base_items
, commands
->nr
);
4882 ALLOC_GROW(items
, nr
+ 1, alloc
);
4883 items
[nr
++] = todo_list
->items
[i
];
4885 if (command
== TODO_PICK
|| command
== TODO_MERGE
)
4889 /* insert or append final <commands> */
4890 if (insert
|| nr
== todo_list
->nr
) {
4891 ALLOC_GROW(items
, nr
+ commands
->nr
, alloc
);
4892 COPY_ARRAY(items
+ nr
, base_items
, commands
->nr
);
4897 FREE_AND_NULL(todo_list
->items
);
4898 todo_list
->items
= items
;
4900 todo_list
->alloc
= alloc
;
4903 static void todo_list_to_strbuf(struct repository
*r
, struct todo_list
*todo_list
,
4904 struct strbuf
*buf
, int num
, unsigned flags
)
4906 struct todo_item
*item
;
4907 int i
, max
= todo_list
->nr
;
4909 if (num
> 0 && num
< max
)
4912 for (item
= todo_list
->items
, i
= 0; i
< max
; i
++, item
++) {
4913 /* if the item is not a command write it and continue */
4914 if (item
->command
>= TODO_COMMENT
) {
4915 strbuf_addf(buf
, "%.*s\n", item
->arg_len
,
4916 todo_item_get_arg(todo_list
, item
));
4920 /* add command to the buffer */
4921 if (flags
& TODO_LIST_ABBREVIATE_CMDS
)
4922 strbuf_addch(buf
, command_to_char(item
->command
));
4924 strbuf_addstr(buf
, command_to_string(item
->command
));
4928 const char *oid
= flags
& TODO_LIST_SHORTEN_IDS
?
4929 short_commit_name(item
->commit
) :
4930 oid_to_hex(&item
->commit
->object
.oid
);
4932 if (item
->command
== TODO_MERGE
) {
4933 if (item
->flags
& TODO_EDIT_MERGE_MSG
)
4934 strbuf_addstr(buf
, " -c");
4936 strbuf_addstr(buf
, " -C");
4939 strbuf_addf(buf
, " %s", oid
);
4942 /* add all the rest */
4944 strbuf_addch(buf
, '\n');
4946 strbuf_addf(buf
, " %.*s\n", item
->arg_len
,
4947 todo_item_get_arg(todo_list
, item
));
4951 int todo_list_write_to_file(struct repository
*r
, struct todo_list
*todo_list
,
4952 const char *file
, const char *shortrevisions
,
4953 const char *shortonto
, int num
, unsigned flags
)
4956 struct strbuf buf
= STRBUF_INIT
;
4958 todo_list_to_strbuf(r
, todo_list
, &buf
, num
, flags
);
4959 if (flags
& TODO_LIST_APPEND_TODO_HELP
)
4960 append_todo_help(flags
& TODO_LIST_KEEP_EMPTY
, count_commands(todo_list
),
4961 shortrevisions
, shortonto
, &buf
);
4963 res
= write_message(buf
.buf
, buf
.len
, file
, 0);
4964 strbuf_release(&buf
);
4969 static const char edit_todo_list_advice
[] =
4970 N_("You can fix this with 'git rebase --edit-todo' "
4971 "and then run 'git rebase --continue'.\n"
4972 "Or you can abort the rebase with 'git rebase"
4975 int check_todo_list_from_file(struct repository
*r
)
4977 struct todo_list old_todo
= TODO_LIST_INIT
, new_todo
= TODO_LIST_INIT
;
4980 if (strbuf_read_file_or_whine(&new_todo
.buf
, rebase_path_todo()) < 0) {
4985 if (strbuf_read_file_or_whine(&old_todo
.buf
, rebase_path_todo_backup()) < 0) {
4990 res
= todo_list_parse_insn_buffer(r
, old_todo
.buf
.buf
, &old_todo
);
4992 res
= todo_list_parse_insn_buffer(r
, new_todo
.buf
.buf
, &new_todo
);
4994 res
= todo_list_check(&old_todo
, &new_todo
);
4996 fprintf(stderr
, _(edit_todo_list_advice
));
4998 todo_list_release(&old_todo
);
4999 todo_list_release(&new_todo
);
5004 /* skip picking commits whose parents are unchanged */
5005 static int skip_unnecessary_picks(struct repository
*r
,
5006 struct todo_list
*todo_list
,
5007 struct object_id
*base_oid
)
5009 struct object_id
*parent_oid
;
5012 for (i
= 0; i
< todo_list
->nr
; i
++) {
5013 struct todo_item
*item
= todo_list
->items
+ i
;
5015 if (item
->command
>= TODO_NOOP
)
5017 if (item
->command
!= TODO_PICK
)
5019 if (parse_commit(item
->commit
)) {
5020 return error(_("could not parse commit '%s'"),
5021 oid_to_hex(&item
->commit
->object
.oid
));
5023 if (!item
->commit
->parents
)
5024 break; /* root commit */
5025 if (item
->commit
->parents
->next
)
5026 break; /* merge commit */
5027 parent_oid
= &item
->commit
->parents
->item
->object
.oid
;
5028 if (!oideq(parent_oid
, base_oid
))
5030 oidcpy(base_oid
, &item
->commit
->object
.oid
);
5033 const char *done_path
= rebase_path_done();
5035 if (todo_list_write_to_file(r
, todo_list
, done_path
, NULL
, NULL
, i
, 0)) {
5036 error_errno(_("could not write to '%s'"), done_path
);
5040 MOVE_ARRAY(todo_list
->items
, todo_list
->items
+ i
, todo_list
->nr
- i
);
5042 todo_list
->current
= 0;
5044 if (is_fixup(peek_command(todo_list
, 0)))
5045 record_in_rewritten(base_oid
, peek_command(todo_list
, 0));
5051 int complete_action(struct repository
*r
, struct replay_opts
*opts
, unsigned flags
,
5052 const char *shortrevisions
, const char *onto_name
,
5053 struct commit
*onto
, const char *orig_head
,
5054 struct string_list
*commands
, unsigned autosquash
,
5055 struct todo_list
*todo_list
)
5057 const char *shortonto
, *todo_file
= rebase_path_todo();
5058 struct todo_list new_todo
= TODO_LIST_INIT
;
5059 struct strbuf
*buf
= &todo_list
->buf
;
5060 struct object_id oid
= onto
->object
.oid
;
5063 shortonto
= find_unique_abbrev(&oid
, DEFAULT_ABBREV
);
5065 if (buf
->len
== 0) {
5066 struct todo_item
*item
= append_new_todo(todo_list
);
5067 item
->command
= TODO_NOOP
;
5068 item
->commit
= NULL
;
5069 item
->arg_len
= item
->arg_offset
= item
->flags
= item
->offset_in_buf
= 0;
5072 if (autosquash
&& todo_list_rearrange_squash(todo_list
))
5076 todo_list_add_exec_commands(todo_list
, commands
);
5078 if (count_commands(todo_list
) == 0) {
5079 apply_autostash(opts
);
5080 sequencer_remove_state(opts
);
5082 return error(_("nothing to do"));
5085 res
= edit_todo_list(r
, todo_list
, &new_todo
, shortrevisions
,
5089 else if (res
== -2) {
5090 apply_autostash(opts
);
5091 sequencer_remove_state(opts
);
5094 } else if (res
== -3) {
5095 apply_autostash(opts
);
5096 sequencer_remove_state(opts
);
5097 todo_list_release(&new_todo
);
5099 return error(_("nothing to do"));
5102 if (todo_list_parse_insn_buffer(r
, new_todo
.buf
.buf
, &new_todo
) ||
5103 todo_list_check(todo_list
, &new_todo
)) {
5104 fprintf(stderr
, _(edit_todo_list_advice
));
5105 checkout_onto(r
, opts
, onto_name
, &onto
->object
.oid
, orig_head
);
5106 todo_list_release(&new_todo
);
5111 if (opts
->allow_ff
&& skip_unnecessary_picks(r
, &new_todo
, &oid
)) {
5112 todo_list_release(&new_todo
);
5113 return error(_("could not skip unnecessary pick commands"));
5116 if (todo_list_write_to_file(r
, &new_todo
, todo_file
, NULL
, NULL
, -1,
5117 flags
& ~(TODO_LIST_SHORTEN_IDS
))) {
5118 todo_list_release(&new_todo
);
5119 return error_errno(_("could not write '%s'"), todo_file
);
5122 todo_list_release(&new_todo
);
5124 if (checkout_onto(r
, opts
, onto_name
, &oid
, orig_head
))
5127 if (require_clean_work_tree(r
, "rebase", "", 1, 1))
5130 return sequencer_continue(r
, opts
);
5133 struct subject2item_entry
{
5134 struct hashmap_entry entry
;
5136 char subject
[FLEX_ARRAY
];
5139 static int subject2item_cmp(const void *fndata
,
5140 const struct subject2item_entry
*a
,
5141 const struct subject2item_entry
*b
, const void *key
)
5143 return key
? strcmp(a
->subject
, key
) : strcmp(a
->subject
, b
->subject
);
5146 define_commit_slab(commit_todo_item
, struct todo_item
*);
5149 * Rearrange the todo list that has both "pick commit-id msg" and "pick
5150 * commit-id fixup!/squash! msg" in it so that the latter is put immediately
5151 * after the former, and change "pick" to "fixup"/"squash".
5153 * Note that if the config has specified a custom instruction format, each log
5154 * message will have to be retrieved from the commit (as the oneline in the
5155 * script cannot be trusted) in order to normalize the autosquash arrangement.
5157 int todo_list_rearrange_squash(struct todo_list
*todo_list
)
5159 struct hashmap subject2item
;
5160 int rearranged
= 0, *next
, *tail
, i
, nr
= 0, alloc
= 0;
5162 struct commit_todo_item commit_todo
;
5163 struct todo_item
*items
= NULL
;
5165 init_commit_todo_item(&commit_todo
);
5167 * The hashmap maps onelines to the respective todo list index.
5169 * If any items need to be rearranged, the next[i] value will indicate
5170 * which item was moved directly after the i'th.
5172 * In that case, last[i] will indicate the index of the latest item to
5173 * be moved to appear after the i'th.
5175 hashmap_init(&subject2item
, (hashmap_cmp_fn
) subject2item_cmp
,
5176 NULL
, todo_list
->nr
);
5177 ALLOC_ARRAY(next
, todo_list
->nr
);
5178 ALLOC_ARRAY(tail
, todo_list
->nr
);
5179 ALLOC_ARRAY(subjects
, todo_list
->nr
);
5180 for (i
= 0; i
< todo_list
->nr
; i
++) {
5181 struct strbuf buf
= STRBUF_INIT
;
5182 struct todo_item
*item
= todo_list
->items
+ i
;
5183 const char *commit_buffer
, *subject
, *p
;
5186 struct subject2item_entry
*entry
;
5188 next
[i
] = tail
[i
] = -1;
5189 if (!item
->commit
|| item
->command
== TODO_DROP
) {
5194 if (is_fixup(item
->command
)) {
5195 clear_commit_todo_item(&commit_todo
);
5196 return error(_("the script was already rearranged."));
5199 *commit_todo_item_at(&commit_todo
, item
->commit
) = item
;
5201 parse_commit(item
->commit
);
5202 commit_buffer
= get_commit_buffer(item
->commit
, NULL
);
5203 find_commit_subject(commit_buffer
, &subject
);
5204 format_subject(&buf
, subject
, " ");
5205 subject
= subjects
[i
] = strbuf_detach(&buf
, &subject_len
);
5206 unuse_commit_buffer(item
->commit
, commit_buffer
);
5207 if ((skip_prefix(subject
, "fixup! ", &p
) ||
5208 skip_prefix(subject
, "squash! ", &p
))) {
5209 struct commit
*commit2
;
5214 if (!skip_prefix(p
, "fixup! ", &p
) &&
5215 !skip_prefix(p
, "squash! ", &p
))
5219 if ((entry
= hashmap_get_from_hash(&subject2item
,
5221 /* found by title */
5223 else if (!strchr(p
, ' ') &&
5225 lookup_commit_reference_by_name(p
)) &&
5226 *commit_todo_item_at(&commit_todo
, commit2
))
5227 /* found by commit name */
5228 i2
= *commit_todo_item_at(&commit_todo
, commit2
)
5231 /* copy can be a prefix of the commit subject */
5232 for (i2
= 0; i2
< i
; i2
++)
5234 starts_with(subjects
[i2
], p
))
5242 todo_list
->items
[i
].command
=
5243 starts_with(subject
, "fixup!") ?
5244 TODO_FIXUP
: TODO_SQUASH
;
5250 } else if (!hashmap_get_from_hash(&subject2item
,
5251 strhash(subject
), subject
)) {
5252 FLEX_ALLOC_MEM(entry
, subject
, subject
, subject_len
);
5254 hashmap_entry_init(entry
, strhash(entry
->subject
));
5255 hashmap_put(&subject2item
, entry
);
5260 for (i
= 0; i
< todo_list
->nr
; i
++) {
5261 enum todo_command command
= todo_list
->items
[i
].command
;
5265 * Initially, all commands are 'pick's. If it is a
5266 * fixup or a squash now, we have rearranged it.
5268 if (is_fixup(command
))
5272 ALLOC_GROW(items
, nr
+ 1, alloc
);
5273 items
[nr
++] = todo_list
->items
[cur
];
5278 FREE_AND_NULL(todo_list
->items
);
5279 todo_list
->items
= items
;
5281 todo_list
->alloc
= alloc
;
5286 for (i
= 0; i
< todo_list
->nr
; i
++)
5289 hashmap_free(&subject2item
, 1);
5291 clear_commit_todo_item(&commit_todo
);