668c232b05d5bfd9ee2369dbbf68eb444eb5824c
1#include "cache.h"
2#include "config.h"
3#include "lockfile.h"
4#include "dir.h"
5#include "object-store.h"
6#include "object.h"
7#include "commit.h"
8#include "sequencer.h"
9#include "tag.h"
10#include "run-command.h"
11#include "exec-cmd.h"
12#include "utf8.h"
13#include "cache-tree.h"
14#include "diff.h"
15#include "revision.h"
16#include "rerere.h"
17#include "merge-recursive.h"
18#include "refs.h"
19#include "argv-array.h"
20#include "quote.h"
21#include "trailer.h"
22#include "log-tree.h"
23#include "wt-status.h"
24#include "hashmap.h"
25#include "notes-utils.h"
26#include "sigchain.h"
27#include "unpack-trees.h"
28#include "worktree.h"
29#include "oidmap.h"
30#include "oidset.h"
31#include "commit-slab.h"
32#include "alias.h"
33#include "commit-reach.h"
34#include "rebase-interactive.h"
35
36#define GIT_REFLOG_ACTION "GIT_REFLOG_ACTION"
37
38const char sign_off_header[] = "Signed-off-by: ";
39static const char cherry_picked_prefix[] = "(cherry picked from commit ";
40
41GIT_PATH_FUNC(git_path_commit_editmsg, "COMMIT_EDITMSG")
42
43GIT_PATH_FUNC(git_path_seq_dir, "sequencer")
44
45static GIT_PATH_FUNC(git_path_todo_file, "sequencer/todo")
46static GIT_PATH_FUNC(git_path_opts_file, "sequencer/opts")
47static GIT_PATH_FUNC(git_path_head_file, "sequencer/head")
48static GIT_PATH_FUNC(git_path_abort_safety_file, "sequencer/abort-safety")
49
50static GIT_PATH_FUNC(rebase_path, "rebase-merge")
51/*
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'.
56 */
57GIT_PATH_FUNC(rebase_path_todo, "rebase-merge/git-rebase-todo")
58static GIT_PATH_FUNC(rebase_path_todo_backup,
59 "rebase-merge/git-rebase-todo.backup")
60
61/*
62 * The rebase command lines that have already been processed. A line
63 * is moved here when it is first handled, before any associated user
64 * actions.
65 */
66static GIT_PATH_FUNC(rebase_path_done, "rebase-merge/done")
67/*
68 * The file to keep track of how many commands were already processed (e.g.
69 * for the prompt).
70 */
71static GIT_PATH_FUNC(rebase_path_msgnum, "rebase-merge/msgnum")
72/*
73 * The file to keep track of how many commands are to be processed in total
74 * (e.g. for the prompt).
75 */
76static GIT_PATH_FUNC(rebase_path_msgtotal, "rebase-merge/end")
77/*
78 * The commit message that is planned to be used for any changes that
79 * need to be committed following a user interaction.
80 */
81static GIT_PATH_FUNC(rebase_path_message, "rebase-merge/message")
82/*
83 * The file into which is accumulated the suggested commit message for
84 * squash/fixup commands. When the first of a series of squash/fixups
85 * is seen, the file is created and the commit message from the
86 * previous commit and from the first squash/fixup commit are written
87 * to it. The commit message for each subsequent squash/fixup commit
88 * is appended to the file as it is processed.
89 */
90static GIT_PATH_FUNC(rebase_path_squash_msg, "rebase-merge/message-squash")
91/*
92 * If the current series of squash/fixups has not yet included a squash
93 * command, then this file exists and holds the commit message of the
94 * original "pick" commit. (If the series ends without a "squash"
95 * command, then this can be used as the commit message of the combined
96 * commit without opening the editor.)
97 */
98static GIT_PATH_FUNC(rebase_path_fixup_msg, "rebase-merge/message-fixup")
99/*
100 * This file contains the list fixup/squash commands that have been
101 * accumulated into message-fixup or message-squash so far.
102 */
103static GIT_PATH_FUNC(rebase_path_current_fixups, "rebase-merge/current-fixups")
104/*
105 * A script to set the GIT_AUTHOR_NAME, GIT_AUTHOR_EMAIL, and
106 * GIT_AUTHOR_DATE that will be used for the commit that is currently
107 * being rebased.
108 */
109static GIT_PATH_FUNC(rebase_path_author_script, "rebase-merge/author-script")
110/*
111 * When an "edit" rebase command is being processed, the SHA1 of the
112 * commit to be edited is recorded in this file. When "git rebase
113 * --continue" is executed, if there are any staged changes then they
114 * will be amended to the HEAD commit, but only provided the HEAD
115 * commit is still the commit to be edited. When any other rebase
116 * command is processed, this file is deleted.
117 */
118static GIT_PATH_FUNC(rebase_path_amend, "rebase-merge/amend")
119/*
120 * When we stop at a given patch via the "edit" command, this file contains
121 * the abbreviated commit name of the corresponding patch.
122 */
123static GIT_PATH_FUNC(rebase_path_stopped_sha, "rebase-merge/stopped-sha")
124/*
125 * For the post-rewrite hook, we make a list of rewritten commits and
126 * their new sha1s. The rewritten-pending list keeps the sha1s of
127 * commits that have been processed, but not committed yet,
128 * e.g. because they are waiting for a 'squash' command.
129 */
130static GIT_PATH_FUNC(rebase_path_rewritten_list, "rebase-merge/rewritten-list")
131static GIT_PATH_FUNC(rebase_path_rewritten_pending,
132 "rebase-merge/rewritten-pending")
133
134/*
135 * The path of the file containig the OID of the "squash onto" commit, i.e.
136 * the dummy commit used for `reset [new root]`.
137 */
138static GIT_PATH_FUNC(rebase_path_squash_onto, "rebase-merge/squash-onto")
139
140/*
141 * The path of the file listing refs that need to be deleted after the rebase
142 * finishes. This is used by the `label` command to record the need for cleanup.
143 */
144static GIT_PATH_FUNC(rebase_path_refs_to_delete, "rebase-merge/refs-to-delete")
145
146/*
147 * The following files are written by git-rebase just after parsing the
148 * command-line.
149 */
150static GIT_PATH_FUNC(rebase_path_gpg_sign_opt, "rebase-merge/gpg_sign_opt")
151static GIT_PATH_FUNC(rebase_path_orig_head, "rebase-merge/orig-head")
152static GIT_PATH_FUNC(rebase_path_verbose, "rebase-merge/verbose")
153static GIT_PATH_FUNC(rebase_path_signoff, "rebase-merge/signoff")
154static GIT_PATH_FUNC(rebase_path_head_name, "rebase-merge/head-name")
155static GIT_PATH_FUNC(rebase_path_onto, "rebase-merge/onto")
156static GIT_PATH_FUNC(rebase_path_autostash, "rebase-merge/autostash")
157static GIT_PATH_FUNC(rebase_path_strategy, "rebase-merge/strategy")
158static GIT_PATH_FUNC(rebase_path_strategy_opts, "rebase-merge/strategy_opts")
159static GIT_PATH_FUNC(rebase_path_allow_rerere_autoupdate, "rebase-merge/allow_rerere_autoupdate")
160static GIT_PATH_FUNC(rebase_path_quiet, "rebase-merge/quiet")
161
162static int git_sequencer_config(const char *k, const char *v, void *cb)
163{
164 struct replay_opts *opts = cb;
165 int status;
166
167 if (!strcmp(k, "commit.cleanup")) {
168 const char *s;
169
170 status = git_config_string(&s, k, v);
171 if (status)
172 return status;
173
174 if (!strcmp(s, "verbatim"))
175 opts->default_msg_cleanup = COMMIT_MSG_CLEANUP_NONE;
176 else if (!strcmp(s, "whitespace"))
177 opts->default_msg_cleanup = COMMIT_MSG_CLEANUP_SPACE;
178 else if (!strcmp(s, "strip"))
179 opts->default_msg_cleanup = COMMIT_MSG_CLEANUP_ALL;
180 else if (!strcmp(s, "scissors"))
181 opts->default_msg_cleanup = COMMIT_MSG_CLEANUP_SPACE;
182 else
183 warning(_("invalid commit message cleanup mode '%s'"),
184 s);
185
186 free((char *)s);
187 return status;
188 }
189
190 if (!strcmp(k, "commit.gpgsign")) {
191 opts->gpg_sign = git_config_bool(k, v) ? xstrdup("") : NULL;
192 return 0;
193 }
194
195 status = git_gpg_config(k, v, NULL);
196 if (status)
197 return status;
198
199 return git_diff_basic_config(k, v, NULL);
200}
201
202void sequencer_init_config(struct replay_opts *opts)
203{
204 opts->default_msg_cleanup = COMMIT_MSG_CLEANUP_NONE;
205 git_config(git_sequencer_config, opts);
206}
207
208static inline int is_rebase_i(const struct replay_opts *opts)
209{
210 return opts->action == REPLAY_INTERACTIVE_REBASE;
211}
212
213static const char *get_dir(const struct replay_opts *opts)
214{
215 if (is_rebase_i(opts))
216 return rebase_path();
217 return git_path_seq_dir();
218}
219
220static const char *get_todo_path(const struct replay_opts *opts)
221{
222 if (is_rebase_i(opts))
223 return rebase_path_todo();
224 return git_path_todo_file();
225}
226
227/*
228 * Returns 0 for non-conforming footer
229 * Returns 1 for conforming footer
230 * Returns 2 when sob exists within conforming footer
231 * Returns 3 when sob exists within conforming footer as last entry
232 */
233static int has_conforming_footer(struct strbuf *sb, struct strbuf *sob,
234 size_t ignore_footer)
235{
236 struct process_trailer_options opts = PROCESS_TRAILER_OPTIONS_INIT;
237 struct trailer_info info;
238 size_t i;
239 int found_sob = 0, found_sob_last = 0;
240
241 opts.no_divider = 1;
242
243 trailer_info_get(&info, sb->buf, &opts);
244
245 if (info.trailer_start == info.trailer_end)
246 return 0;
247
248 for (i = 0; i < info.trailer_nr; i++)
249 if (sob && !strncmp(info.trailers[i], sob->buf, sob->len)) {
250 found_sob = 1;
251 if (i == info.trailer_nr - 1)
252 found_sob_last = 1;
253 }
254
255 trailer_info_release(&info);
256
257 if (found_sob_last)
258 return 3;
259 if (found_sob)
260 return 2;
261 return 1;
262}
263
264static const char *gpg_sign_opt_quoted(struct replay_opts *opts)
265{
266 static struct strbuf buf = STRBUF_INIT;
267
268 strbuf_reset(&buf);
269 if (opts->gpg_sign)
270 sq_quotef(&buf, "-S%s", opts->gpg_sign);
271 return buf.buf;
272}
273
274int sequencer_remove_state(struct replay_opts *opts)
275{
276 struct strbuf buf = STRBUF_INIT;
277 int i;
278
279 if (is_rebase_i(opts) &&
280 strbuf_read_file(&buf, rebase_path_refs_to_delete(), 0) > 0) {
281 char *p = buf.buf;
282 while (*p) {
283 char *eol = strchr(p, '\n');
284 if (eol)
285 *eol = '\0';
286 if (delete_ref("(rebase -i) cleanup", p, NULL, 0) < 0)
287 warning(_("could not delete '%s'"), p);
288 if (!eol)
289 break;
290 p = eol + 1;
291 }
292 }
293
294 free(opts->gpg_sign);
295 free(opts->strategy);
296 for (i = 0; i < opts->xopts_nr; i++)
297 free(opts->xopts[i]);
298 free(opts->xopts);
299 strbuf_release(&opts->current_fixups);
300
301 strbuf_reset(&buf);
302 strbuf_addstr(&buf, get_dir(opts));
303 remove_dir_recursively(&buf, 0);
304 strbuf_release(&buf);
305
306 return 0;
307}
308
309static const char *action_name(const struct replay_opts *opts)
310{
311 switch (opts->action) {
312 case REPLAY_REVERT:
313 return N_("revert");
314 case REPLAY_PICK:
315 return N_("cherry-pick");
316 case REPLAY_INTERACTIVE_REBASE:
317 return N_("rebase -i");
318 }
319 die(_("unknown action: %d"), opts->action);
320}
321
322struct commit_message {
323 char *parent_label;
324 char *label;
325 char *subject;
326 const char *message;
327};
328
329static const char *short_commit_name(struct commit *commit)
330{
331 return find_unique_abbrev(&commit->object.oid, DEFAULT_ABBREV);
332}
333
334static int get_message(struct commit *commit, struct commit_message *out)
335{
336 const char *abbrev, *subject;
337 int subject_len;
338
339 out->message = logmsg_reencode(commit, NULL, get_commit_output_encoding());
340 abbrev = short_commit_name(commit);
341
342 subject_len = find_commit_subject(out->message, &subject);
343
344 out->subject = xmemdupz(subject, subject_len);
345 out->label = xstrfmt("%s... %s", abbrev, out->subject);
346 out->parent_label = xstrfmt("parent of %s", out->label);
347
348 return 0;
349}
350
351static void free_message(struct commit *commit, struct commit_message *msg)
352{
353 free(msg->parent_label);
354 free(msg->label);
355 free(msg->subject);
356 unuse_commit_buffer(commit, msg->message);
357}
358
359static void print_advice(struct repository *r, int show_hint,
360 struct replay_opts *opts)
361{
362 char *msg = getenv("GIT_CHERRY_PICK_HELP");
363
364 if (msg) {
365 fprintf(stderr, "%s\n", msg);
366 /*
367 * A conflict has occurred but the porcelain
368 * (typically rebase --interactive) wants to take care
369 * of the commit itself so remove CHERRY_PICK_HEAD
370 */
371 unlink(git_path_cherry_pick_head(r));
372 return;
373 }
374
375 if (show_hint) {
376 if (opts->no_commit)
377 advise(_("after resolving the conflicts, mark the corrected paths\n"
378 "with 'git add <paths>' or 'git rm <paths>'"));
379 else
380 advise(_("after resolving the conflicts, mark the corrected paths\n"
381 "with 'git add <paths>' or 'git rm <paths>'\n"
382 "and commit the result with 'git commit'"));
383 }
384}
385
386int write_message(const void *buf, size_t len, const char *filename,
387 int append_eol)
388{
389 struct lock_file msg_file = LOCK_INIT;
390
391 int msg_fd = hold_lock_file_for_update(&msg_file, filename, 0);
392 if (msg_fd < 0)
393 return error_errno(_("could not lock '%s'"), filename);
394 if (write_in_full(msg_fd, buf, len) < 0) {
395 error_errno(_("could not write to '%s'"), filename);
396 rollback_lock_file(&msg_file);
397 return -1;
398 }
399 if (append_eol && write(msg_fd, "\n", 1) < 0) {
400 error_errno(_("could not write eol to '%s'"), filename);
401 rollback_lock_file(&msg_file);
402 return -1;
403 }
404 if (commit_lock_file(&msg_file) < 0)
405 return error(_("failed to finalize '%s'"), filename);
406
407 return 0;
408}
409
410/*
411 * Reads a file that was presumably written by a shell script, i.e. with an
412 * end-of-line marker that needs to be stripped.
413 *
414 * Note that only the last end-of-line marker is stripped, consistent with the
415 * behavior of "$(cat path)" in a shell script.
416 *
417 * Returns 1 if the file was read, 0 if it could not be read or does not exist.
418 */
419static int read_oneliner(struct strbuf *buf,
420 const char *path, int skip_if_empty)
421{
422 int orig_len = buf->len;
423
424 if (!file_exists(path))
425 return 0;
426
427 if (strbuf_read_file(buf, path, 0) < 0) {
428 warning_errno(_("could not read '%s'"), path);
429 return 0;
430 }
431
432 if (buf->len > orig_len && buf->buf[buf->len - 1] == '\n') {
433 if (--buf->len > orig_len && buf->buf[buf->len - 1] == '\r')
434 --buf->len;
435 buf->buf[buf->len] = '\0';
436 }
437
438 if (skip_if_empty && buf->len == orig_len)
439 return 0;
440
441 return 1;
442}
443
444static struct tree *empty_tree(struct repository *r)
445{
446 return lookup_tree(r, the_hash_algo->empty_tree);
447}
448
449static int error_dirty_index(struct index_state *istate, struct replay_opts *opts)
450{
451 if (read_index_unmerged(istate))
452 return error_resolve_conflict(_(action_name(opts)));
453
454 error(_("your local changes would be overwritten by %s."),
455 _(action_name(opts)));
456
457 if (advice_commit_before_merge)
458 advise(_("commit your changes or stash them to proceed."));
459 return -1;
460}
461
462static void update_abort_safety_file(void)
463{
464 struct object_id head;
465
466 /* Do nothing on a single-pick */
467 if (!file_exists(git_path_seq_dir()))
468 return;
469
470 if (!get_oid("HEAD", &head))
471 write_file(git_path_abort_safety_file(), "%s", oid_to_hex(&head));
472 else
473 write_file(git_path_abort_safety_file(), "%s", "");
474}
475
476static int fast_forward_to(struct repository *r,
477 const struct object_id *to,
478 const struct object_id *from,
479 int unborn,
480 struct replay_opts *opts)
481{
482 struct ref_transaction *transaction;
483 struct strbuf sb = STRBUF_INIT;
484 struct strbuf err = STRBUF_INIT;
485
486 read_index(r->index);
487 if (checkout_fast_forward(r, from, to, 1))
488 return -1; /* the callee should have complained already */
489
490 strbuf_addf(&sb, _("%s: fast-forward"), _(action_name(opts)));
491
492 transaction = ref_transaction_begin(&err);
493 if (!transaction ||
494 ref_transaction_update(transaction, "HEAD",
495 to, unborn && !is_rebase_i(opts) ?
496 &null_oid : from,
497 0, sb.buf, &err) ||
498 ref_transaction_commit(transaction, &err)) {
499 ref_transaction_free(transaction);
500 error("%s", err.buf);
501 strbuf_release(&sb);
502 strbuf_release(&err);
503 return -1;
504 }
505
506 strbuf_release(&sb);
507 strbuf_release(&err);
508 ref_transaction_free(transaction);
509 update_abort_safety_file();
510 return 0;
511}
512
513void append_conflicts_hint(struct index_state *istate,
514 struct strbuf *msgbuf)
515{
516 int i;
517
518 strbuf_addch(msgbuf, '\n');
519 strbuf_commented_addf(msgbuf, "Conflicts:\n");
520 for (i = 0; i < istate->cache_nr;) {
521 const struct cache_entry *ce = istate->cache[i++];
522 if (ce_stage(ce)) {
523 strbuf_commented_addf(msgbuf, "\t%s\n", ce->name);
524 while (i < istate->cache_nr &&
525 !strcmp(ce->name, istate->cache[i]->name))
526 i++;
527 }
528 }
529}
530
531static int do_recursive_merge(struct repository *r,
532 struct commit *base, struct commit *next,
533 const char *base_label, const char *next_label,
534 struct object_id *head, struct strbuf *msgbuf,
535 struct replay_opts *opts)
536{
537 struct merge_options o;
538 struct tree *result, *next_tree, *base_tree, *head_tree;
539 int clean;
540 char **xopt;
541 struct lock_file index_lock = LOCK_INIT;
542
543 if (repo_hold_locked_index(r, &index_lock, LOCK_REPORT_ON_ERROR) < 0)
544 return -1;
545
546 read_index(r->index);
547
548 init_merge_options(&o);
549 o.ancestor = base ? base_label : "(empty tree)";
550 o.branch1 = "HEAD";
551 o.branch2 = next ? next_label : "(empty tree)";
552 if (is_rebase_i(opts))
553 o.buffer_output = 2;
554 o.show_rename_progress = 1;
555
556 head_tree = parse_tree_indirect(head);
557 next_tree = next ? get_commit_tree(next) : empty_tree(r);
558 base_tree = base ? get_commit_tree(base) : empty_tree(r);
559
560 for (xopt = opts->xopts; xopt != opts->xopts + opts->xopts_nr; xopt++)
561 parse_merge_opt(&o, *xopt);
562
563 clean = merge_trees(&o,
564 head_tree,
565 next_tree, base_tree, &result);
566 if (is_rebase_i(opts) && clean <= 0)
567 fputs(o.obuf.buf, stdout);
568 strbuf_release(&o.obuf);
569 diff_warn_rename_limit("merge.renamelimit", o.needed_rename_limit, 0);
570 if (clean < 0) {
571 rollback_lock_file(&index_lock);
572 return clean;
573 }
574
575 if (write_locked_index(r->index, &index_lock,
576 COMMIT_LOCK | SKIP_IF_UNCHANGED))
577 /*
578 * TRANSLATORS: %s will be "revert", "cherry-pick" or
579 * "rebase -i".
580 */
581 return error(_("%s: Unable to write new index file"),
582 _(action_name(opts)));
583
584 if (!clean)
585 append_conflicts_hint(r->index, msgbuf);
586
587 return !clean;
588}
589
590static struct object_id *get_cache_tree_oid(struct index_state *istate)
591{
592 if (!istate->cache_tree)
593 istate->cache_tree = cache_tree();
594
595 if (!cache_tree_fully_valid(istate->cache_tree))
596 if (cache_tree_update(istate, 0)) {
597 error(_("unable to update cache tree"));
598 return NULL;
599 }
600
601 return &istate->cache_tree->oid;
602}
603
604static int is_index_unchanged(struct repository *r)
605{
606 struct object_id head_oid, *cache_tree_oid;
607 struct commit *head_commit;
608 struct index_state *istate = r->index;
609
610 if (!resolve_ref_unsafe("HEAD", RESOLVE_REF_READING, &head_oid, NULL))
611 return error(_("could not resolve HEAD commit"));
612
613 head_commit = lookup_commit(r, &head_oid);
614
615 /*
616 * If head_commit is NULL, check_commit, called from
617 * lookup_commit, would have indicated that head_commit is not
618 * a commit object already. parse_commit() will return failure
619 * without further complaints in such a case. Otherwise, if
620 * the commit is invalid, parse_commit() will complain. So
621 * there is nothing for us to say here. Just return failure.
622 */
623 if (parse_commit(head_commit))
624 return -1;
625
626 if (!(cache_tree_oid = get_cache_tree_oid(istate)))
627 return -1;
628
629 return oideq(cache_tree_oid, get_commit_tree_oid(head_commit));
630}
631
632static int write_author_script(const char *message)
633{
634 struct strbuf buf = STRBUF_INIT;
635 const char *eol;
636 int res;
637
638 for (;;)
639 if (!*message || starts_with(message, "\n")) {
640missing_author:
641 /* Missing 'author' line? */
642 unlink(rebase_path_author_script());
643 return 0;
644 } else if (skip_prefix(message, "author ", &message))
645 break;
646 else if ((eol = strchr(message, '\n')))
647 message = eol + 1;
648 else
649 goto missing_author;
650
651 strbuf_addstr(&buf, "GIT_AUTHOR_NAME='");
652 while (*message && *message != '\n' && *message != '\r')
653 if (skip_prefix(message, " <", &message))
654 break;
655 else if (*message != '\'')
656 strbuf_addch(&buf, *(message++));
657 else
658 strbuf_addf(&buf, "'\\%c'", *(message++));
659 strbuf_addstr(&buf, "'\nGIT_AUTHOR_EMAIL='");
660 while (*message && *message != '\n' && *message != '\r')
661 if (skip_prefix(message, "> ", &message))
662 break;
663 else if (*message != '\'')
664 strbuf_addch(&buf, *(message++));
665 else
666 strbuf_addf(&buf, "'\\%c'", *(message++));
667 strbuf_addstr(&buf, "'\nGIT_AUTHOR_DATE='@");
668 while (*message && *message != '\n' && *message != '\r')
669 if (*message != '\'')
670 strbuf_addch(&buf, *(message++));
671 else
672 strbuf_addf(&buf, "'\\%c'", *(message++));
673 strbuf_addch(&buf, '\'');
674 res = write_message(buf.buf, buf.len, rebase_path_author_script(), 1);
675 strbuf_release(&buf);
676 return res;
677}
678
679/**
680 * Take a series of KEY='VALUE' lines where VALUE part is
681 * sq-quoted, and append <KEY, VALUE> at the end of the string list
682 */
683static int parse_key_value_squoted(char *buf, struct string_list *list)
684{
685 while (*buf) {
686 struct string_list_item *item;
687 char *np;
688 char *cp = strchr(buf, '=');
689 if (!cp) {
690 np = strchrnul(buf, '\n');
691 return error(_("no key present in '%.*s'"),
692 (int) (np - buf), buf);
693 }
694 np = strchrnul(cp, '\n');
695 *cp++ = '\0';
696 item = string_list_append(list, buf);
697
698 buf = np + (*np == '\n');
699 *np = '\0';
700 cp = sq_dequote(cp);
701 if (!cp)
702 return error(_("unable to dequote value of '%s'"),
703 item->string);
704 item->util = xstrdup(cp);
705 }
706 return 0;
707}
708
709/**
710 * Reads and parses the state directory's "author-script" file, and sets name,
711 * email and date accordingly.
712 * Returns 0 on success, -1 if the file could not be parsed.
713 *
714 * The author script is of the format:
715 *
716 * GIT_AUTHOR_NAME='$author_name'
717 * GIT_AUTHOR_EMAIL='$author_email'
718 * GIT_AUTHOR_DATE='$author_date'
719 *
720 * where $author_name, $author_email and $author_date are quoted. We are strict
721 * with our parsing, as the file was meant to be eval'd in the old
722 * git-am.sh/git-rebase--interactive.sh scripts, and thus if the file differs
723 * from what this function expects, it is better to bail out than to do
724 * something that the user does not expect.
725 */
726int read_author_script(const char *path, char **name, char **email, char **date,
727 int allow_missing)
728{
729 struct strbuf buf = STRBUF_INIT;
730 struct string_list kv = STRING_LIST_INIT_DUP;
731 int retval = -1; /* assume failure */
732 int i, name_i = -2, email_i = -2, date_i = -2, err = 0;
733
734 if (strbuf_read_file(&buf, path, 256) <= 0) {
735 strbuf_release(&buf);
736 if (errno == ENOENT && allow_missing)
737 return 0;
738 else
739 return error_errno(_("could not open '%s' for reading"),
740 path);
741 }
742
743 if (parse_key_value_squoted(buf.buf, &kv))
744 goto finish;
745
746 for (i = 0; i < kv.nr; i++) {
747 if (!strcmp(kv.items[i].string, "GIT_AUTHOR_NAME")) {
748 if (name_i != -2)
749 name_i = error(_("'GIT_AUTHOR_NAME' already given"));
750 else
751 name_i = i;
752 } else if (!strcmp(kv.items[i].string, "GIT_AUTHOR_EMAIL")) {
753 if (email_i != -2)
754 email_i = error(_("'GIT_AUTHOR_EMAIL' already given"));
755 else
756 email_i = i;
757 } else if (!strcmp(kv.items[i].string, "GIT_AUTHOR_DATE")) {
758 if (date_i != -2)
759 date_i = error(_("'GIT_AUTHOR_DATE' already given"));
760 else
761 date_i = i;
762 } else {
763 err = error(_("unknown variable '%s'"),
764 kv.items[i].string);
765 }
766 }
767 if (name_i == -2)
768 error(_("missing 'GIT_AUTHOR_NAME'"));
769 if (email_i == -2)
770 error(_("missing 'GIT_AUTHOR_EMAIL'"));
771 if (date_i == -2)
772 error(_("missing 'GIT_AUTHOR_DATE'"));
773 if (date_i < 0 || email_i < 0 || date_i < 0 || err)
774 goto finish;
775 *name = kv.items[name_i].util;
776 *email = kv.items[email_i].util;
777 *date = kv.items[date_i].util;
778 retval = 0;
779finish:
780 string_list_clear(&kv, !!retval);
781 strbuf_release(&buf);
782 return retval;
783}
784
785/*
786 * Read a GIT_AUTHOR_NAME, GIT_AUTHOR_EMAIL AND GIT_AUTHOR_DATE from a
787 * file with shell quoting into struct argv_array. Returns -1 on
788 * error, 0 otherwise.
789 */
790static int read_env_script(struct argv_array *env)
791{
792 char *name, *email, *date;
793
794 if (read_author_script(rebase_path_author_script(),
795 &name, &email, &date, 0))
796 return -1;
797
798 argv_array_pushf(env, "GIT_AUTHOR_NAME=%s", name);
799 argv_array_pushf(env, "GIT_AUTHOR_EMAIL=%s", email);
800 argv_array_pushf(env, "GIT_AUTHOR_DATE=%s", date);
801 free(name);
802 free(email);
803 free(date);
804
805 return 0;
806}
807
808static char *get_author(const char *message)
809{
810 size_t len;
811 const char *a;
812
813 a = find_commit_header(message, "author", &len);
814 if (a)
815 return xmemdupz(a, len);
816
817 return NULL;
818}
819
820/* Read author-script and return an ident line (author <email> timestamp) */
821static const char *read_author_ident(struct strbuf *buf)
822{
823 struct strbuf out = STRBUF_INIT;
824 char *name, *email, *date;
825
826 if (read_author_script(rebase_path_author_script(),
827 &name, &email, &date, 0))
828 return NULL;
829
830 /* validate date since fmt_ident() will die() on bad value */
831 if (parse_date(date, &out)){
832 warning(_("invalid date format '%s' in '%s'"),
833 date, rebase_path_author_script());
834 strbuf_release(&out);
835 return NULL;
836 }
837
838 strbuf_reset(&out);
839 strbuf_addstr(&out, fmt_ident(name, email, date, 0));
840 strbuf_swap(buf, &out);
841 strbuf_release(&out);
842 free(name);
843 free(email);
844 free(date);
845 return buf->buf;
846}
847
848static const char staged_changes_advice[] =
849N_("you have staged changes in your working tree\n"
850"If these changes are meant to be squashed into the previous commit, run:\n"
851"\n"
852" git commit --amend %s\n"
853"\n"
854"If they are meant to go into a new commit, run:\n"
855"\n"
856" git commit %s\n"
857"\n"
858"In both cases, once you're done, continue with:\n"
859"\n"
860" git rebase --continue\n");
861
862#define ALLOW_EMPTY (1<<0)
863#define EDIT_MSG (1<<1)
864#define AMEND_MSG (1<<2)
865#define CLEANUP_MSG (1<<3)
866#define VERIFY_MSG (1<<4)
867#define CREATE_ROOT_COMMIT (1<<5)
868
869static int run_command_silent_on_success(struct child_process *cmd)
870{
871 struct strbuf buf = STRBUF_INIT;
872 int rc;
873
874 cmd->stdout_to_stderr = 1;
875 rc = pipe_command(cmd,
876 NULL, 0,
877 NULL, 0,
878 &buf, 0);
879
880 if (rc)
881 fputs(buf.buf, stderr);
882 strbuf_release(&buf);
883 return rc;
884}
885
886/*
887 * If we are cherry-pick, and if the merge did not result in
888 * hand-editing, we will hit this commit and inherit the original
889 * author date and name.
890 *
891 * If we are revert, or if our cherry-pick results in a hand merge,
892 * we had better say that the current user is responsible for that.
893 *
894 * An exception is when run_git_commit() is called during an
895 * interactive rebase: in that case, we will want to retain the
896 * author metadata.
897 */
898static int run_git_commit(struct repository *r,
899 const char *defmsg,
900 struct replay_opts *opts,
901 unsigned int flags)
902{
903 struct child_process cmd = CHILD_PROCESS_INIT;
904 const char *value;
905
906 if ((flags & CREATE_ROOT_COMMIT) && !(flags & AMEND_MSG)) {
907 struct strbuf msg = STRBUF_INIT, script = STRBUF_INIT;
908 const char *author = NULL;
909 struct object_id root_commit, *cache_tree_oid;
910 int res = 0;
911
912 if (is_rebase_i(opts)) {
913 author = read_author_ident(&script);
914 if (!author) {
915 strbuf_release(&script);
916 return -1;
917 }
918 }
919
920 if (!defmsg)
921 BUG("root commit without message");
922
923 if (!(cache_tree_oid = get_cache_tree_oid(r->index)))
924 res = -1;
925
926 if (!res)
927 res = strbuf_read_file(&msg, defmsg, 0);
928
929 if (res <= 0)
930 res = error_errno(_("could not read '%s'"), defmsg);
931 else
932 res = commit_tree(msg.buf, msg.len, cache_tree_oid,
933 NULL, &root_commit, author,
934 opts->gpg_sign);
935
936 strbuf_release(&msg);
937 strbuf_release(&script);
938 if (!res) {
939 update_ref(NULL, "CHERRY_PICK_HEAD", &root_commit, NULL,
940 REF_NO_DEREF, UPDATE_REFS_MSG_ON_ERR);
941 res = update_ref(NULL, "HEAD", &root_commit, NULL, 0,
942 UPDATE_REFS_MSG_ON_ERR);
943 }
944 return res < 0 ? error(_("writing root commit")) : 0;
945 }
946
947 cmd.git_cmd = 1;
948
949 if (is_rebase_i(opts) && read_env_script(&cmd.env_array)) {
950 const char *gpg_opt = gpg_sign_opt_quoted(opts);
951
952 return error(_(staged_changes_advice),
953 gpg_opt, gpg_opt);
954 }
955
956 argv_array_push(&cmd.args, "commit");
957
958 if (!(flags & VERIFY_MSG))
959 argv_array_push(&cmd.args, "-n");
960 if ((flags & AMEND_MSG))
961 argv_array_push(&cmd.args, "--amend");
962 if (opts->gpg_sign)
963 argv_array_pushf(&cmd.args, "-S%s", opts->gpg_sign);
964 if (defmsg)
965 argv_array_pushl(&cmd.args, "-F", defmsg, NULL);
966 else if (!(flags & EDIT_MSG))
967 argv_array_pushl(&cmd.args, "-C", "HEAD", NULL);
968 if ((flags & CLEANUP_MSG))
969 argv_array_push(&cmd.args, "--cleanup=strip");
970 if ((flags & EDIT_MSG))
971 argv_array_push(&cmd.args, "-e");
972 else if (!(flags & CLEANUP_MSG) &&
973 !opts->signoff && !opts->record_origin &&
974 git_config_get_value("commit.cleanup", &value))
975 argv_array_push(&cmd.args, "--cleanup=verbatim");
976
977 if ((flags & ALLOW_EMPTY))
978 argv_array_push(&cmd.args, "--allow-empty");
979
980 if (!(flags & EDIT_MSG))
981 argv_array_push(&cmd.args, "--allow-empty-message");
982
983 if (is_rebase_i(opts) && !(flags & EDIT_MSG))
984 return run_command_silent_on_success(&cmd);
985 else
986 return run_command(&cmd);
987}
988
989static int rest_is_empty(const struct strbuf *sb, int start)
990{
991 int i, eol;
992 const char *nl;
993
994 /* Check if the rest is just whitespace and Signed-off-by's. */
995 for (i = start; i < sb->len; i++) {
996 nl = memchr(sb->buf + i, '\n', sb->len - i);
997 if (nl)
998 eol = nl - sb->buf;
999 else
1000 eol = sb->len;
1001
1002 if (strlen(sign_off_header) <= eol - i &&
1003 starts_with(sb->buf + i, sign_off_header)) {
1004 i = eol;
1005 continue;
1006 }
1007 while (i < eol)
1008 if (!isspace(sb->buf[i++]))
1009 return 0;
1010 }
1011
1012 return 1;
1013}
1014
1015/*
1016 * Find out if the message in the strbuf contains only whitespace and
1017 * Signed-off-by lines.
1018 */
1019int message_is_empty(const struct strbuf *sb,
1020 enum commit_msg_cleanup_mode cleanup_mode)
1021{
1022 if (cleanup_mode == COMMIT_MSG_CLEANUP_NONE && sb->len)
1023 return 0;
1024 return rest_is_empty(sb, 0);
1025}
1026
1027/*
1028 * See if the user edited the message in the editor or left what
1029 * was in the template intact
1030 */
1031int template_untouched(const struct strbuf *sb, const char *template_file,
1032 enum commit_msg_cleanup_mode cleanup_mode)
1033{
1034 struct strbuf tmpl = STRBUF_INIT;
1035 const char *start;
1036
1037 if (cleanup_mode == COMMIT_MSG_CLEANUP_NONE && sb->len)
1038 return 0;
1039
1040 if (!template_file || strbuf_read_file(&tmpl, template_file, 0) <= 0)
1041 return 0;
1042
1043 strbuf_stripspace(&tmpl, cleanup_mode == COMMIT_MSG_CLEANUP_ALL);
1044 if (!skip_prefix(sb->buf, tmpl.buf, &start))
1045 start = sb->buf;
1046 strbuf_release(&tmpl);
1047 return rest_is_empty(sb, start - sb->buf);
1048}
1049
1050int update_head_with_reflog(const struct commit *old_head,
1051 const struct object_id *new_head,
1052 const char *action, const struct strbuf *msg,
1053 struct strbuf *err)
1054{
1055 struct ref_transaction *transaction;
1056 struct strbuf sb = STRBUF_INIT;
1057 const char *nl;
1058 int ret = 0;
1059
1060 if (action) {
1061 strbuf_addstr(&sb, action);
1062 strbuf_addstr(&sb, ": ");
1063 }
1064
1065 nl = strchr(msg->buf, '\n');
1066 if (nl) {
1067 strbuf_add(&sb, msg->buf, nl + 1 - msg->buf);
1068 } else {
1069 strbuf_addbuf(&sb, msg);
1070 strbuf_addch(&sb, '\n');
1071 }
1072
1073 transaction = ref_transaction_begin(err);
1074 if (!transaction ||
1075 ref_transaction_update(transaction, "HEAD", new_head,
1076 old_head ? &old_head->object.oid : &null_oid,
1077 0, sb.buf, err) ||
1078 ref_transaction_commit(transaction, err)) {
1079 ret = -1;
1080 }
1081 ref_transaction_free(transaction);
1082 strbuf_release(&sb);
1083
1084 return ret;
1085}
1086
1087static int run_rewrite_hook(const struct object_id *oldoid,
1088 const struct object_id *newoid)
1089{
1090 struct child_process proc = CHILD_PROCESS_INIT;
1091 const char *argv[3];
1092 int code;
1093 struct strbuf sb = STRBUF_INIT;
1094
1095 argv[0] = find_hook("post-rewrite");
1096 if (!argv[0])
1097 return 0;
1098
1099 argv[1] = "amend";
1100 argv[2] = NULL;
1101
1102 proc.argv = argv;
1103 proc.in = -1;
1104 proc.stdout_to_stderr = 1;
1105
1106 code = start_command(&proc);
1107 if (code)
1108 return code;
1109 strbuf_addf(&sb, "%s %s\n", oid_to_hex(oldoid), oid_to_hex(newoid));
1110 sigchain_push(SIGPIPE, SIG_IGN);
1111 write_in_full(proc.in, sb.buf, sb.len);
1112 close(proc.in);
1113 strbuf_release(&sb);
1114 sigchain_pop(SIGPIPE);
1115 return finish_command(&proc);
1116}
1117
1118void commit_post_rewrite(struct repository *r,
1119 const struct commit *old_head,
1120 const struct object_id *new_head)
1121{
1122 struct notes_rewrite_cfg *cfg;
1123
1124 cfg = init_copy_notes_for_rewrite("amend");
1125 if (cfg) {
1126 /* we are amending, so old_head is not NULL */
1127 copy_note_for_rewrite(cfg, &old_head->object.oid, new_head);
1128 finish_copy_notes_for_rewrite(r, cfg, "Notes added by 'git commit --amend'");
1129 }
1130 run_rewrite_hook(&old_head->object.oid, new_head);
1131}
1132
1133static int run_prepare_commit_msg_hook(struct repository *r,
1134 struct strbuf *msg,
1135 const char *commit)
1136{
1137 struct argv_array hook_env = ARGV_ARRAY_INIT;
1138 int ret;
1139 const char *name;
1140
1141 name = git_path_commit_editmsg();
1142 if (write_message(msg->buf, msg->len, name, 0))
1143 return -1;
1144
1145 argv_array_pushf(&hook_env, "GIT_INDEX_FILE=%s", r->index_file);
1146 argv_array_push(&hook_env, "GIT_EDITOR=:");
1147 if (commit)
1148 ret = run_hook_le(hook_env.argv, "prepare-commit-msg", name,
1149 "commit", commit, NULL);
1150 else
1151 ret = run_hook_le(hook_env.argv, "prepare-commit-msg", name,
1152 "message", NULL);
1153 if (ret)
1154 ret = error(_("'prepare-commit-msg' hook failed"));
1155 argv_array_clear(&hook_env);
1156
1157 return ret;
1158}
1159
1160static const char implicit_ident_advice_noconfig[] =
1161N_("Your name and email address were configured automatically based\n"
1162"on your username and hostname. Please check that they are accurate.\n"
1163"You can suppress this message by setting them explicitly. Run the\n"
1164"following command and follow the instructions in your editor to edit\n"
1165"your configuration file:\n"
1166"\n"
1167" git config --global --edit\n"
1168"\n"
1169"After doing this, you may fix the identity used for this commit with:\n"
1170"\n"
1171" git commit --amend --reset-author\n");
1172
1173static const char implicit_ident_advice_config[] =
1174N_("Your name and email address were configured automatically based\n"
1175"on your username and hostname. Please check that they are accurate.\n"
1176"You can suppress this message by setting them explicitly:\n"
1177"\n"
1178" git config --global user.name \"Your Name\"\n"
1179" git config --global user.email you@example.com\n"
1180"\n"
1181"After doing this, you may fix the identity used for this commit with:\n"
1182"\n"
1183" git commit --amend --reset-author\n");
1184
1185static const char *implicit_ident_advice(void)
1186{
1187 char *user_config = expand_user_path("~/.gitconfig", 0);
1188 char *xdg_config = xdg_config_home("config");
1189 int config_exists = file_exists(user_config) || file_exists(xdg_config);
1190
1191 free(user_config);
1192 free(xdg_config);
1193
1194 if (config_exists)
1195 return _(implicit_ident_advice_config);
1196 else
1197 return _(implicit_ident_advice_noconfig);
1198
1199}
1200
1201void print_commit_summary(struct repository *r,
1202 const char *prefix,
1203 const struct object_id *oid,
1204 unsigned int flags)
1205{
1206 struct rev_info rev;
1207 struct commit *commit;
1208 struct strbuf format = STRBUF_INIT;
1209 const char *head;
1210 struct pretty_print_context pctx = {0};
1211 struct strbuf author_ident = STRBUF_INIT;
1212 struct strbuf committer_ident = STRBUF_INIT;
1213
1214 commit = lookup_commit(r, oid);
1215 if (!commit)
1216 die(_("couldn't look up newly created commit"));
1217 if (parse_commit(commit))
1218 die(_("could not parse newly created commit"));
1219
1220 strbuf_addstr(&format, "format:%h] %s");
1221
1222 format_commit_message(commit, "%an <%ae>", &author_ident, &pctx);
1223 format_commit_message(commit, "%cn <%ce>", &committer_ident, &pctx);
1224 if (strbuf_cmp(&author_ident, &committer_ident)) {
1225 strbuf_addstr(&format, "\n Author: ");
1226 strbuf_addbuf_percentquote(&format, &author_ident);
1227 }
1228 if (flags & SUMMARY_SHOW_AUTHOR_DATE) {
1229 struct strbuf date = STRBUF_INIT;
1230
1231 format_commit_message(commit, "%ad", &date, &pctx);
1232 strbuf_addstr(&format, "\n Date: ");
1233 strbuf_addbuf_percentquote(&format, &date);
1234 strbuf_release(&date);
1235 }
1236 if (!committer_ident_sufficiently_given()) {
1237 strbuf_addstr(&format, "\n Committer: ");
1238 strbuf_addbuf_percentquote(&format, &committer_ident);
1239 if (advice_implicit_identity) {
1240 strbuf_addch(&format, '\n');
1241 strbuf_addstr(&format, implicit_ident_advice());
1242 }
1243 }
1244 strbuf_release(&author_ident);
1245 strbuf_release(&committer_ident);
1246
1247 repo_init_revisions(r, &rev, prefix);
1248 setup_revisions(0, NULL, &rev, NULL);
1249
1250 rev.diff = 1;
1251 rev.diffopt.output_format =
1252 DIFF_FORMAT_SHORTSTAT | DIFF_FORMAT_SUMMARY;
1253
1254 rev.verbose_header = 1;
1255 rev.show_root_diff = 1;
1256 get_commit_format(format.buf, &rev);
1257 rev.always_show_header = 0;
1258 rev.diffopt.detect_rename = DIFF_DETECT_RENAME;
1259 rev.diffopt.break_opt = 0;
1260 diff_setup_done(&rev.diffopt);
1261
1262 head = resolve_ref_unsafe("HEAD", 0, NULL, NULL);
1263 if (!head)
1264 die_errno(_("unable to resolve HEAD after creating commit"));
1265 if (!strcmp(head, "HEAD"))
1266 head = _("detached HEAD");
1267 else
1268 skip_prefix(head, "refs/heads/", &head);
1269 printf("[%s%s ", head, (flags & SUMMARY_INITIAL_COMMIT) ?
1270 _(" (root-commit)") : "");
1271
1272 if (!log_tree_commit(&rev, commit)) {
1273 rev.always_show_header = 1;
1274 rev.use_terminator = 1;
1275 log_tree_commit(&rev, commit);
1276 }
1277
1278 strbuf_release(&format);
1279}
1280
1281static int parse_head(struct repository *r, struct commit **head)
1282{
1283 struct commit *current_head;
1284 struct object_id oid;
1285
1286 if (get_oid("HEAD", &oid)) {
1287 current_head = NULL;
1288 } else {
1289 current_head = lookup_commit_reference(r, &oid);
1290 if (!current_head)
1291 return error(_("could not parse HEAD"));
1292 if (!oideq(&oid, ¤t_head->object.oid)) {
1293 warning(_("HEAD %s is not a commit!"),
1294 oid_to_hex(&oid));
1295 }
1296 if (parse_commit(current_head))
1297 return error(_("could not parse HEAD commit"));
1298 }
1299 *head = current_head;
1300
1301 return 0;
1302}
1303
1304/*
1305 * Try to commit without forking 'git commit'. In some cases we need
1306 * to run 'git commit' to display an error message
1307 *
1308 * Returns:
1309 * -1 - error unable to commit
1310 * 0 - success
1311 * 1 - run 'git commit'
1312 */
1313static int try_to_commit(struct repository *r,
1314 struct strbuf *msg, const char *author,
1315 struct replay_opts *opts, unsigned int flags,
1316 struct object_id *oid)
1317{
1318 struct object_id tree;
1319 struct commit *current_head;
1320 struct commit_list *parents = NULL;
1321 struct commit_extra_header *extra = NULL;
1322 struct strbuf err = STRBUF_INIT;
1323 struct strbuf commit_msg = STRBUF_INIT;
1324 char *amend_author = NULL;
1325 const char *hook_commit = NULL;
1326 enum commit_msg_cleanup_mode cleanup;
1327 int res = 0;
1328
1329 if (parse_head(r, ¤t_head))
1330 return -1;
1331
1332 if (flags & AMEND_MSG) {
1333 const char *exclude_gpgsig[] = { "gpgsig", NULL };
1334 const char *out_enc = get_commit_output_encoding();
1335 const char *message = logmsg_reencode(current_head, NULL,
1336 out_enc);
1337
1338 if (!msg) {
1339 const char *orig_message = NULL;
1340
1341 find_commit_subject(message, &orig_message);
1342 msg = &commit_msg;
1343 strbuf_addstr(msg, orig_message);
1344 hook_commit = "HEAD";
1345 }
1346 author = amend_author = get_author(message);
1347 unuse_commit_buffer(current_head, message);
1348 if (!author) {
1349 res = error(_("unable to parse commit author"));
1350 goto out;
1351 }
1352 parents = copy_commit_list(current_head->parents);
1353 extra = read_commit_extra_headers(current_head, exclude_gpgsig);
1354 } else if (current_head) {
1355 commit_list_insert(current_head, &parents);
1356 }
1357
1358 if (write_index_as_tree(&tree, r->index, r->index_file, 0, NULL)) {
1359 res = error(_("git write-tree failed to write a tree"));
1360 goto out;
1361 }
1362
1363 if (!(flags & ALLOW_EMPTY) && oideq(current_head ?
1364 get_commit_tree_oid(current_head) :
1365 the_hash_algo->empty_tree, &tree)) {
1366 res = 1; /* run 'git commit' to display error message */
1367 goto out;
1368 }
1369
1370 if (find_hook("prepare-commit-msg")) {
1371 res = run_prepare_commit_msg_hook(r, msg, hook_commit);
1372 if (res)
1373 goto out;
1374 if (strbuf_read_file(&commit_msg, git_path_commit_editmsg(),
1375 2048) < 0) {
1376 res = error_errno(_("unable to read commit message "
1377 "from '%s'"),
1378 git_path_commit_editmsg());
1379 goto out;
1380 }
1381 msg = &commit_msg;
1382 }
1383
1384 cleanup = (flags & CLEANUP_MSG) ? COMMIT_MSG_CLEANUP_ALL :
1385 opts->default_msg_cleanup;
1386
1387 if (cleanup != COMMIT_MSG_CLEANUP_NONE)
1388 strbuf_stripspace(msg, cleanup == COMMIT_MSG_CLEANUP_ALL);
1389 if ((flags & EDIT_MSG) && message_is_empty(msg, cleanup)) {
1390 res = 1; /* run 'git commit' to display error message */
1391 goto out;
1392 }
1393
1394 reset_ident_date();
1395
1396 if (commit_tree_extended(msg->buf, msg->len, &tree, parents,
1397 oid, author, opts->gpg_sign, extra)) {
1398 res = error(_("failed to write commit object"));
1399 goto out;
1400 }
1401
1402 if (update_head_with_reflog(current_head, oid,
1403 getenv("GIT_REFLOG_ACTION"), msg, &err)) {
1404 res = error("%s", err.buf);
1405 goto out;
1406 }
1407
1408 if (flags & AMEND_MSG)
1409 commit_post_rewrite(r, current_head, oid);
1410
1411out:
1412 free_commit_extra_headers(extra);
1413 strbuf_release(&err);
1414 strbuf_release(&commit_msg);
1415 free(amend_author);
1416
1417 return res;
1418}
1419
1420static int do_commit(struct repository *r,
1421 const char *msg_file, const char *author,
1422 struct replay_opts *opts, unsigned int flags)
1423{
1424 int res = 1;
1425
1426 if (!(flags & EDIT_MSG) && !(flags & VERIFY_MSG) &&
1427 !(flags & CREATE_ROOT_COMMIT)) {
1428 struct object_id oid;
1429 struct strbuf sb = STRBUF_INIT;
1430
1431 if (msg_file && strbuf_read_file(&sb, msg_file, 2048) < 0)
1432 return error_errno(_("unable to read commit message "
1433 "from '%s'"),
1434 msg_file);
1435
1436 res = try_to_commit(r, msg_file ? &sb : NULL,
1437 author, opts, flags, &oid);
1438 strbuf_release(&sb);
1439 if (!res) {
1440 unlink(git_path_cherry_pick_head(r));
1441 unlink(git_path_merge_msg(r));
1442 if (!is_rebase_i(opts))
1443 print_commit_summary(r, NULL, &oid,
1444 SUMMARY_SHOW_AUTHOR_DATE);
1445 return res;
1446 }
1447 }
1448 if (res == 1)
1449 return run_git_commit(r, msg_file, opts, flags);
1450
1451 return res;
1452}
1453
1454static int is_original_commit_empty(struct commit *commit)
1455{
1456 const struct object_id *ptree_oid;
1457
1458 if (parse_commit(commit))
1459 return error(_("could not parse commit %s"),
1460 oid_to_hex(&commit->object.oid));
1461 if (commit->parents) {
1462 struct commit *parent = commit->parents->item;
1463 if (parse_commit(parent))
1464 return error(_("could not parse parent commit %s"),
1465 oid_to_hex(&parent->object.oid));
1466 ptree_oid = get_commit_tree_oid(parent);
1467 } else {
1468 ptree_oid = the_hash_algo->empty_tree; /* commit is root */
1469 }
1470
1471 return oideq(ptree_oid, get_commit_tree_oid(commit));
1472}
1473
1474/*
1475 * Do we run "git commit" with "--allow-empty"?
1476 */
1477static int allow_empty(struct repository *r,
1478 struct replay_opts *opts,
1479 struct commit *commit)
1480{
1481 int index_unchanged, empty_commit;
1482
1483 /*
1484 * Three cases:
1485 *
1486 * (1) we do not allow empty at all and error out.
1487 *
1488 * (2) we allow ones that were initially empty, but
1489 * forbid the ones that become empty;
1490 *
1491 * (3) we allow both.
1492 */
1493 if (!opts->allow_empty)
1494 return 0; /* let "git commit" barf as necessary */
1495
1496 index_unchanged = is_index_unchanged(r);
1497 if (index_unchanged < 0)
1498 return index_unchanged;
1499 if (!index_unchanged)
1500 return 0; /* we do not have to say --allow-empty */
1501
1502 if (opts->keep_redundant_commits)
1503 return 1;
1504
1505 empty_commit = is_original_commit_empty(commit);
1506 if (empty_commit < 0)
1507 return empty_commit;
1508 if (!empty_commit)
1509 return 0;
1510 else
1511 return 1;
1512}
1513
1514/*
1515 * Note that ordering matters in this enum. Not only must it match the mapping
1516 * below, it is also divided into several sections that matter. When adding
1517 * new commands, make sure you add it in the right section.
1518 */
1519enum todo_command {
1520 /* commands that handle commits */
1521 TODO_PICK = 0,
1522 TODO_REVERT,
1523 TODO_EDIT,
1524 TODO_REWORD,
1525 TODO_FIXUP,
1526 TODO_SQUASH,
1527 /* commands that do something else than handling a single commit */
1528 TODO_EXEC,
1529 TODO_BREAK,
1530 TODO_LABEL,
1531 TODO_RESET,
1532 TODO_MERGE,
1533 /* commands that do nothing but are counted for reporting progress */
1534 TODO_NOOP,
1535 TODO_DROP,
1536 /* comments (not counted for reporting progress) */
1537 TODO_COMMENT
1538};
1539
1540static struct {
1541 char c;
1542 const char *str;
1543} todo_command_info[] = {
1544 { 'p', "pick" },
1545 { 0, "revert" },
1546 { 'e', "edit" },
1547 { 'r', "reword" },
1548 { 'f', "fixup" },
1549 { 's', "squash" },
1550 { 'x', "exec" },
1551 { 'b', "break" },
1552 { 'l', "label" },
1553 { 't', "reset" },
1554 { 'm', "merge" },
1555 { 0, "noop" },
1556 { 'd', "drop" },
1557 { 0, NULL }
1558};
1559
1560static const char *command_to_string(const enum todo_command command)
1561{
1562 if (command < TODO_COMMENT)
1563 return todo_command_info[command].str;
1564 die(_("unknown command: %d"), command);
1565}
1566
1567static char command_to_char(const enum todo_command command)
1568{
1569 if (command < TODO_COMMENT && todo_command_info[command].c)
1570 return todo_command_info[command].c;
1571 return comment_line_char;
1572}
1573
1574static int is_noop(const enum todo_command command)
1575{
1576 return TODO_NOOP <= command;
1577}
1578
1579static int is_fixup(enum todo_command command)
1580{
1581 return command == TODO_FIXUP || command == TODO_SQUASH;
1582}
1583
1584/* Does this command create a (non-merge) commit? */
1585static int is_pick_or_similar(enum todo_command command)
1586{
1587 switch (command) {
1588 case TODO_PICK:
1589 case TODO_REVERT:
1590 case TODO_EDIT:
1591 case TODO_REWORD:
1592 case TODO_FIXUP:
1593 case TODO_SQUASH:
1594 return 1;
1595 default:
1596 return 0;
1597 }
1598}
1599
1600static int update_squash_messages(struct repository *r,
1601 enum todo_command command,
1602 struct commit *commit,
1603 struct replay_opts *opts)
1604{
1605 struct strbuf buf = STRBUF_INIT;
1606 int res;
1607 const char *message, *body;
1608
1609 if (opts->current_fixup_count > 0) {
1610 struct strbuf header = STRBUF_INIT;
1611 char *eol;
1612
1613 if (strbuf_read_file(&buf, rebase_path_squash_msg(), 9) <= 0)
1614 return error(_("could not read '%s'"),
1615 rebase_path_squash_msg());
1616
1617 eol = buf.buf[0] != comment_line_char ?
1618 buf.buf : strchrnul(buf.buf, '\n');
1619
1620 strbuf_addf(&header, "%c ", comment_line_char);
1621 strbuf_addf(&header, _("This is a combination of %d commits."),
1622 opts->current_fixup_count + 2);
1623 strbuf_splice(&buf, 0, eol - buf.buf, header.buf, header.len);
1624 strbuf_release(&header);
1625 } else {
1626 struct object_id head;
1627 struct commit *head_commit;
1628 const char *head_message, *body;
1629
1630 if (get_oid("HEAD", &head))
1631 return error(_("need a HEAD to fixup"));
1632 if (!(head_commit = lookup_commit_reference(r, &head)))
1633 return error(_("could not read HEAD"));
1634 if (!(head_message = get_commit_buffer(head_commit, NULL)))
1635 return error(_("could not read HEAD's commit message"));
1636
1637 find_commit_subject(head_message, &body);
1638 if (write_message(body, strlen(body),
1639 rebase_path_fixup_msg(), 0)) {
1640 unuse_commit_buffer(head_commit, head_message);
1641 return error(_("cannot write '%s'"),
1642 rebase_path_fixup_msg());
1643 }
1644
1645 strbuf_addf(&buf, "%c ", comment_line_char);
1646 strbuf_addf(&buf, _("This is a combination of %d commits."), 2);
1647 strbuf_addf(&buf, "\n%c ", comment_line_char);
1648 strbuf_addstr(&buf, _("This is the 1st commit message:"));
1649 strbuf_addstr(&buf, "\n\n");
1650 strbuf_addstr(&buf, body);
1651
1652 unuse_commit_buffer(head_commit, head_message);
1653 }
1654
1655 if (!(message = get_commit_buffer(commit, NULL)))
1656 return error(_("could not read commit message of %s"),
1657 oid_to_hex(&commit->object.oid));
1658 find_commit_subject(message, &body);
1659
1660 if (command == TODO_SQUASH) {
1661 unlink(rebase_path_fixup_msg());
1662 strbuf_addf(&buf, "\n%c ", comment_line_char);
1663 strbuf_addf(&buf, _("This is the commit message #%d:"),
1664 ++opts->current_fixup_count + 1);
1665 strbuf_addstr(&buf, "\n\n");
1666 strbuf_addstr(&buf, body);
1667 } else if (command == TODO_FIXUP) {
1668 strbuf_addf(&buf, "\n%c ", comment_line_char);
1669 strbuf_addf(&buf, _("The commit message #%d will be skipped:"),
1670 ++opts->current_fixup_count + 1);
1671 strbuf_addstr(&buf, "\n\n");
1672 strbuf_add_commented_lines(&buf, body, strlen(body));
1673 } else
1674 return error(_("unknown command: %d"), command);
1675 unuse_commit_buffer(commit, message);
1676
1677 res = write_message(buf.buf, buf.len, rebase_path_squash_msg(), 0);
1678 strbuf_release(&buf);
1679
1680 if (!res) {
1681 strbuf_addf(&opts->current_fixups, "%s%s %s",
1682 opts->current_fixups.len ? "\n" : "",
1683 command_to_string(command),
1684 oid_to_hex(&commit->object.oid));
1685 res = write_message(opts->current_fixups.buf,
1686 opts->current_fixups.len,
1687 rebase_path_current_fixups(), 0);
1688 }
1689
1690 return res;
1691}
1692
1693static void flush_rewritten_pending(void) {
1694 struct strbuf buf = STRBUF_INIT;
1695 struct object_id newoid;
1696 FILE *out;
1697
1698 if (strbuf_read_file(&buf, rebase_path_rewritten_pending(), (GIT_MAX_HEXSZ + 1) * 2) > 0 &&
1699 !get_oid("HEAD", &newoid) &&
1700 (out = fopen_or_warn(rebase_path_rewritten_list(), "a"))) {
1701 char *bol = buf.buf, *eol;
1702
1703 while (*bol) {
1704 eol = strchrnul(bol, '\n');
1705 fprintf(out, "%.*s %s\n", (int)(eol - bol),
1706 bol, oid_to_hex(&newoid));
1707 if (!*eol)
1708 break;
1709 bol = eol + 1;
1710 }
1711 fclose(out);
1712 unlink(rebase_path_rewritten_pending());
1713 }
1714 strbuf_release(&buf);
1715}
1716
1717static void record_in_rewritten(struct object_id *oid,
1718 enum todo_command next_command) {
1719 FILE *out = fopen_or_warn(rebase_path_rewritten_pending(), "a");
1720
1721 if (!out)
1722 return;
1723
1724 fprintf(out, "%s\n", oid_to_hex(oid));
1725 fclose(out);
1726
1727 if (!is_fixup(next_command))
1728 flush_rewritten_pending();
1729}
1730
1731static int do_pick_commit(struct repository *r,
1732 enum todo_command command,
1733 struct commit *commit,
1734 struct replay_opts *opts,
1735 int final_fixup)
1736{
1737 unsigned int flags = opts->edit ? EDIT_MSG : 0;
1738 const char *msg_file = opts->edit ? NULL : git_path_merge_msg(r);
1739 struct object_id head;
1740 struct commit *base, *next, *parent;
1741 const char *base_label, *next_label;
1742 char *author = NULL;
1743 struct commit_message msg = { NULL, NULL, NULL, NULL };
1744 struct strbuf msgbuf = STRBUF_INIT;
1745 int res, unborn = 0, allow;
1746
1747 if (opts->no_commit) {
1748 /*
1749 * We do not intend to commit immediately. We just want to
1750 * merge the differences in, so let's compute the tree
1751 * that represents the "current" state for merge-recursive
1752 * to work on.
1753 */
1754 if (write_index_as_tree(&head, r->index, r->index_file, 0, NULL))
1755 return error(_("your index file is unmerged."));
1756 } else {
1757 unborn = get_oid("HEAD", &head);
1758 /* Do we want to generate a root commit? */
1759 if (is_pick_or_similar(command) && opts->have_squash_onto &&
1760 oideq(&head, &opts->squash_onto)) {
1761 if (is_fixup(command))
1762 return error(_("cannot fixup root commit"));
1763 flags |= CREATE_ROOT_COMMIT;
1764 unborn = 1;
1765 } else if (unborn)
1766 oidcpy(&head, the_hash_algo->empty_tree);
1767 if (index_differs_from(r, unborn ? empty_tree_oid_hex() : "HEAD",
1768 NULL, 0))
1769 return error_dirty_index(r->index, opts);
1770 }
1771 discard_index(r->index);
1772
1773 if (!commit->parents)
1774 parent = NULL;
1775 else if (commit->parents->next) {
1776 /* Reverting or cherry-picking a merge commit */
1777 int cnt;
1778 struct commit_list *p;
1779
1780 if (!opts->mainline)
1781 return error(_("commit %s is a merge but no -m option was given."),
1782 oid_to_hex(&commit->object.oid));
1783
1784 for (cnt = 1, p = commit->parents;
1785 cnt != opts->mainline && p;
1786 cnt++)
1787 p = p->next;
1788 if (cnt != opts->mainline || !p)
1789 return error(_("commit %s does not have parent %d"),
1790 oid_to_hex(&commit->object.oid), opts->mainline);
1791 parent = p->item;
1792 } else if (0 < opts->mainline)
1793 return error(_("mainline was specified but commit %s is not a merge."),
1794 oid_to_hex(&commit->object.oid));
1795 else
1796 parent = commit->parents->item;
1797
1798 if (get_message(commit, &msg) != 0)
1799 return error(_("cannot get commit message for %s"),
1800 oid_to_hex(&commit->object.oid));
1801
1802 if (opts->allow_ff && !is_fixup(command) &&
1803 ((parent && oideq(&parent->object.oid, &head)) ||
1804 (!parent && unborn))) {
1805 if (is_rebase_i(opts))
1806 write_author_script(msg.message);
1807 res = fast_forward_to(r, &commit->object.oid, &head, unborn,
1808 opts);
1809 if (res || command != TODO_REWORD)
1810 goto leave;
1811 flags |= EDIT_MSG | AMEND_MSG | VERIFY_MSG;
1812 msg_file = NULL;
1813 goto fast_forward_edit;
1814 }
1815 if (parent && parse_commit(parent) < 0)
1816 /* TRANSLATORS: The first %s will be a "todo" command like
1817 "revert" or "pick", the second %s a SHA1. */
1818 return error(_("%s: cannot parse parent commit %s"),
1819 command_to_string(command),
1820 oid_to_hex(&parent->object.oid));
1821
1822 /*
1823 * "commit" is an existing commit. We would want to apply
1824 * the difference it introduces since its first parent "prev"
1825 * on top of the current HEAD if we are cherry-pick. Or the
1826 * reverse of it if we are revert.
1827 */
1828
1829 if (command == TODO_REVERT) {
1830 base = commit;
1831 base_label = msg.label;
1832 next = parent;
1833 next_label = msg.parent_label;
1834 strbuf_addstr(&msgbuf, "Revert \"");
1835 strbuf_addstr(&msgbuf, msg.subject);
1836 strbuf_addstr(&msgbuf, "\"\n\nThis reverts commit ");
1837 strbuf_addstr(&msgbuf, oid_to_hex(&commit->object.oid));
1838
1839 if (commit->parents && commit->parents->next) {
1840 strbuf_addstr(&msgbuf, ", reversing\nchanges made to ");
1841 strbuf_addstr(&msgbuf, oid_to_hex(&parent->object.oid));
1842 }
1843 strbuf_addstr(&msgbuf, ".\n");
1844 } else {
1845 const char *p;
1846
1847 base = parent;
1848 base_label = msg.parent_label;
1849 next = commit;
1850 next_label = msg.label;
1851
1852 /* Append the commit log message to msgbuf. */
1853 if (find_commit_subject(msg.message, &p))
1854 strbuf_addstr(&msgbuf, p);
1855
1856 if (opts->record_origin) {
1857 strbuf_complete_line(&msgbuf);
1858 if (!has_conforming_footer(&msgbuf, NULL, 0))
1859 strbuf_addch(&msgbuf, '\n');
1860 strbuf_addstr(&msgbuf, cherry_picked_prefix);
1861 strbuf_addstr(&msgbuf, oid_to_hex(&commit->object.oid));
1862 strbuf_addstr(&msgbuf, ")\n");
1863 }
1864 if (!is_fixup(command))
1865 author = get_author(msg.message);
1866 }
1867
1868 if (command == TODO_REWORD)
1869 flags |= EDIT_MSG | VERIFY_MSG;
1870 else if (is_fixup(command)) {
1871 if (update_squash_messages(r, command, commit, opts))
1872 return -1;
1873 flags |= AMEND_MSG;
1874 if (!final_fixup)
1875 msg_file = rebase_path_squash_msg();
1876 else if (file_exists(rebase_path_fixup_msg())) {
1877 flags |= CLEANUP_MSG;
1878 msg_file = rebase_path_fixup_msg();
1879 } else {
1880 const char *dest = git_path_squash_msg(r);
1881 unlink(dest);
1882 if (copy_file(dest, rebase_path_squash_msg(), 0666))
1883 return error(_("could not rename '%s' to '%s'"),
1884 rebase_path_squash_msg(), dest);
1885 unlink(git_path_merge_msg(r));
1886 msg_file = dest;
1887 flags |= EDIT_MSG;
1888 }
1889 }
1890
1891 if (opts->signoff && !is_fixup(command))
1892 append_signoff(&msgbuf, 0, 0);
1893
1894 if (is_rebase_i(opts) && write_author_script(msg.message) < 0)
1895 res = -1;
1896 else if (!opts->strategy || !strcmp(opts->strategy, "recursive") || command == TODO_REVERT) {
1897 res = do_recursive_merge(r, base, next, base_label, next_label,
1898 &head, &msgbuf, opts);
1899 if (res < 0)
1900 goto leave;
1901
1902 res |= write_message(msgbuf.buf, msgbuf.len,
1903 git_path_merge_msg(r), 0);
1904 } else {
1905 struct commit_list *common = NULL;
1906 struct commit_list *remotes = NULL;
1907
1908 res = write_message(msgbuf.buf, msgbuf.len,
1909 git_path_merge_msg(r), 0);
1910
1911 commit_list_insert(base, &common);
1912 commit_list_insert(next, &remotes);
1913 res |= try_merge_command(r, opts->strategy,
1914 opts->xopts_nr, (const char **)opts->xopts,
1915 common, oid_to_hex(&head), remotes);
1916 free_commit_list(common);
1917 free_commit_list(remotes);
1918 }
1919 strbuf_release(&msgbuf);
1920
1921 /*
1922 * If the merge was clean or if it failed due to conflict, we write
1923 * CHERRY_PICK_HEAD for the subsequent invocation of commit to use.
1924 * However, if the merge did not even start, then we don't want to
1925 * write it at all.
1926 */
1927 if (command == TODO_PICK && !opts->no_commit && (res == 0 || res == 1) &&
1928 update_ref(NULL, "CHERRY_PICK_HEAD", &commit->object.oid, NULL,
1929 REF_NO_DEREF, UPDATE_REFS_MSG_ON_ERR))
1930 res = -1;
1931 if (command == TODO_REVERT && ((opts->no_commit && res == 0) || res == 1) &&
1932 update_ref(NULL, "REVERT_HEAD", &commit->object.oid, NULL,
1933 REF_NO_DEREF, UPDATE_REFS_MSG_ON_ERR))
1934 res = -1;
1935
1936 if (res) {
1937 error(command == TODO_REVERT
1938 ? _("could not revert %s... %s")
1939 : _("could not apply %s... %s"),
1940 short_commit_name(commit), msg.subject);
1941 print_advice(r, res == 1, opts);
1942 repo_rerere(r, opts->allow_rerere_auto);
1943 goto leave;
1944 }
1945
1946 allow = allow_empty(r, opts, commit);
1947 if (allow < 0) {
1948 res = allow;
1949 goto leave;
1950 } else if (allow)
1951 flags |= ALLOW_EMPTY;
1952 if (!opts->no_commit) {
1953fast_forward_edit:
1954 if (author || command == TODO_REVERT || (flags & AMEND_MSG))
1955 res = do_commit(r, msg_file, author, opts, flags);
1956 else
1957 res = error(_("unable to parse commit author"));
1958 }
1959
1960 if (!res && final_fixup) {
1961 unlink(rebase_path_fixup_msg());
1962 unlink(rebase_path_squash_msg());
1963 unlink(rebase_path_current_fixups());
1964 strbuf_reset(&opts->current_fixups);
1965 opts->current_fixup_count = 0;
1966 }
1967
1968leave:
1969 free_message(commit, &msg);
1970 free(author);
1971 update_abort_safety_file();
1972
1973 return res;
1974}
1975
1976static int prepare_revs(struct replay_opts *opts)
1977{
1978 /*
1979 * picking (but not reverting) ranges (but not individual revisions)
1980 * should be done in reverse
1981 */
1982 if (opts->action == REPLAY_PICK && !opts->revs->no_walk)
1983 opts->revs->reverse ^= 1;
1984
1985 if (prepare_revision_walk(opts->revs))
1986 return error(_("revision walk setup failed"));
1987
1988 return 0;
1989}
1990
1991static int read_and_refresh_cache(struct repository *r,
1992 struct replay_opts *opts)
1993{
1994 struct lock_file index_lock = LOCK_INIT;
1995 int index_fd = repo_hold_locked_index(r, &index_lock, 0);
1996 if (repo_read_index(r) < 0) {
1997 rollback_lock_file(&index_lock);
1998 return error(_("git %s: failed to read the index"),
1999 _(action_name(opts)));
2000 }
2001 refresh_index(r->index, REFRESH_QUIET|REFRESH_UNMERGED, NULL, NULL, NULL);
2002 if (index_fd >= 0) {
2003 if (write_locked_index(r->index, &index_lock,
2004 COMMIT_LOCK | SKIP_IF_UNCHANGED)) {
2005 return error(_("git %s: failed to refresh the index"),
2006 _(action_name(opts)));
2007 }
2008 }
2009 return 0;
2010}
2011
2012enum todo_item_flags {
2013 TODO_EDIT_MERGE_MSG = 1
2014};
2015
2016struct todo_item {
2017 enum todo_command command;
2018 struct commit *commit;
2019 unsigned int flags;
2020 const char *arg;
2021 int arg_len;
2022 size_t offset_in_buf;
2023};
2024
2025struct todo_list {
2026 struct strbuf buf;
2027 struct todo_item *items;
2028 int nr, alloc, current;
2029 int done_nr, total_nr;
2030 struct stat_data stat;
2031};
2032
2033#define TODO_LIST_INIT { STRBUF_INIT }
2034
2035static void todo_list_release(struct todo_list *todo_list)
2036{
2037 strbuf_release(&todo_list->buf);
2038 FREE_AND_NULL(todo_list->items);
2039 todo_list->nr = todo_list->alloc = 0;
2040}
2041
2042static struct todo_item *append_new_todo(struct todo_list *todo_list)
2043{
2044 ALLOC_GROW(todo_list->items, todo_list->nr + 1, todo_list->alloc);
2045 return todo_list->items + todo_list->nr++;
2046}
2047
2048static int parse_insn_line(struct repository *r, struct todo_item *item,
2049 const char *bol, char *eol)
2050{
2051 struct object_id commit_oid;
2052 char *end_of_object_name;
2053 int i, saved, status, padding;
2054
2055 item->flags = 0;
2056
2057 /* left-trim */
2058 bol += strspn(bol, " \t");
2059
2060 if (bol == eol || *bol == '\r' || *bol == comment_line_char) {
2061 item->command = TODO_COMMENT;
2062 item->commit = NULL;
2063 item->arg = bol;
2064 item->arg_len = eol - bol;
2065 return 0;
2066 }
2067
2068 for (i = 0; i < TODO_COMMENT; i++)
2069 if (skip_prefix(bol, todo_command_info[i].str, &bol)) {
2070 item->command = i;
2071 break;
2072 } else if ((bol + 1 == eol || bol[1] == ' ') &&
2073 *bol == todo_command_info[i].c) {
2074 bol++;
2075 item->command = i;
2076 break;
2077 }
2078 if (i >= TODO_COMMENT)
2079 return -1;
2080
2081 /* Eat up extra spaces/ tabs before object name */
2082 padding = strspn(bol, " \t");
2083 bol += padding;
2084
2085 if (item->command == TODO_NOOP || item->command == TODO_BREAK) {
2086 if (bol != eol)
2087 return error(_("%s does not accept arguments: '%s'"),
2088 command_to_string(item->command), bol);
2089 item->commit = NULL;
2090 item->arg = bol;
2091 item->arg_len = eol - bol;
2092 return 0;
2093 }
2094
2095 if (!padding)
2096 return error(_("missing arguments for %s"),
2097 command_to_string(item->command));
2098
2099 if (item->command == TODO_EXEC || item->command == TODO_LABEL ||
2100 item->command == TODO_RESET) {
2101 item->commit = NULL;
2102 item->arg = bol;
2103 item->arg_len = (int)(eol - bol);
2104 return 0;
2105 }
2106
2107 if (item->command == TODO_MERGE) {
2108 if (skip_prefix(bol, "-C", &bol))
2109 bol += strspn(bol, " \t");
2110 else if (skip_prefix(bol, "-c", &bol)) {
2111 bol += strspn(bol, " \t");
2112 item->flags |= TODO_EDIT_MERGE_MSG;
2113 } else {
2114 item->flags |= TODO_EDIT_MERGE_MSG;
2115 item->commit = NULL;
2116 item->arg = bol;
2117 item->arg_len = (int)(eol - bol);
2118 return 0;
2119 }
2120 }
2121
2122 end_of_object_name = (char *) bol + strcspn(bol, " \t\n");
2123 saved = *end_of_object_name;
2124 *end_of_object_name = '\0';
2125 status = get_oid(bol, &commit_oid);
2126 *end_of_object_name = saved;
2127
2128 item->arg = end_of_object_name + strspn(end_of_object_name, " \t");
2129 item->arg_len = (int)(eol - item->arg);
2130
2131 if (status < 0)
2132 return -1;
2133
2134 item->commit = lookup_commit_reference(r, &commit_oid);
2135 return !item->commit;
2136}
2137
2138static int parse_insn_buffer(struct repository *r, char *buf,
2139 struct todo_list *todo_list)
2140{
2141 struct todo_item *item;
2142 char *p = buf, *next_p;
2143 int i, res = 0, fixup_okay = file_exists(rebase_path_done());
2144
2145 for (i = 1; *p; i++, p = next_p) {
2146 char *eol = strchrnul(p, '\n');
2147
2148 next_p = *eol ? eol + 1 /* skip LF */ : eol;
2149
2150 if (p != eol && eol[-1] == '\r')
2151 eol--; /* strip Carriage Return */
2152
2153 item = append_new_todo(todo_list);
2154 item->offset_in_buf = p - todo_list->buf.buf;
2155 if (parse_insn_line(r, item, p, eol)) {
2156 res = error(_("invalid line %d: %.*s"),
2157 i, (int)(eol - p), p);
2158 item->command = TODO_NOOP;
2159 }
2160
2161 if (fixup_okay)
2162 ; /* do nothing */
2163 else if (is_fixup(item->command))
2164 return error(_("cannot '%s' without a previous commit"),
2165 command_to_string(item->command));
2166 else if (!is_noop(item->command))
2167 fixup_okay = 1;
2168 }
2169
2170 return res;
2171}
2172
2173static int count_commands(struct todo_list *todo_list)
2174{
2175 int count = 0, i;
2176
2177 for (i = 0; i < todo_list->nr; i++)
2178 if (todo_list->items[i].command != TODO_COMMENT)
2179 count++;
2180
2181 return count;
2182}
2183
2184static int get_item_line_offset(struct todo_list *todo_list, int index)
2185{
2186 return index < todo_list->nr ?
2187 todo_list->items[index].offset_in_buf : todo_list->buf.len;
2188}
2189
2190static const char *get_item_line(struct todo_list *todo_list, int index)
2191{
2192 return todo_list->buf.buf + get_item_line_offset(todo_list, index);
2193}
2194
2195static int get_item_line_length(struct todo_list *todo_list, int index)
2196{
2197 return get_item_line_offset(todo_list, index + 1)
2198 - get_item_line_offset(todo_list, index);
2199}
2200
2201static ssize_t strbuf_read_file_or_whine(struct strbuf *sb, const char *path)
2202{
2203 int fd;
2204 ssize_t len;
2205
2206 fd = open(path, O_RDONLY);
2207 if (fd < 0)
2208 return error_errno(_("could not open '%s'"), path);
2209 len = strbuf_read(sb, fd, 0);
2210 close(fd);
2211 if (len < 0)
2212 return error(_("could not read '%s'."), path);
2213 return len;
2214}
2215
2216static int read_populate_todo(struct repository *r,
2217 struct todo_list *todo_list,
2218 struct replay_opts *opts)
2219{
2220 struct stat st;
2221 const char *todo_file = get_todo_path(opts);
2222 int res;
2223
2224 strbuf_reset(&todo_list->buf);
2225 if (strbuf_read_file_or_whine(&todo_list->buf, todo_file) < 0)
2226 return -1;
2227
2228 res = stat(todo_file, &st);
2229 if (res)
2230 return error(_("could not stat '%s'"), todo_file);
2231 fill_stat_data(&todo_list->stat, &st);
2232
2233 res = parse_insn_buffer(r, todo_list->buf.buf, todo_list);
2234 if (res) {
2235 if (is_rebase_i(opts))
2236 return error(_("please fix this using "
2237 "'git rebase --edit-todo'."));
2238 return error(_("unusable instruction sheet: '%s'"), todo_file);
2239 }
2240
2241 if (!todo_list->nr &&
2242 (!is_rebase_i(opts) || !file_exists(rebase_path_done())))
2243 return error(_("no commits parsed."));
2244
2245 if (!is_rebase_i(opts)) {
2246 enum todo_command valid =
2247 opts->action == REPLAY_PICK ? TODO_PICK : TODO_REVERT;
2248 int i;
2249
2250 for (i = 0; i < todo_list->nr; i++)
2251 if (valid == todo_list->items[i].command)
2252 continue;
2253 else if (valid == TODO_PICK)
2254 return error(_("cannot cherry-pick during a revert."));
2255 else
2256 return error(_("cannot revert during a cherry-pick."));
2257 }
2258
2259 if (is_rebase_i(opts)) {
2260 struct todo_list done = TODO_LIST_INIT;
2261 FILE *f = fopen_or_warn(rebase_path_msgtotal(), "w");
2262
2263 if (strbuf_read_file(&done.buf, rebase_path_done(), 0) > 0 &&
2264 !parse_insn_buffer(r, done.buf.buf, &done))
2265 todo_list->done_nr = count_commands(&done);
2266 else
2267 todo_list->done_nr = 0;
2268
2269 todo_list->total_nr = todo_list->done_nr
2270 + count_commands(todo_list);
2271 todo_list_release(&done);
2272
2273 if (f) {
2274 fprintf(f, "%d\n", todo_list->total_nr);
2275 fclose(f);
2276 }
2277 }
2278
2279 return 0;
2280}
2281
2282static int git_config_string_dup(char **dest,
2283 const char *var, const char *value)
2284{
2285 if (!value)
2286 return config_error_nonbool(var);
2287 free(*dest);
2288 *dest = xstrdup(value);
2289 return 0;
2290}
2291
2292static int populate_opts_cb(const char *key, const char *value, void *data)
2293{
2294 struct replay_opts *opts = data;
2295 int error_flag = 1;
2296
2297 if (!value)
2298 error_flag = 0;
2299 else if (!strcmp(key, "options.no-commit"))
2300 opts->no_commit = git_config_bool_or_int(key, value, &error_flag);
2301 else if (!strcmp(key, "options.edit"))
2302 opts->edit = git_config_bool_or_int(key, value, &error_flag);
2303 else if (!strcmp(key, "options.signoff"))
2304 opts->signoff = git_config_bool_or_int(key, value, &error_flag);
2305 else if (!strcmp(key, "options.record-origin"))
2306 opts->record_origin = git_config_bool_or_int(key, value, &error_flag);
2307 else if (!strcmp(key, "options.allow-ff"))
2308 opts->allow_ff = git_config_bool_or_int(key, value, &error_flag);
2309 else if (!strcmp(key, "options.mainline"))
2310 opts->mainline = git_config_int(key, value);
2311 else if (!strcmp(key, "options.strategy"))
2312 git_config_string_dup(&opts->strategy, key, value);
2313 else if (!strcmp(key, "options.gpg-sign"))
2314 git_config_string_dup(&opts->gpg_sign, key, value);
2315 else if (!strcmp(key, "options.strategy-option")) {
2316 ALLOC_GROW(opts->xopts, opts->xopts_nr + 1, opts->xopts_alloc);
2317 opts->xopts[opts->xopts_nr++] = xstrdup(value);
2318 } else if (!strcmp(key, "options.allow-rerere-auto"))
2319 opts->allow_rerere_auto =
2320 git_config_bool_or_int(key, value, &error_flag) ?
2321 RERERE_AUTOUPDATE : RERERE_NOAUTOUPDATE;
2322 else
2323 return error(_("invalid key: %s"), key);
2324
2325 if (!error_flag)
2326 return error(_("invalid value for %s: %s"), key, value);
2327
2328 return 0;
2329}
2330
2331void parse_strategy_opts(struct replay_opts *opts, char *raw_opts)
2332{
2333 int i;
2334 char *strategy_opts_string = raw_opts;
2335
2336 if (*strategy_opts_string == ' ')
2337 strategy_opts_string++;
2338
2339 opts->xopts_nr = split_cmdline(strategy_opts_string,
2340 (const char ***)&opts->xopts);
2341 for (i = 0; i < opts->xopts_nr; i++) {
2342 const char *arg = opts->xopts[i];
2343
2344 skip_prefix(arg, "--", &arg);
2345 opts->xopts[i] = xstrdup(arg);
2346 }
2347}
2348
2349static void read_strategy_opts(struct replay_opts *opts, struct strbuf *buf)
2350{
2351 strbuf_reset(buf);
2352 if (!read_oneliner(buf, rebase_path_strategy(), 0))
2353 return;
2354 opts->strategy = strbuf_detach(buf, NULL);
2355 if (!read_oneliner(buf, rebase_path_strategy_opts(), 0))
2356 return;
2357
2358 parse_strategy_opts(opts, buf->buf);
2359}
2360
2361static int read_populate_opts(struct replay_opts *opts)
2362{
2363 if (is_rebase_i(opts)) {
2364 struct strbuf buf = STRBUF_INIT;
2365
2366 if (read_oneliner(&buf, rebase_path_gpg_sign_opt(), 1)) {
2367 if (!starts_with(buf.buf, "-S"))
2368 strbuf_reset(&buf);
2369 else {
2370 free(opts->gpg_sign);
2371 opts->gpg_sign = xstrdup(buf.buf + 2);
2372 }
2373 strbuf_reset(&buf);
2374 }
2375
2376 if (read_oneliner(&buf, rebase_path_allow_rerere_autoupdate(), 1)) {
2377 if (!strcmp(buf.buf, "--rerere-autoupdate"))
2378 opts->allow_rerere_auto = RERERE_AUTOUPDATE;
2379 else if (!strcmp(buf.buf, "--no-rerere-autoupdate"))
2380 opts->allow_rerere_auto = RERERE_NOAUTOUPDATE;
2381 strbuf_reset(&buf);
2382 }
2383
2384 if (file_exists(rebase_path_verbose()))
2385 opts->verbose = 1;
2386
2387 if (file_exists(rebase_path_signoff())) {
2388 opts->allow_ff = 0;
2389 opts->signoff = 1;
2390 }
2391
2392 read_strategy_opts(opts, &buf);
2393 strbuf_release(&buf);
2394
2395 if (read_oneliner(&opts->current_fixups,
2396 rebase_path_current_fixups(), 1)) {
2397 const char *p = opts->current_fixups.buf;
2398 opts->current_fixup_count = 1;
2399 while ((p = strchr(p, '\n'))) {
2400 opts->current_fixup_count++;
2401 p++;
2402 }
2403 }
2404
2405 if (read_oneliner(&buf, rebase_path_squash_onto(), 0)) {
2406 if (get_oid_hex(buf.buf, &opts->squash_onto) < 0)
2407 return error(_("unusable squash-onto"));
2408 opts->have_squash_onto = 1;
2409 }
2410
2411 return 0;
2412 }
2413
2414 if (!file_exists(git_path_opts_file()))
2415 return 0;
2416 /*
2417 * The function git_parse_source(), called from git_config_from_file(),
2418 * may die() in case of a syntactically incorrect file. We do not care
2419 * about this case, though, because we wrote that file ourselves, so we
2420 * are pretty certain that it is syntactically correct.
2421 */
2422 if (git_config_from_file(populate_opts_cb, git_path_opts_file(), opts) < 0)
2423 return error(_("malformed options sheet: '%s'"),
2424 git_path_opts_file());
2425 return 0;
2426}
2427
2428static void write_strategy_opts(struct replay_opts *opts)
2429{
2430 int i;
2431 struct strbuf buf = STRBUF_INIT;
2432
2433 for (i = 0; i < opts->xopts_nr; ++i)
2434 strbuf_addf(&buf, " --%s", opts->xopts[i]);
2435
2436 write_file(rebase_path_strategy_opts(), "%s\n", buf.buf);
2437 strbuf_release(&buf);
2438}
2439
2440int write_basic_state(struct replay_opts *opts, const char *head_name,
2441 const char *onto, const char *orig_head)
2442{
2443 const char *quiet = getenv("GIT_QUIET");
2444
2445 if (head_name)
2446 write_file(rebase_path_head_name(), "%s\n", head_name);
2447 if (onto)
2448 write_file(rebase_path_onto(), "%s\n", onto);
2449 if (orig_head)
2450 write_file(rebase_path_orig_head(), "%s\n", orig_head);
2451
2452 if (quiet)
2453 write_file(rebase_path_quiet(), "%s\n", quiet);
2454 else
2455 write_file(rebase_path_quiet(), "\n");
2456
2457 if (opts->verbose)
2458 write_file(rebase_path_verbose(), "%s", "");
2459 if (opts->strategy)
2460 write_file(rebase_path_strategy(), "%s\n", opts->strategy);
2461 if (opts->xopts_nr > 0)
2462 write_strategy_opts(opts);
2463
2464 if (opts->allow_rerere_auto == RERERE_AUTOUPDATE)
2465 write_file(rebase_path_allow_rerere_autoupdate(), "--rerere-autoupdate\n");
2466 else if (opts->allow_rerere_auto == RERERE_NOAUTOUPDATE)
2467 write_file(rebase_path_allow_rerere_autoupdate(), "--no-rerere-autoupdate\n");
2468
2469 if (opts->gpg_sign)
2470 write_file(rebase_path_gpg_sign_opt(), "-S%s\n", opts->gpg_sign);
2471 if (opts->signoff)
2472 write_file(rebase_path_signoff(), "--signoff\n");
2473
2474 return 0;
2475}
2476
2477static int walk_revs_populate_todo(struct todo_list *todo_list,
2478 struct replay_opts *opts)
2479{
2480 enum todo_command command = opts->action == REPLAY_PICK ?
2481 TODO_PICK : TODO_REVERT;
2482 const char *command_string = todo_command_info[command].str;
2483 struct commit *commit;
2484
2485 if (prepare_revs(opts))
2486 return -1;
2487
2488 while ((commit = get_revision(opts->revs))) {
2489 struct todo_item *item = append_new_todo(todo_list);
2490 const char *commit_buffer = get_commit_buffer(commit, NULL);
2491 const char *subject;
2492 int subject_len;
2493
2494 item->command = command;
2495 item->commit = commit;
2496 item->arg = NULL;
2497 item->arg_len = 0;
2498 item->offset_in_buf = todo_list->buf.len;
2499 subject_len = find_commit_subject(commit_buffer, &subject);
2500 strbuf_addf(&todo_list->buf, "%s %s %.*s\n", command_string,
2501 short_commit_name(commit), subject_len, subject);
2502 unuse_commit_buffer(commit, commit_buffer);
2503 }
2504
2505 if (!todo_list->nr)
2506 return error(_("empty commit set passed"));
2507
2508 return 0;
2509}
2510
2511static int create_seq_dir(void)
2512{
2513 if (file_exists(git_path_seq_dir())) {
2514 error(_("a cherry-pick or revert is already in progress"));
2515 advise(_("try \"git cherry-pick (--continue | --quit | --abort)\""));
2516 return -1;
2517 } else if (mkdir(git_path_seq_dir(), 0777) < 0)
2518 return error_errno(_("could not create sequencer directory '%s'"),
2519 git_path_seq_dir());
2520 return 0;
2521}
2522
2523static int save_head(const char *head)
2524{
2525 struct lock_file head_lock = LOCK_INIT;
2526 struct strbuf buf = STRBUF_INIT;
2527 int fd;
2528 ssize_t written;
2529
2530 fd = hold_lock_file_for_update(&head_lock, git_path_head_file(), 0);
2531 if (fd < 0)
2532 return error_errno(_("could not lock HEAD"));
2533 strbuf_addf(&buf, "%s\n", head);
2534 written = write_in_full(fd, buf.buf, buf.len);
2535 strbuf_release(&buf);
2536 if (written < 0) {
2537 error_errno(_("could not write to '%s'"), git_path_head_file());
2538 rollback_lock_file(&head_lock);
2539 return -1;
2540 }
2541 if (commit_lock_file(&head_lock) < 0)
2542 return error(_("failed to finalize '%s'"), git_path_head_file());
2543 return 0;
2544}
2545
2546static int rollback_is_safe(void)
2547{
2548 struct strbuf sb = STRBUF_INIT;
2549 struct object_id expected_head, actual_head;
2550
2551 if (strbuf_read_file(&sb, git_path_abort_safety_file(), 0) >= 0) {
2552 strbuf_trim(&sb);
2553 if (get_oid_hex(sb.buf, &expected_head)) {
2554 strbuf_release(&sb);
2555 die(_("could not parse %s"), git_path_abort_safety_file());
2556 }
2557 strbuf_release(&sb);
2558 }
2559 else if (errno == ENOENT)
2560 oidclr(&expected_head);
2561 else
2562 die_errno(_("could not read '%s'"), git_path_abort_safety_file());
2563
2564 if (get_oid("HEAD", &actual_head))
2565 oidclr(&actual_head);
2566
2567 return oideq(&actual_head, &expected_head);
2568}
2569
2570static int reset_for_rollback(const struct object_id *oid)
2571{
2572 const char *argv[4]; /* reset --merge <arg> + NULL */
2573
2574 argv[0] = "reset";
2575 argv[1] = "--merge";
2576 argv[2] = oid_to_hex(oid);
2577 argv[3] = NULL;
2578 return run_command_v_opt(argv, RUN_GIT_CMD);
2579}
2580
2581static int rollback_single_pick(struct repository *r)
2582{
2583 struct object_id head_oid;
2584
2585 if (!file_exists(git_path_cherry_pick_head(r)) &&
2586 !file_exists(git_path_revert_head(r)))
2587 return error(_("no cherry-pick or revert in progress"));
2588 if (read_ref_full("HEAD", 0, &head_oid, NULL))
2589 return error(_("cannot resolve HEAD"));
2590 if (is_null_oid(&head_oid))
2591 return error(_("cannot abort from a branch yet to be born"));
2592 return reset_for_rollback(&head_oid);
2593}
2594
2595int sequencer_rollback(struct repository *r, struct replay_opts *opts)
2596{
2597 FILE *f;
2598 struct object_id oid;
2599 struct strbuf buf = STRBUF_INIT;
2600 const char *p;
2601
2602 f = fopen(git_path_head_file(), "r");
2603 if (!f && errno == ENOENT) {
2604 /*
2605 * There is no multiple-cherry-pick in progress.
2606 * If CHERRY_PICK_HEAD or REVERT_HEAD indicates
2607 * a single-cherry-pick in progress, abort that.
2608 */
2609 return rollback_single_pick(r);
2610 }
2611 if (!f)
2612 return error_errno(_("cannot open '%s'"), git_path_head_file());
2613 if (strbuf_getline_lf(&buf, f)) {
2614 error(_("cannot read '%s': %s"), git_path_head_file(),
2615 ferror(f) ? strerror(errno) : _("unexpected end of file"));
2616 fclose(f);
2617 goto fail;
2618 }
2619 fclose(f);
2620 if (parse_oid_hex(buf.buf, &oid, &p) || *p != '\0') {
2621 error(_("stored pre-cherry-pick HEAD file '%s' is corrupt"),
2622 git_path_head_file());
2623 goto fail;
2624 }
2625 if (is_null_oid(&oid)) {
2626 error(_("cannot abort from a branch yet to be born"));
2627 goto fail;
2628 }
2629
2630 if (!rollback_is_safe()) {
2631 /* Do not error, just do not rollback */
2632 warning(_("You seem to have moved HEAD. "
2633 "Not rewinding, check your HEAD!"));
2634 } else
2635 if (reset_for_rollback(&oid))
2636 goto fail;
2637 strbuf_release(&buf);
2638 return sequencer_remove_state(opts);
2639fail:
2640 strbuf_release(&buf);
2641 return -1;
2642}
2643
2644static int save_todo(struct todo_list *todo_list, struct replay_opts *opts)
2645{
2646 struct lock_file todo_lock = LOCK_INIT;
2647 const char *todo_path = get_todo_path(opts);
2648 int next = todo_list->current, offset, fd;
2649
2650 /*
2651 * rebase -i writes "git-rebase-todo" without the currently executing
2652 * command, appending it to "done" instead.
2653 */
2654 if (is_rebase_i(opts))
2655 next++;
2656
2657 fd = hold_lock_file_for_update(&todo_lock, todo_path, 0);
2658 if (fd < 0)
2659 return error_errno(_("could not lock '%s'"), todo_path);
2660 offset = get_item_line_offset(todo_list, next);
2661 if (write_in_full(fd, todo_list->buf.buf + offset,
2662 todo_list->buf.len - offset) < 0)
2663 return error_errno(_("could not write to '%s'"), todo_path);
2664 if (commit_lock_file(&todo_lock) < 0)
2665 return error(_("failed to finalize '%s'"), todo_path);
2666
2667 if (is_rebase_i(opts) && next > 0) {
2668 const char *done = rebase_path_done();
2669 int fd = open(done, O_CREAT | O_WRONLY | O_APPEND, 0666);
2670 int ret = 0;
2671
2672 if (fd < 0)
2673 return 0;
2674 if (write_in_full(fd, get_item_line(todo_list, next - 1),
2675 get_item_line_length(todo_list, next - 1))
2676 < 0)
2677 ret = error_errno(_("could not write to '%s'"), done);
2678 if (close(fd) < 0)
2679 ret = error_errno(_("failed to finalize '%s'"), done);
2680 return ret;
2681 }
2682 return 0;
2683}
2684
2685static int save_opts(struct replay_opts *opts)
2686{
2687 const char *opts_file = git_path_opts_file();
2688 int res = 0;
2689
2690 if (opts->no_commit)
2691 res |= git_config_set_in_file_gently(opts_file, "options.no-commit", "true");
2692 if (opts->edit)
2693 res |= git_config_set_in_file_gently(opts_file, "options.edit", "true");
2694 if (opts->signoff)
2695 res |= git_config_set_in_file_gently(opts_file, "options.signoff", "true");
2696 if (opts->record_origin)
2697 res |= git_config_set_in_file_gently(opts_file, "options.record-origin", "true");
2698 if (opts->allow_ff)
2699 res |= git_config_set_in_file_gently(opts_file, "options.allow-ff", "true");
2700 if (opts->mainline) {
2701 struct strbuf buf = STRBUF_INIT;
2702 strbuf_addf(&buf, "%d", opts->mainline);
2703 res |= git_config_set_in_file_gently(opts_file, "options.mainline", buf.buf);
2704 strbuf_release(&buf);
2705 }
2706 if (opts->strategy)
2707 res |= git_config_set_in_file_gently(opts_file, "options.strategy", opts->strategy);
2708 if (opts->gpg_sign)
2709 res |= git_config_set_in_file_gently(opts_file, "options.gpg-sign", opts->gpg_sign);
2710 if (opts->xopts) {
2711 int i;
2712 for (i = 0; i < opts->xopts_nr; i++)
2713 res |= git_config_set_multivar_in_file_gently(opts_file,
2714 "options.strategy-option",
2715 opts->xopts[i], "^$", 0);
2716 }
2717 if (opts->allow_rerere_auto)
2718 res |= git_config_set_in_file_gently(opts_file, "options.allow-rerere-auto",
2719 opts->allow_rerere_auto == RERERE_AUTOUPDATE ?
2720 "true" : "false");
2721 return res;
2722}
2723
2724static int make_patch(struct repository *r,
2725 struct commit *commit,
2726 struct replay_opts *opts)
2727{
2728 struct strbuf buf = STRBUF_INIT;
2729 struct rev_info log_tree_opt;
2730 const char *subject, *p;
2731 int res = 0;
2732
2733 p = short_commit_name(commit);
2734 if (write_message(p, strlen(p), rebase_path_stopped_sha(), 1) < 0)
2735 return -1;
2736 if (update_ref("rebase", "REBASE_HEAD", &commit->object.oid,
2737 NULL, REF_NO_DEREF, UPDATE_REFS_MSG_ON_ERR))
2738 res |= error(_("could not update %s"), "REBASE_HEAD");
2739
2740 strbuf_addf(&buf, "%s/patch", get_dir(opts));
2741 memset(&log_tree_opt, 0, sizeof(log_tree_opt));
2742 repo_init_revisions(r, &log_tree_opt, NULL);
2743 log_tree_opt.abbrev = 0;
2744 log_tree_opt.diff = 1;
2745 log_tree_opt.diffopt.output_format = DIFF_FORMAT_PATCH;
2746 log_tree_opt.disable_stdin = 1;
2747 log_tree_opt.no_commit_id = 1;
2748 log_tree_opt.diffopt.file = fopen(buf.buf, "w");
2749 log_tree_opt.diffopt.use_color = GIT_COLOR_NEVER;
2750 if (!log_tree_opt.diffopt.file)
2751 res |= error_errno(_("could not open '%s'"), buf.buf);
2752 else {
2753 res |= log_tree_commit(&log_tree_opt, commit);
2754 fclose(log_tree_opt.diffopt.file);
2755 }
2756 strbuf_reset(&buf);
2757
2758 strbuf_addf(&buf, "%s/message", get_dir(opts));
2759 if (!file_exists(buf.buf)) {
2760 const char *commit_buffer = get_commit_buffer(commit, NULL);
2761 find_commit_subject(commit_buffer, &subject);
2762 res |= write_message(subject, strlen(subject), buf.buf, 1);
2763 unuse_commit_buffer(commit, commit_buffer);
2764 }
2765 strbuf_release(&buf);
2766
2767 return res;
2768}
2769
2770static int intend_to_amend(void)
2771{
2772 struct object_id head;
2773 char *p;
2774
2775 if (get_oid("HEAD", &head))
2776 return error(_("cannot read HEAD"));
2777
2778 p = oid_to_hex(&head);
2779 return write_message(p, strlen(p), rebase_path_amend(), 1);
2780}
2781
2782static int error_with_patch(struct repository *r,
2783 struct commit *commit,
2784 const char *subject, int subject_len,
2785 struct replay_opts *opts,
2786 int exit_code, int to_amend)
2787{
2788 if (commit) {
2789 if (make_patch(r, commit, opts))
2790 return -1;
2791 } else if (copy_file(rebase_path_message(),
2792 git_path_merge_msg(r), 0666))
2793 return error(_("unable to copy '%s' to '%s'"),
2794 git_path_merge_msg(r), rebase_path_message());
2795
2796 if (to_amend) {
2797 if (intend_to_amend())
2798 return -1;
2799
2800 fprintf(stderr,
2801 _("You can amend the commit now, with\n"
2802 "\n"
2803 " git commit --amend %s\n"
2804 "\n"
2805 "Once you are satisfied with your changes, run\n"
2806 "\n"
2807 " git rebase --continue\n"),
2808 gpg_sign_opt_quoted(opts));
2809 } else if (exit_code) {
2810 if (commit)
2811 fprintf_ln(stderr, _("Could not apply %s... %.*s"),
2812 short_commit_name(commit), subject_len, subject);
2813 else
2814 /*
2815 * We don't have the hash of the parent so
2816 * just print the line from the todo file.
2817 */
2818 fprintf_ln(stderr, _("Could not merge %.*s"),
2819 subject_len, subject);
2820 }
2821
2822 return exit_code;
2823}
2824
2825static int error_failed_squash(struct repository *r,
2826 struct commit *commit,
2827 struct replay_opts *opts,
2828 int subject_len,
2829 const char *subject)
2830{
2831 if (copy_file(rebase_path_message(), rebase_path_squash_msg(), 0666))
2832 return error(_("could not copy '%s' to '%s'"),
2833 rebase_path_squash_msg(), rebase_path_message());
2834 unlink(git_path_merge_msg(r));
2835 if (copy_file(git_path_merge_msg(r), rebase_path_message(), 0666))
2836 return error(_("could not copy '%s' to '%s'"),
2837 rebase_path_message(),
2838 git_path_merge_msg(r));
2839 return error_with_patch(r, commit, subject, subject_len, opts, 1, 0);
2840}
2841
2842static int do_exec(struct repository *r, const char *command_line)
2843{
2844 struct argv_array child_env = ARGV_ARRAY_INIT;
2845 const char *child_argv[] = { NULL, NULL };
2846 int dirty, status;
2847
2848 fprintf(stderr, "Executing: %s\n", command_line);
2849 child_argv[0] = command_line;
2850 argv_array_pushf(&child_env, "GIT_DIR=%s", absolute_path(get_git_dir()));
2851 argv_array_pushf(&child_env, "GIT_WORK_TREE=%s",
2852 absolute_path(get_git_work_tree()));
2853 status = run_command_v_opt_cd_env(child_argv, RUN_USING_SHELL, NULL,
2854 child_env.argv);
2855
2856 /* force re-reading of the cache */
2857 if (discard_index(r->index) < 0 || read_index(r->index) < 0)
2858 return error(_("could not read index"));
2859
2860 dirty = require_clean_work_tree(r, "rebase", NULL, 1, 1);
2861
2862 if (status) {
2863 warning(_("execution failed: %s\n%s"
2864 "You can fix the problem, and then run\n"
2865 "\n"
2866 " git rebase --continue\n"
2867 "\n"),
2868 command_line,
2869 dirty ? N_("and made changes to the index and/or the "
2870 "working tree\n") : "");
2871 if (status == 127)
2872 /* command not found */
2873 status = 1;
2874 } else if (dirty) {
2875 warning(_("execution succeeded: %s\nbut "
2876 "left changes to the index and/or the working tree\n"
2877 "Commit or stash your changes, and then run\n"
2878 "\n"
2879 " git rebase --continue\n"
2880 "\n"), command_line);
2881 status = 1;
2882 }
2883
2884 argv_array_clear(&child_env);
2885
2886 return status;
2887}
2888
2889static int safe_append(const char *filename, const char *fmt, ...)
2890{
2891 va_list ap;
2892 struct lock_file lock = LOCK_INIT;
2893 int fd = hold_lock_file_for_update(&lock, filename,
2894 LOCK_REPORT_ON_ERROR);
2895 struct strbuf buf = STRBUF_INIT;
2896
2897 if (fd < 0)
2898 return -1;
2899
2900 if (strbuf_read_file(&buf, filename, 0) < 0 && errno != ENOENT) {
2901 error_errno(_("could not read '%s'"), filename);
2902 rollback_lock_file(&lock);
2903 return -1;
2904 }
2905 strbuf_complete(&buf, '\n');
2906 va_start(ap, fmt);
2907 strbuf_vaddf(&buf, fmt, ap);
2908 va_end(ap);
2909
2910 if (write_in_full(fd, buf.buf, buf.len) < 0) {
2911 error_errno(_("could not write to '%s'"), filename);
2912 strbuf_release(&buf);
2913 rollback_lock_file(&lock);
2914 return -1;
2915 }
2916 if (commit_lock_file(&lock) < 0) {
2917 strbuf_release(&buf);
2918 rollback_lock_file(&lock);
2919 return error(_("failed to finalize '%s'"), filename);
2920 }
2921
2922 strbuf_release(&buf);
2923 return 0;
2924}
2925
2926static int do_label(struct repository *r, const char *name, int len)
2927{
2928 struct ref_store *refs = get_main_ref_store(r);
2929 struct ref_transaction *transaction;
2930 struct strbuf ref_name = STRBUF_INIT, err = STRBUF_INIT;
2931 struct strbuf msg = STRBUF_INIT;
2932 int ret = 0;
2933 struct object_id head_oid;
2934
2935 if (len == 1 && *name == '#')
2936 return error(_("illegal label name: '%.*s'"), len, name);
2937
2938 strbuf_addf(&ref_name, "refs/rewritten/%.*s", len, name);
2939 strbuf_addf(&msg, "rebase -i (label) '%.*s'", len, name);
2940
2941 transaction = ref_store_transaction_begin(refs, &err);
2942 if (!transaction) {
2943 error("%s", err.buf);
2944 ret = -1;
2945 } else if (get_oid("HEAD", &head_oid)) {
2946 error(_("could not read HEAD"));
2947 ret = -1;
2948 } else if (ref_transaction_update(transaction, ref_name.buf, &head_oid,
2949 NULL, 0, msg.buf, &err) < 0 ||
2950 ref_transaction_commit(transaction, &err)) {
2951 error("%s", err.buf);
2952 ret = -1;
2953 }
2954 ref_transaction_free(transaction);
2955 strbuf_release(&err);
2956 strbuf_release(&msg);
2957
2958 if (!ret)
2959 ret = safe_append(rebase_path_refs_to_delete(),
2960 "%s\n", ref_name.buf);
2961 strbuf_release(&ref_name);
2962
2963 return ret;
2964}
2965
2966static const char *reflog_message(struct replay_opts *opts,
2967 const char *sub_action, const char *fmt, ...);
2968
2969static int do_reset(struct repository *r,
2970 const char *name, int len,
2971 struct replay_opts *opts)
2972{
2973 struct strbuf ref_name = STRBUF_INIT;
2974 struct object_id oid;
2975 struct lock_file lock = LOCK_INIT;
2976 struct tree_desc desc;
2977 struct tree *tree;
2978 struct unpack_trees_options unpack_tree_opts;
2979 int ret = 0;
2980
2981 if (repo_hold_locked_index(r, &lock, LOCK_REPORT_ON_ERROR) < 0)
2982 return -1;
2983
2984 if (len == 10 && !strncmp("[new root]", name, len)) {
2985 if (!opts->have_squash_onto) {
2986 const char *hex;
2987 if (commit_tree("", 0, the_hash_algo->empty_tree,
2988 NULL, &opts->squash_onto,
2989 NULL, NULL))
2990 return error(_("writing fake root commit"));
2991 opts->have_squash_onto = 1;
2992 hex = oid_to_hex(&opts->squash_onto);
2993 if (write_message(hex, strlen(hex),
2994 rebase_path_squash_onto(), 0))
2995 return error(_("writing squash-onto"));
2996 }
2997 oidcpy(&oid, &opts->squash_onto);
2998 } else {
2999 int i;
3000
3001 /* Determine the length of the label */
3002 for (i = 0; i < len; i++)
3003 if (isspace(name[i]))
3004 break;
3005 len = i;
3006
3007 strbuf_addf(&ref_name, "refs/rewritten/%.*s", len, name);
3008 if (get_oid(ref_name.buf, &oid) &&
3009 get_oid(ref_name.buf + strlen("refs/rewritten/"), &oid)) {
3010 error(_("could not read '%s'"), ref_name.buf);
3011 rollback_lock_file(&lock);
3012 strbuf_release(&ref_name);
3013 return -1;
3014 }
3015 }
3016
3017 memset(&unpack_tree_opts, 0, sizeof(unpack_tree_opts));
3018 setup_unpack_trees_porcelain(&unpack_tree_opts, "reset");
3019 unpack_tree_opts.head_idx = 1;
3020 unpack_tree_opts.src_index = r->index;
3021 unpack_tree_opts.dst_index = r->index;
3022 unpack_tree_opts.fn = oneway_merge;
3023 unpack_tree_opts.merge = 1;
3024 unpack_tree_opts.update = 1;
3025
3026 if (read_index_unmerged(r->index)) {
3027 rollback_lock_file(&lock);
3028 strbuf_release(&ref_name);
3029 return error_resolve_conflict(_(action_name(opts)));
3030 }
3031
3032 if (!fill_tree_descriptor(&desc, &oid)) {
3033 error(_("failed to find tree of %s"), oid_to_hex(&oid));
3034 rollback_lock_file(&lock);
3035 free((void *)desc.buffer);
3036 strbuf_release(&ref_name);
3037 return -1;
3038 }
3039
3040 if (unpack_trees(1, &desc, &unpack_tree_opts)) {
3041 rollback_lock_file(&lock);
3042 free((void *)desc.buffer);
3043 strbuf_release(&ref_name);
3044 return -1;
3045 }
3046
3047 tree = parse_tree_indirect(&oid);
3048 prime_cache_tree(r, r->index, tree);
3049
3050 if (write_locked_index(r->index, &lock, COMMIT_LOCK) < 0)
3051 ret = error(_("could not write index"));
3052 free((void *)desc.buffer);
3053
3054 if (!ret)
3055 ret = update_ref(reflog_message(opts, "reset", "'%.*s'",
3056 len, name), "HEAD", &oid,
3057 NULL, 0, UPDATE_REFS_MSG_ON_ERR);
3058
3059 strbuf_release(&ref_name);
3060 return ret;
3061}
3062
3063static struct commit *lookup_label(const char *label, int len,
3064 struct strbuf *buf)
3065{
3066 struct commit *commit;
3067
3068 strbuf_reset(buf);
3069 strbuf_addf(buf, "refs/rewritten/%.*s", len, label);
3070 commit = lookup_commit_reference_by_name(buf->buf);
3071 if (!commit) {
3072 /* fall back to non-rewritten ref or commit */
3073 strbuf_splice(buf, 0, strlen("refs/rewritten/"), "", 0);
3074 commit = lookup_commit_reference_by_name(buf->buf);
3075 }
3076
3077 if (!commit)
3078 error(_("could not resolve '%s'"), buf->buf);
3079
3080 return commit;
3081}
3082
3083static int do_merge(struct repository *r,
3084 struct commit *commit,
3085 const char *arg, int arg_len,
3086 int flags, struct replay_opts *opts)
3087{
3088 int run_commit_flags = (flags & TODO_EDIT_MERGE_MSG) ?
3089 EDIT_MSG | VERIFY_MSG : 0;
3090 struct strbuf ref_name = STRBUF_INIT;
3091 struct commit *head_commit, *merge_commit, *i;
3092 struct commit_list *bases, *j, *reversed = NULL;
3093 struct commit_list *to_merge = NULL, **tail = &to_merge;
3094 struct merge_options o;
3095 int merge_arg_len, oneline_offset, can_fast_forward, ret, k;
3096 static struct lock_file lock;
3097 const char *p;
3098
3099 if (repo_hold_locked_index(r, &lock, LOCK_REPORT_ON_ERROR) < 0) {
3100 ret = -1;
3101 goto leave_merge;
3102 }
3103
3104 head_commit = lookup_commit_reference_by_name("HEAD");
3105 if (!head_commit) {
3106 ret = error(_("cannot merge without a current revision"));
3107 goto leave_merge;
3108 }
3109
3110 /*
3111 * For octopus merges, the arg starts with the list of revisions to be
3112 * merged. The list is optionally followed by '#' and the oneline.
3113 */
3114 merge_arg_len = oneline_offset = arg_len;
3115 for (p = arg; p - arg < arg_len; p += strspn(p, " \t\n")) {
3116 if (!*p)
3117 break;
3118 if (*p == '#' && (!p[1] || isspace(p[1]))) {
3119 p += 1 + strspn(p + 1, " \t\n");
3120 oneline_offset = p - arg;
3121 break;
3122 }
3123 k = strcspn(p, " \t\n");
3124 if (!k)
3125 continue;
3126 merge_commit = lookup_label(p, k, &ref_name);
3127 if (!merge_commit) {
3128 ret = error(_("unable to parse '%.*s'"), k, p);
3129 goto leave_merge;
3130 }
3131 tail = &commit_list_insert(merge_commit, tail)->next;
3132 p += k;
3133 merge_arg_len = p - arg;
3134 }
3135
3136 if (!to_merge) {
3137 ret = error(_("nothing to merge: '%.*s'"), arg_len, arg);
3138 goto leave_merge;
3139 }
3140
3141 if (opts->have_squash_onto &&
3142 oideq(&head_commit->object.oid, &opts->squash_onto)) {
3143 /*
3144 * When the user tells us to "merge" something into a
3145 * "[new root]", let's simply fast-forward to the merge head.
3146 */
3147 rollback_lock_file(&lock);
3148 if (to_merge->next)
3149 ret = error(_("octopus merge cannot be executed on "
3150 "top of a [new root]"));
3151 else
3152 ret = fast_forward_to(r, &to_merge->item->object.oid,
3153 &head_commit->object.oid, 0,
3154 opts);
3155 goto leave_merge;
3156 }
3157
3158 if (commit) {
3159 const char *message = get_commit_buffer(commit, NULL);
3160 const char *body;
3161 int len;
3162
3163 if (!message) {
3164 ret = error(_("could not get commit message of '%s'"),
3165 oid_to_hex(&commit->object.oid));
3166 goto leave_merge;
3167 }
3168 write_author_script(message);
3169 find_commit_subject(message, &body);
3170 len = strlen(body);
3171 ret = write_message(body, len, git_path_merge_msg(r), 0);
3172 unuse_commit_buffer(commit, message);
3173 if (ret) {
3174 error_errno(_("could not write '%s'"),
3175 git_path_merge_msg(r));
3176 goto leave_merge;
3177 }
3178 } else {
3179 struct strbuf buf = STRBUF_INIT;
3180 int len;
3181
3182 strbuf_addf(&buf, "author %s", git_author_info(0));
3183 write_author_script(buf.buf);
3184 strbuf_reset(&buf);
3185
3186 if (oneline_offset < arg_len) {
3187 p = arg + oneline_offset;
3188 len = arg_len - oneline_offset;
3189 } else {
3190 strbuf_addf(&buf, "Merge %s '%.*s'",
3191 to_merge->next ? "branches" : "branch",
3192 merge_arg_len, arg);
3193 p = buf.buf;
3194 len = buf.len;
3195 }
3196
3197 ret = write_message(p, len, git_path_merge_msg(r), 0);
3198 strbuf_release(&buf);
3199 if (ret) {
3200 error_errno(_("could not write '%s'"),
3201 git_path_merge_msg(r));
3202 goto leave_merge;
3203 }
3204 }
3205
3206 /*
3207 * If HEAD is not identical to the first parent of the original merge
3208 * commit, we cannot fast-forward.
3209 */
3210 can_fast_forward = opts->allow_ff && commit && commit->parents &&
3211 oideq(&commit->parents->item->object.oid,
3212 &head_commit->object.oid);
3213
3214 /*
3215 * If any merge head is different from the original one, we cannot
3216 * fast-forward.
3217 */
3218 if (can_fast_forward) {
3219 struct commit_list *p = commit->parents->next;
3220
3221 for (j = to_merge; j && p; j = j->next, p = p->next)
3222 if (!oideq(&j->item->object.oid,
3223 &p->item->object.oid)) {
3224 can_fast_forward = 0;
3225 break;
3226 }
3227 /*
3228 * If the number of merge heads differs from the original merge
3229 * commit, we cannot fast-forward.
3230 */
3231 if (j || p)
3232 can_fast_forward = 0;
3233 }
3234
3235 if (can_fast_forward) {
3236 rollback_lock_file(&lock);
3237 ret = fast_forward_to(r, &commit->object.oid,
3238 &head_commit->object.oid, 0, opts);
3239 goto leave_merge;
3240 }
3241
3242 if (to_merge->next) {
3243 /* Octopus merge */
3244 struct child_process cmd = CHILD_PROCESS_INIT;
3245
3246 if (read_env_script(&cmd.env_array)) {
3247 const char *gpg_opt = gpg_sign_opt_quoted(opts);
3248
3249 ret = error(_(staged_changes_advice), gpg_opt, gpg_opt);
3250 goto leave_merge;
3251 }
3252
3253 cmd.git_cmd = 1;
3254 argv_array_push(&cmd.args, "merge");
3255 argv_array_push(&cmd.args, "-s");
3256 argv_array_push(&cmd.args, "octopus");
3257 argv_array_push(&cmd.args, "--no-edit");
3258 argv_array_push(&cmd.args, "--no-ff");
3259 argv_array_push(&cmd.args, "--no-log");
3260 argv_array_push(&cmd.args, "--no-stat");
3261 argv_array_push(&cmd.args, "-F");
3262 argv_array_push(&cmd.args, git_path_merge_msg(r));
3263 if (opts->gpg_sign)
3264 argv_array_push(&cmd.args, opts->gpg_sign);
3265
3266 /* Add the tips to be merged */
3267 for (j = to_merge; j; j = j->next)
3268 argv_array_push(&cmd.args,
3269 oid_to_hex(&j->item->object.oid));
3270
3271 strbuf_release(&ref_name);
3272 unlink(git_path_cherry_pick_head(r));
3273 rollback_lock_file(&lock);
3274
3275 rollback_lock_file(&lock);
3276 ret = run_command(&cmd);
3277
3278 /* force re-reading of the cache */
3279 if (!ret && (discard_index(r->index) < 0 ||
3280 read_index(r->index) < 0))
3281 ret = error(_("could not read index"));
3282 goto leave_merge;
3283 }
3284
3285 merge_commit = to_merge->item;
3286 bases = get_merge_bases(head_commit, merge_commit);
3287 if (bases && oideq(&merge_commit->object.oid,
3288 &bases->item->object.oid)) {
3289 ret = 0;
3290 /* skip merging an ancestor of HEAD */
3291 goto leave_merge;
3292 }
3293
3294 write_message(oid_to_hex(&merge_commit->object.oid), GIT_SHA1_HEXSZ,
3295 git_path_merge_head(r), 0);
3296 write_message("no-ff", 5, git_path_merge_mode(r), 0);
3297
3298 for (j = bases; j; j = j->next)
3299 commit_list_insert(j->item, &reversed);
3300 free_commit_list(bases);
3301
3302 read_index(r->index);
3303 init_merge_options(&o);
3304 o.branch1 = "HEAD";
3305 o.branch2 = ref_name.buf;
3306 o.buffer_output = 2;
3307
3308 ret = merge_recursive(&o, head_commit, merge_commit, reversed, &i);
3309 if (ret <= 0)
3310 fputs(o.obuf.buf, stdout);
3311 strbuf_release(&o.obuf);
3312 if (ret < 0) {
3313 error(_("could not even attempt to merge '%.*s'"),
3314 merge_arg_len, arg);
3315 goto leave_merge;
3316 }
3317 /*
3318 * The return value of merge_recursive() is 1 on clean, and 0 on
3319 * unclean merge.
3320 *
3321 * Let's reverse that, so that do_merge() returns 0 upon success and
3322 * 1 upon failed merge (keeping the return value -1 for the cases where
3323 * we will want to reschedule the `merge` command).
3324 */
3325 ret = !ret;
3326
3327 if (r->index->cache_changed &&
3328 write_locked_index(r->index, &lock, COMMIT_LOCK)) {
3329 ret = error(_("merge: Unable to write new index file"));
3330 goto leave_merge;
3331 }
3332
3333 rollback_lock_file(&lock);
3334 if (ret)
3335 repo_rerere(r, opts->allow_rerere_auto);
3336 else
3337 /*
3338 * In case of problems, we now want to return a positive
3339 * value (a negative one would indicate that the `merge`
3340 * command needs to be rescheduled).
3341 */
3342 ret = !!run_git_commit(r, git_path_merge_msg(r), opts,
3343 run_commit_flags);
3344
3345leave_merge:
3346 strbuf_release(&ref_name);
3347 rollback_lock_file(&lock);
3348 free_commit_list(to_merge);
3349 return ret;
3350}
3351
3352static int is_final_fixup(struct todo_list *todo_list)
3353{
3354 int i = todo_list->current;
3355
3356 if (!is_fixup(todo_list->items[i].command))
3357 return 0;
3358
3359 while (++i < todo_list->nr)
3360 if (is_fixup(todo_list->items[i].command))
3361 return 0;
3362 else if (!is_noop(todo_list->items[i].command))
3363 break;
3364 return 1;
3365}
3366
3367static enum todo_command peek_command(struct todo_list *todo_list, int offset)
3368{
3369 int i;
3370
3371 for (i = todo_list->current + offset; i < todo_list->nr; i++)
3372 if (!is_noop(todo_list->items[i].command))
3373 return todo_list->items[i].command;
3374
3375 return -1;
3376}
3377
3378static int apply_autostash(struct replay_opts *opts)
3379{
3380 struct strbuf stash_sha1 = STRBUF_INIT;
3381 struct child_process child = CHILD_PROCESS_INIT;
3382 int ret = 0;
3383
3384 if (!read_oneliner(&stash_sha1, rebase_path_autostash(), 1)) {
3385 strbuf_release(&stash_sha1);
3386 return 0;
3387 }
3388 strbuf_trim(&stash_sha1);
3389
3390 child.git_cmd = 1;
3391 child.no_stdout = 1;
3392 child.no_stderr = 1;
3393 argv_array_push(&child.args, "stash");
3394 argv_array_push(&child.args, "apply");
3395 argv_array_push(&child.args, stash_sha1.buf);
3396 if (!run_command(&child))
3397 fprintf(stderr, _("Applied autostash.\n"));
3398 else {
3399 struct child_process store = CHILD_PROCESS_INIT;
3400
3401 store.git_cmd = 1;
3402 argv_array_push(&store.args, "stash");
3403 argv_array_push(&store.args, "store");
3404 argv_array_push(&store.args, "-m");
3405 argv_array_push(&store.args, "autostash");
3406 argv_array_push(&store.args, "-q");
3407 argv_array_push(&store.args, stash_sha1.buf);
3408 if (run_command(&store))
3409 ret = error(_("cannot store %s"), stash_sha1.buf);
3410 else
3411 fprintf(stderr,
3412 _("Applying autostash resulted in conflicts.\n"
3413 "Your changes are safe in the stash.\n"
3414 "You can run \"git stash pop\" or"
3415 " \"git stash drop\" at any time.\n"));
3416 }
3417
3418 strbuf_release(&stash_sha1);
3419 return ret;
3420}
3421
3422static const char *reflog_message(struct replay_opts *opts,
3423 const char *sub_action, const char *fmt, ...)
3424{
3425 va_list ap;
3426 static struct strbuf buf = STRBUF_INIT;
3427
3428 va_start(ap, fmt);
3429 strbuf_reset(&buf);
3430 strbuf_addstr(&buf, action_name(opts));
3431 if (sub_action)
3432 strbuf_addf(&buf, " (%s)", sub_action);
3433 if (fmt) {
3434 strbuf_addstr(&buf, ": ");
3435 strbuf_vaddf(&buf, fmt, ap);
3436 }
3437 va_end(ap);
3438
3439 return buf.buf;
3440}
3441
3442static int run_git_checkout(struct replay_opts *opts, const char *commit,
3443 const char *action)
3444{
3445 struct child_process cmd = CHILD_PROCESS_INIT;
3446
3447 cmd.git_cmd = 1;
3448
3449 argv_array_push(&cmd.args, "checkout");
3450 argv_array_push(&cmd.args, commit);
3451 argv_array_pushf(&cmd.env_array, GIT_REFLOG_ACTION "=%s", action);
3452
3453 if (opts->verbose)
3454 return run_command(&cmd);
3455 else
3456 return run_command_silent_on_success(&cmd);
3457}
3458
3459int prepare_branch_to_be_rebased(struct replay_opts *opts, const char *commit)
3460{
3461 const char *action;
3462
3463 if (commit && *commit) {
3464 action = reflog_message(opts, "start", "checkout %s", commit);
3465 if (run_git_checkout(opts, commit, action))
3466 return error(_("could not checkout %s"), commit);
3467 }
3468
3469 return 0;
3470}
3471
3472static int checkout_onto(struct replay_opts *opts,
3473 const char *onto_name, const char *onto,
3474 const char *orig_head)
3475{
3476 struct object_id oid;
3477 const char *action = reflog_message(opts, "start", "checkout %s", onto_name);
3478
3479 if (get_oid(orig_head, &oid))
3480 return error(_("%s: not a valid OID"), orig_head);
3481
3482 if (run_git_checkout(opts, onto, action)) {
3483 apply_autostash(opts);
3484 sequencer_remove_state(opts);
3485 return error(_("could not detach HEAD"));
3486 }
3487
3488 return update_ref(NULL, "ORIG_HEAD", &oid, NULL, 0, UPDATE_REFS_MSG_ON_ERR);
3489}
3490
3491static int stopped_at_head(struct repository *r)
3492{
3493 struct object_id head;
3494 struct commit *commit;
3495 struct commit_message message;
3496
3497 if (get_oid("HEAD", &head) ||
3498 !(commit = lookup_commit(r, &head)) ||
3499 parse_commit(commit) || get_message(commit, &message))
3500 fprintf(stderr, _("Stopped at HEAD\n"));
3501 else {
3502 fprintf(stderr, _("Stopped at %s\n"), message.label);
3503 free_message(commit, &message);
3504 }
3505 return 0;
3506
3507}
3508
3509static const char rescheduled_advice[] =
3510N_("Could not execute the todo command\n"
3511"\n"
3512" %.*s"
3513"\n"
3514"It has been rescheduled; To edit the command before continuing, please\n"
3515"edit the todo list first:\n"
3516"\n"
3517" git rebase --edit-todo\n"
3518" git rebase --continue\n");
3519
3520static int pick_commits(struct repository *r,
3521 struct todo_list *todo_list,
3522 struct replay_opts *opts)
3523{
3524 int res = 0, reschedule = 0;
3525
3526 setenv(GIT_REFLOG_ACTION, action_name(opts), 0);
3527 if (opts->allow_ff)
3528 assert(!(opts->signoff || opts->no_commit ||
3529 opts->record_origin || opts->edit));
3530 if (read_and_refresh_cache(r, opts))
3531 return -1;
3532
3533 while (todo_list->current < todo_list->nr) {
3534 struct todo_item *item = todo_list->items + todo_list->current;
3535 if (save_todo(todo_list, opts))
3536 return -1;
3537 if (is_rebase_i(opts)) {
3538 if (item->command != TODO_COMMENT) {
3539 FILE *f = fopen(rebase_path_msgnum(), "w");
3540
3541 todo_list->done_nr++;
3542
3543 if (f) {
3544 fprintf(f, "%d\n", todo_list->done_nr);
3545 fclose(f);
3546 }
3547 fprintf(stderr, "Rebasing (%d/%d)%s",
3548 todo_list->done_nr,
3549 todo_list->total_nr,
3550 opts->verbose ? "\n" : "\r");
3551 }
3552 unlink(rebase_path_message());
3553 unlink(rebase_path_author_script());
3554 unlink(rebase_path_stopped_sha());
3555 unlink(rebase_path_amend());
3556 unlink(git_path_merge_head(the_repository));
3557 delete_ref(NULL, "REBASE_HEAD", NULL, REF_NO_DEREF);
3558
3559 if (item->command == TODO_BREAK)
3560 return stopped_at_head(r);
3561 }
3562 if (item->command <= TODO_SQUASH) {
3563 if (is_rebase_i(opts))
3564 setenv("GIT_REFLOG_ACTION", reflog_message(opts,
3565 command_to_string(item->command), NULL),
3566 1);
3567 res = do_pick_commit(r, item->command, item->commit,
3568 opts, is_final_fixup(todo_list));
3569 if (is_rebase_i(opts) && res < 0) {
3570 /* Reschedule */
3571 advise(_(rescheduled_advice),
3572 get_item_line_length(todo_list,
3573 todo_list->current),
3574 get_item_line(todo_list,
3575 todo_list->current));
3576 todo_list->current--;
3577 if (save_todo(todo_list, opts))
3578 return -1;
3579 }
3580 if (item->command == TODO_EDIT) {
3581 struct commit *commit = item->commit;
3582 if (!res)
3583 fprintf(stderr,
3584 _("Stopped at %s... %.*s\n"),
3585 short_commit_name(commit),
3586 item->arg_len, item->arg);
3587 return error_with_patch(r, commit,
3588 item->arg, item->arg_len, opts, res,
3589 !res);
3590 }
3591 if (is_rebase_i(opts) && !res)
3592 record_in_rewritten(&item->commit->object.oid,
3593 peek_command(todo_list, 1));
3594 if (res && is_fixup(item->command)) {
3595 if (res == 1)
3596 intend_to_amend();
3597 return error_failed_squash(r, item->commit, opts,
3598 item->arg_len, item->arg);
3599 } else if (res && is_rebase_i(opts) && item->commit) {
3600 int to_amend = 0;
3601 struct object_id oid;
3602
3603 /*
3604 * If we are rewording and have either
3605 * fast-forwarded already, or are about to
3606 * create a new root commit, we want to amend,
3607 * otherwise we do not.
3608 */
3609 if (item->command == TODO_REWORD &&
3610 !get_oid("HEAD", &oid) &&
3611 (oideq(&item->commit->object.oid, &oid) ||
3612 (opts->have_squash_onto &&
3613 oideq(&opts->squash_onto, &oid))))
3614 to_amend = 1;
3615
3616 return res | error_with_patch(r, item->commit,
3617 item->arg, item->arg_len, opts,
3618 res, to_amend);
3619 }
3620 } else if (item->command == TODO_EXEC) {
3621 char *end_of_arg = (char *)(item->arg + item->arg_len);
3622 int saved = *end_of_arg;
3623 struct stat st;
3624
3625 *end_of_arg = '\0';
3626 res = do_exec(r, item->arg);
3627 *end_of_arg = saved;
3628
3629 /* Reread the todo file if it has changed. */
3630 if (res)
3631 ; /* fall through */
3632 else if (stat(get_todo_path(opts), &st))
3633 res = error_errno(_("could not stat '%s'"),
3634 get_todo_path(opts));
3635 else if (match_stat_data(&todo_list->stat, &st)) {
3636 todo_list_release(todo_list);
3637 if (read_populate_todo(r, todo_list, opts))
3638 res = -1; /* message was printed */
3639 /* `current` will be incremented below */
3640 todo_list->current = -1;
3641 }
3642 } else if (item->command == TODO_LABEL) {
3643 if ((res = do_label(r, item->arg, item->arg_len)))
3644 reschedule = 1;
3645 } else if (item->command == TODO_RESET) {
3646 if ((res = do_reset(r, item->arg, item->arg_len, opts)))
3647 reschedule = 1;
3648 } else if (item->command == TODO_MERGE) {
3649 if ((res = do_merge(r, item->commit,
3650 item->arg, item->arg_len,
3651 item->flags, opts)) < 0)
3652 reschedule = 1;
3653 else if (item->commit)
3654 record_in_rewritten(&item->commit->object.oid,
3655 peek_command(todo_list, 1));
3656 if (res > 0)
3657 /* failed with merge conflicts */
3658 return error_with_patch(r, item->commit,
3659 item->arg,
3660 item->arg_len, opts,
3661 res, 0);
3662 } else if (!is_noop(item->command))
3663 return error(_("unknown command %d"), item->command);
3664
3665 if (reschedule) {
3666 advise(_(rescheduled_advice),
3667 get_item_line_length(todo_list,
3668 todo_list->current),
3669 get_item_line(todo_list, todo_list->current));
3670 todo_list->current--;
3671 if (save_todo(todo_list, opts))
3672 return -1;
3673 if (item->commit)
3674 return error_with_patch(r,
3675 item->commit,
3676 item->arg,
3677 item->arg_len, opts,
3678 res, 0);
3679 }
3680
3681 todo_list->current++;
3682 if (res)
3683 return res;
3684 }
3685
3686 if (is_rebase_i(opts)) {
3687 struct strbuf head_ref = STRBUF_INIT, buf = STRBUF_INIT;
3688 struct stat st;
3689
3690 /* Stopped in the middle, as planned? */
3691 if (todo_list->current < todo_list->nr)
3692 return 0;
3693
3694 if (read_oneliner(&head_ref, rebase_path_head_name(), 0) &&
3695 starts_with(head_ref.buf, "refs/")) {
3696 const char *msg;
3697 struct object_id head, orig;
3698 int res;
3699
3700 if (get_oid("HEAD", &head)) {
3701 res = error(_("cannot read HEAD"));
3702cleanup_head_ref:
3703 strbuf_release(&head_ref);
3704 strbuf_release(&buf);
3705 return res;
3706 }
3707 if (!read_oneliner(&buf, rebase_path_orig_head(), 0) ||
3708 get_oid_hex(buf.buf, &orig)) {
3709 res = error(_("could not read orig-head"));
3710 goto cleanup_head_ref;
3711 }
3712 strbuf_reset(&buf);
3713 if (!read_oneliner(&buf, rebase_path_onto(), 0)) {
3714 res = error(_("could not read 'onto'"));
3715 goto cleanup_head_ref;
3716 }
3717 msg = reflog_message(opts, "finish", "%s onto %s",
3718 head_ref.buf, buf.buf);
3719 if (update_ref(msg, head_ref.buf, &head, &orig,
3720 REF_NO_DEREF, UPDATE_REFS_MSG_ON_ERR)) {
3721 res = error(_("could not update %s"),
3722 head_ref.buf);
3723 goto cleanup_head_ref;
3724 }
3725 msg = reflog_message(opts, "finish", "returning to %s",
3726 head_ref.buf);
3727 if (create_symref("HEAD", head_ref.buf, msg)) {
3728 res = error(_("could not update HEAD to %s"),
3729 head_ref.buf);
3730 goto cleanup_head_ref;
3731 }
3732 strbuf_reset(&buf);
3733 }
3734
3735 if (opts->verbose) {
3736 struct rev_info log_tree_opt;
3737 struct object_id orig, head;
3738
3739 memset(&log_tree_opt, 0, sizeof(log_tree_opt));
3740 repo_init_revisions(r, &log_tree_opt, NULL);
3741 log_tree_opt.diff = 1;
3742 log_tree_opt.diffopt.output_format =
3743 DIFF_FORMAT_DIFFSTAT;
3744 log_tree_opt.disable_stdin = 1;
3745
3746 if (read_oneliner(&buf, rebase_path_orig_head(), 0) &&
3747 !get_oid(buf.buf, &orig) &&
3748 !get_oid("HEAD", &head)) {
3749 diff_tree_oid(&orig, &head, "",
3750 &log_tree_opt.diffopt);
3751 log_tree_diff_flush(&log_tree_opt);
3752 }
3753 }
3754 flush_rewritten_pending();
3755 if (!stat(rebase_path_rewritten_list(), &st) &&
3756 st.st_size > 0) {
3757 struct child_process child = CHILD_PROCESS_INIT;
3758 const char *post_rewrite_hook =
3759 find_hook("post-rewrite");
3760
3761 child.in = open(rebase_path_rewritten_list(), O_RDONLY);
3762 child.git_cmd = 1;
3763 argv_array_push(&child.args, "notes");
3764 argv_array_push(&child.args, "copy");
3765 argv_array_push(&child.args, "--for-rewrite=rebase");
3766 /* we don't care if this copying failed */
3767 run_command(&child);
3768
3769 if (post_rewrite_hook) {
3770 struct child_process hook = CHILD_PROCESS_INIT;
3771
3772 hook.in = open(rebase_path_rewritten_list(),
3773 O_RDONLY);
3774 hook.stdout_to_stderr = 1;
3775 argv_array_push(&hook.args, post_rewrite_hook);
3776 argv_array_push(&hook.args, "rebase");
3777 /* we don't care if this hook failed */
3778 run_command(&hook);
3779 }
3780 }
3781 apply_autostash(opts);
3782
3783 fprintf(stderr, "Successfully rebased and updated %s.\n",
3784 head_ref.buf);
3785
3786 strbuf_release(&buf);
3787 strbuf_release(&head_ref);
3788 }
3789
3790 /*
3791 * Sequence of picks finished successfully; cleanup by
3792 * removing the .git/sequencer directory
3793 */
3794 return sequencer_remove_state(opts);
3795}
3796
3797static int continue_single_pick(struct repository *r)
3798{
3799 const char *argv[] = { "commit", NULL };
3800
3801 if (!file_exists(git_path_cherry_pick_head(r)) &&
3802 !file_exists(git_path_revert_head(r)))
3803 return error(_("no cherry-pick or revert in progress"));
3804 return run_command_v_opt(argv, RUN_GIT_CMD);
3805}
3806
3807static int commit_staged_changes(struct repository *r,
3808 struct replay_opts *opts,
3809 struct todo_list *todo_list)
3810{
3811 unsigned int flags = ALLOW_EMPTY | EDIT_MSG;
3812 unsigned int final_fixup = 0, is_clean;
3813
3814 if (has_unstaged_changes(r, 1))
3815 return error(_("cannot rebase: You have unstaged changes."));
3816
3817 is_clean = !has_uncommitted_changes(r, 0);
3818
3819 if (file_exists(rebase_path_amend())) {
3820 struct strbuf rev = STRBUF_INIT;
3821 struct object_id head, to_amend;
3822
3823 if (get_oid("HEAD", &head))
3824 return error(_("cannot amend non-existing commit"));
3825 if (!read_oneliner(&rev, rebase_path_amend(), 0))
3826 return error(_("invalid file: '%s'"), rebase_path_amend());
3827 if (get_oid_hex(rev.buf, &to_amend))
3828 return error(_("invalid contents: '%s'"),
3829 rebase_path_amend());
3830 if (!is_clean && !oideq(&head, &to_amend))
3831 return error(_("\nYou have uncommitted changes in your "
3832 "working tree. Please, commit them\n"
3833 "first and then run 'git rebase "
3834 "--continue' again."));
3835 /*
3836 * When skipping a failed fixup/squash, we need to edit the
3837 * commit message, the current fixup list and count, and if it
3838 * was the last fixup/squash in the chain, we need to clean up
3839 * the commit message and if there was a squash, let the user
3840 * edit it.
3841 */
3842 if (!is_clean || !opts->current_fixup_count)
3843 ; /* this is not the final fixup */
3844 else if (!oideq(&head, &to_amend) ||
3845 !file_exists(rebase_path_stopped_sha())) {
3846 /* was a final fixup or squash done manually? */
3847 if (!is_fixup(peek_command(todo_list, 0))) {
3848 unlink(rebase_path_fixup_msg());
3849 unlink(rebase_path_squash_msg());
3850 unlink(rebase_path_current_fixups());
3851 strbuf_reset(&opts->current_fixups);
3852 opts->current_fixup_count = 0;
3853 }
3854 } else {
3855 /* we are in a fixup/squash chain */
3856 const char *p = opts->current_fixups.buf;
3857 int len = opts->current_fixups.len;
3858
3859 opts->current_fixup_count--;
3860 if (!len)
3861 BUG("Incorrect current_fixups:\n%s", p);
3862 while (len && p[len - 1] != '\n')
3863 len--;
3864 strbuf_setlen(&opts->current_fixups, len);
3865 if (write_message(p, len, rebase_path_current_fixups(),
3866 0) < 0)
3867 return error(_("could not write file: '%s'"),
3868 rebase_path_current_fixups());
3869
3870 /*
3871 * If a fixup/squash in a fixup/squash chain failed, the
3872 * commit message is already correct, no need to commit
3873 * it again.
3874 *
3875 * Only if it is the final command in the fixup/squash
3876 * chain, and only if the chain is longer than a single
3877 * fixup/squash command (which was just skipped), do we
3878 * actually need to re-commit with a cleaned up commit
3879 * message.
3880 */
3881 if (opts->current_fixup_count > 0 &&
3882 !is_fixup(peek_command(todo_list, 0))) {
3883 final_fixup = 1;
3884 /*
3885 * If there was not a single "squash" in the
3886 * chain, we only need to clean up the commit
3887 * message, no need to bother the user with
3888 * opening the commit message in the editor.
3889 */
3890 if (!starts_with(p, "squash ") &&
3891 !strstr(p, "\nsquash "))
3892 flags = (flags & ~EDIT_MSG) | CLEANUP_MSG;
3893 } else if (is_fixup(peek_command(todo_list, 0))) {
3894 /*
3895 * We need to update the squash message to skip
3896 * the latest commit message.
3897 */
3898 struct commit *commit;
3899 const char *path = rebase_path_squash_msg();
3900
3901 if (parse_head(r, &commit) ||
3902 !(p = get_commit_buffer(commit, NULL)) ||
3903 write_message(p, strlen(p), path, 0)) {
3904 unuse_commit_buffer(commit, p);
3905 return error(_("could not write file: "
3906 "'%s'"), path);
3907 }
3908 unuse_commit_buffer(commit, p);
3909 }
3910 }
3911
3912 strbuf_release(&rev);
3913 flags |= AMEND_MSG;
3914 }
3915
3916 if (is_clean) {
3917 const char *cherry_pick_head = git_path_cherry_pick_head(r);
3918
3919 if (file_exists(cherry_pick_head) && unlink(cherry_pick_head))
3920 return error(_("could not remove CHERRY_PICK_HEAD"));
3921 if (!final_fixup)
3922 return 0;
3923 }
3924
3925 if (run_git_commit(r, final_fixup ? NULL : rebase_path_message(),
3926 opts, flags))
3927 return error(_("could not commit staged changes."));
3928 unlink(rebase_path_amend());
3929 unlink(git_path_merge_head(the_repository));
3930 if (final_fixup) {
3931 unlink(rebase_path_fixup_msg());
3932 unlink(rebase_path_squash_msg());
3933 }
3934 if (opts->current_fixup_count > 0) {
3935 /*
3936 * Whether final fixup or not, we just cleaned up the commit
3937 * message...
3938 */
3939 unlink(rebase_path_current_fixups());
3940 strbuf_reset(&opts->current_fixups);
3941 opts->current_fixup_count = 0;
3942 }
3943 return 0;
3944}
3945
3946int sequencer_continue(struct repository *r, struct replay_opts *opts)
3947{
3948 struct todo_list todo_list = TODO_LIST_INIT;
3949 int res;
3950
3951 if (read_and_refresh_cache(r, opts))
3952 return -1;
3953
3954 if (read_populate_opts(opts))
3955 return -1;
3956 if (is_rebase_i(opts)) {
3957 if ((res = read_populate_todo(r, &todo_list, opts)))
3958 goto release_todo_list;
3959 if (commit_staged_changes(r, opts, &todo_list))
3960 return -1;
3961 } else if (!file_exists(get_todo_path(opts)))
3962 return continue_single_pick(r);
3963 else if ((res = read_populate_todo(r, &todo_list, opts)))
3964 goto release_todo_list;
3965
3966 if (!is_rebase_i(opts)) {
3967 /* Verify that the conflict has been resolved */
3968 if (file_exists(git_path_cherry_pick_head(r)) ||
3969 file_exists(git_path_revert_head(r))) {
3970 res = continue_single_pick(r);
3971 if (res)
3972 goto release_todo_list;
3973 }
3974 if (index_differs_from(r, "HEAD", NULL, 0)) {
3975 res = error_dirty_index(r->index, opts);
3976 goto release_todo_list;
3977 }
3978 todo_list.current++;
3979 } else if (file_exists(rebase_path_stopped_sha())) {
3980 struct strbuf buf = STRBUF_INIT;
3981 struct object_id oid;
3982
3983 if (read_oneliner(&buf, rebase_path_stopped_sha(), 1) &&
3984 !get_oid_committish(buf.buf, &oid))
3985 record_in_rewritten(&oid, peek_command(&todo_list, 0));
3986 strbuf_release(&buf);
3987 }
3988
3989 res = pick_commits(r, &todo_list, opts);
3990release_todo_list:
3991 todo_list_release(&todo_list);
3992 return res;
3993}
3994
3995static int single_pick(struct repository *r,
3996 struct commit *cmit,
3997 struct replay_opts *opts)
3998{
3999 setenv(GIT_REFLOG_ACTION, action_name(opts), 0);
4000 return do_pick_commit(r, opts->action == REPLAY_PICK ?
4001 TODO_PICK : TODO_REVERT, cmit, opts, 0);
4002}
4003
4004int sequencer_pick_revisions(struct repository *r,
4005 struct replay_opts *opts)
4006{
4007 struct todo_list todo_list = TODO_LIST_INIT;
4008 struct object_id oid;
4009 int i, res;
4010
4011 assert(opts->revs);
4012 if (read_and_refresh_cache(r, opts))
4013 return -1;
4014
4015 for (i = 0; i < opts->revs->pending.nr; i++) {
4016 struct object_id oid;
4017 const char *name = opts->revs->pending.objects[i].name;
4018
4019 /* This happens when using --stdin. */
4020 if (!strlen(name))
4021 continue;
4022
4023 if (!get_oid(name, &oid)) {
4024 if (!lookup_commit_reference_gently(r, &oid, 1)) {
4025 enum object_type type = oid_object_info(r,
4026 &oid,
4027 NULL);
4028 return error(_("%s: can't cherry-pick a %s"),
4029 name, type_name(type));
4030 }
4031 } else
4032 return error(_("%s: bad revision"), name);
4033 }
4034
4035 /*
4036 * If we were called as "git cherry-pick <commit>", just
4037 * cherry-pick/revert it, set CHERRY_PICK_HEAD /
4038 * REVERT_HEAD, and don't touch the sequencer state.
4039 * This means it is possible to cherry-pick in the middle
4040 * of a cherry-pick sequence.
4041 */
4042 if (opts->revs->cmdline.nr == 1 &&
4043 opts->revs->cmdline.rev->whence == REV_CMD_REV &&
4044 opts->revs->no_walk &&
4045 !opts->revs->cmdline.rev->flags) {
4046 struct commit *cmit;
4047 if (prepare_revision_walk(opts->revs))
4048 return error(_("revision walk setup failed"));
4049 cmit = get_revision(opts->revs);
4050 if (!cmit)
4051 return error(_("empty commit set passed"));
4052 if (get_revision(opts->revs))
4053 BUG("unexpected extra commit from walk");
4054 return single_pick(r, cmit, opts);
4055 }
4056
4057 /*
4058 * Start a new cherry-pick/ revert sequence; but
4059 * first, make sure that an existing one isn't in
4060 * progress
4061 */
4062
4063 if (walk_revs_populate_todo(&todo_list, opts) ||
4064 create_seq_dir() < 0)
4065 return -1;
4066 if (get_oid("HEAD", &oid) && (opts->action == REPLAY_REVERT))
4067 return error(_("can't revert as initial commit"));
4068 if (save_head(oid_to_hex(&oid)))
4069 return -1;
4070 if (save_opts(opts))
4071 return -1;
4072 update_abort_safety_file();
4073 res = pick_commits(r, &todo_list, opts);
4074 todo_list_release(&todo_list);
4075 return res;
4076}
4077
4078void append_signoff(struct strbuf *msgbuf, size_t ignore_footer, unsigned flag)
4079{
4080 unsigned no_dup_sob = flag & APPEND_SIGNOFF_DEDUP;
4081 struct strbuf sob = STRBUF_INIT;
4082 int has_footer;
4083
4084 strbuf_addstr(&sob, sign_off_header);
4085 strbuf_addstr(&sob, fmt_name(getenv("GIT_COMMITTER_NAME"),
4086 getenv("GIT_COMMITTER_EMAIL")));
4087 strbuf_addch(&sob, '\n');
4088
4089 if (!ignore_footer)
4090 strbuf_complete_line(msgbuf);
4091
4092 /*
4093 * If the whole message buffer is equal to the sob, pretend that we
4094 * found a conforming footer with a matching sob
4095 */
4096 if (msgbuf->len - ignore_footer == sob.len &&
4097 !strncmp(msgbuf->buf, sob.buf, sob.len))
4098 has_footer = 3;
4099 else
4100 has_footer = has_conforming_footer(msgbuf, &sob, ignore_footer);
4101
4102 if (!has_footer) {
4103 const char *append_newlines = NULL;
4104 size_t len = msgbuf->len - ignore_footer;
4105
4106 if (!len) {
4107 /*
4108 * The buffer is completely empty. Leave foom for
4109 * the title and body to be filled in by the user.
4110 */
4111 append_newlines = "\n\n";
4112 } else if (len == 1) {
4113 /*
4114 * Buffer contains a single newline. Add another
4115 * so that we leave room for the title and body.
4116 */
4117 append_newlines = "\n";
4118 } else if (msgbuf->buf[len - 2] != '\n') {
4119 /*
4120 * Buffer ends with a single newline. Add another
4121 * so that there is an empty line between the message
4122 * body and the sob.
4123 */
4124 append_newlines = "\n";
4125 } /* else, the buffer already ends with two newlines. */
4126
4127 if (append_newlines)
4128 strbuf_splice(msgbuf, msgbuf->len - ignore_footer, 0,
4129 append_newlines, strlen(append_newlines));
4130 }
4131
4132 if (has_footer != 3 && (!no_dup_sob || has_footer != 2))
4133 strbuf_splice(msgbuf, msgbuf->len - ignore_footer, 0,
4134 sob.buf, sob.len);
4135
4136 strbuf_release(&sob);
4137}
4138
4139struct labels_entry {
4140 struct hashmap_entry entry;
4141 char label[FLEX_ARRAY];
4142};
4143
4144static int labels_cmp(const void *fndata, const struct labels_entry *a,
4145 const struct labels_entry *b, const void *key)
4146{
4147 return key ? strcmp(a->label, key) : strcmp(a->label, b->label);
4148}
4149
4150struct string_entry {
4151 struct oidmap_entry entry;
4152 char string[FLEX_ARRAY];
4153};
4154
4155struct label_state {
4156 struct oidmap commit2label;
4157 struct hashmap labels;
4158 struct strbuf buf;
4159};
4160
4161static const char *label_oid(struct object_id *oid, const char *label,
4162 struct label_state *state)
4163{
4164 struct labels_entry *labels_entry;
4165 struct string_entry *string_entry;
4166 struct object_id dummy;
4167 size_t len;
4168 int i;
4169
4170 string_entry = oidmap_get(&state->commit2label, oid);
4171 if (string_entry)
4172 return string_entry->string;
4173
4174 /*
4175 * For "uninteresting" commits, i.e. commits that are not to be
4176 * rebased, and which can therefore not be labeled, we use a unique
4177 * abbreviation of the commit name. This is slightly more complicated
4178 * than calling find_unique_abbrev() because we also need to make
4179 * sure that the abbreviation does not conflict with any other
4180 * label.
4181 *
4182 * We disallow "interesting" commits to be labeled by a string that
4183 * is a valid full-length hash, to ensure that we always can find an
4184 * abbreviation for any uninteresting commit's names that does not
4185 * clash with any other label.
4186 */
4187 if (!label) {
4188 char *p;
4189
4190 strbuf_reset(&state->buf);
4191 strbuf_grow(&state->buf, GIT_SHA1_HEXSZ);
4192 label = p = state->buf.buf;
4193
4194 find_unique_abbrev_r(p, oid, default_abbrev);
4195
4196 /*
4197 * We may need to extend the abbreviated hash so that there is
4198 * no conflicting label.
4199 */
4200 if (hashmap_get_from_hash(&state->labels, strihash(p), p)) {
4201 size_t i = strlen(p) + 1;
4202
4203 oid_to_hex_r(p, oid);
4204 for (; i < GIT_SHA1_HEXSZ; i++) {
4205 char save = p[i];
4206 p[i] = '\0';
4207 if (!hashmap_get_from_hash(&state->labels,
4208 strihash(p), p))
4209 break;
4210 p[i] = save;
4211 }
4212 }
4213 } else if (((len = strlen(label)) == the_hash_algo->hexsz &&
4214 !get_oid_hex(label, &dummy)) ||
4215 (len == 1 && *label == '#') ||
4216 hashmap_get_from_hash(&state->labels,
4217 strihash(label), label)) {
4218 /*
4219 * If the label already exists, or if the label is a valid full
4220 * OID, or the label is a '#' (which we use as a separator
4221 * between merge heads and oneline), we append a dash and a
4222 * number to make it unique.
4223 */
4224 struct strbuf *buf = &state->buf;
4225
4226 strbuf_reset(buf);
4227 strbuf_add(buf, label, len);
4228
4229 for (i = 2; ; i++) {
4230 strbuf_setlen(buf, len);
4231 strbuf_addf(buf, "-%d", i);
4232 if (!hashmap_get_from_hash(&state->labels,
4233 strihash(buf->buf),
4234 buf->buf))
4235 break;
4236 }
4237
4238 label = buf->buf;
4239 }
4240
4241 FLEX_ALLOC_STR(labels_entry, label, label);
4242 hashmap_entry_init(labels_entry, strihash(label));
4243 hashmap_add(&state->labels, labels_entry);
4244
4245 FLEX_ALLOC_STR(string_entry, string, label);
4246 oidcpy(&string_entry->entry.oid, oid);
4247 oidmap_put(&state->commit2label, string_entry);
4248
4249 return string_entry->string;
4250}
4251
4252static int make_script_with_merges(struct pretty_print_context *pp,
4253 struct rev_info *revs, FILE *out,
4254 unsigned flags)
4255{
4256 int keep_empty = flags & TODO_LIST_KEEP_EMPTY;
4257 int rebase_cousins = flags & TODO_LIST_REBASE_COUSINS;
4258 struct strbuf buf = STRBUF_INIT, oneline = STRBUF_INIT;
4259 struct strbuf label = STRBUF_INIT;
4260 struct commit_list *commits = NULL, **tail = &commits, *iter;
4261 struct commit_list *tips = NULL, **tips_tail = &tips;
4262 struct commit *commit;
4263 struct oidmap commit2todo = OIDMAP_INIT;
4264 struct string_entry *entry;
4265 struct oidset interesting = OIDSET_INIT, child_seen = OIDSET_INIT,
4266 shown = OIDSET_INIT;
4267 struct label_state state = { OIDMAP_INIT, { NULL }, STRBUF_INIT };
4268
4269 int abbr = flags & TODO_LIST_ABBREVIATE_CMDS;
4270 const char *cmd_pick = abbr ? "p" : "pick",
4271 *cmd_label = abbr ? "l" : "label",
4272 *cmd_reset = abbr ? "t" : "reset",
4273 *cmd_merge = abbr ? "m" : "merge";
4274
4275 oidmap_init(&commit2todo, 0);
4276 oidmap_init(&state.commit2label, 0);
4277 hashmap_init(&state.labels, (hashmap_cmp_fn) labels_cmp, NULL, 0);
4278 strbuf_init(&state.buf, 32);
4279
4280 if (revs->cmdline.nr && (revs->cmdline.rev[0].flags & BOTTOM)) {
4281 struct object_id *oid = &revs->cmdline.rev[0].item->oid;
4282 FLEX_ALLOC_STR(entry, string, "onto");
4283 oidcpy(&entry->entry.oid, oid);
4284 oidmap_put(&state.commit2label, entry);
4285 }
4286
4287 /*
4288 * First phase:
4289 * - get onelines for all commits
4290 * - gather all branch tips (i.e. 2nd or later parents of merges)
4291 * - label all branch tips
4292 */
4293 while ((commit = get_revision(revs))) {
4294 struct commit_list *to_merge;
4295 const char *p1, *p2;
4296 struct object_id *oid;
4297 int is_empty;
4298
4299 tail = &commit_list_insert(commit, tail)->next;
4300 oidset_insert(&interesting, &commit->object.oid);
4301
4302 is_empty = is_original_commit_empty(commit);
4303 if (!is_empty && (commit->object.flags & PATCHSAME))
4304 continue;
4305
4306 strbuf_reset(&oneline);
4307 pretty_print_commit(pp, commit, &oneline);
4308
4309 to_merge = commit->parents ? commit->parents->next : NULL;
4310 if (!to_merge) {
4311 /* non-merge commit: easy case */
4312 strbuf_reset(&buf);
4313 if (!keep_empty && is_empty)
4314 strbuf_addf(&buf, "%c ", comment_line_char);
4315 strbuf_addf(&buf, "%s %s %s", cmd_pick,
4316 oid_to_hex(&commit->object.oid),
4317 oneline.buf);
4318
4319 FLEX_ALLOC_STR(entry, string, buf.buf);
4320 oidcpy(&entry->entry.oid, &commit->object.oid);
4321 oidmap_put(&commit2todo, entry);
4322
4323 continue;
4324 }
4325
4326 /* Create a label */
4327 strbuf_reset(&label);
4328 if (skip_prefix(oneline.buf, "Merge ", &p1) &&
4329 (p1 = strchr(p1, '\'')) &&
4330 (p2 = strchr(++p1, '\'')))
4331 strbuf_add(&label, p1, p2 - p1);
4332 else if (skip_prefix(oneline.buf, "Merge pull request ",
4333 &p1) &&
4334 (p1 = strstr(p1, " from ")))
4335 strbuf_addstr(&label, p1 + strlen(" from "));
4336 else
4337 strbuf_addbuf(&label, &oneline);
4338
4339 for (p1 = label.buf; *p1; p1++)
4340 if (isspace(*p1))
4341 *(char *)p1 = '-';
4342
4343 strbuf_reset(&buf);
4344 strbuf_addf(&buf, "%s -C %s",
4345 cmd_merge, oid_to_hex(&commit->object.oid));
4346
4347 /* label the tips of merged branches */
4348 for (; to_merge; to_merge = to_merge->next) {
4349 oid = &to_merge->item->object.oid;
4350 strbuf_addch(&buf, ' ');
4351
4352 if (!oidset_contains(&interesting, oid)) {
4353 strbuf_addstr(&buf, label_oid(oid, NULL,
4354 &state));
4355 continue;
4356 }
4357
4358 tips_tail = &commit_list_insert(to_merge->item,
4359 tips_tail)->next;
4360
4361 strbuf_addstr(&buf, label_oid(oid, label.buf, &state));
4362 }
4363 strbuf_addf(&buf, " # %s", oneline.buf);
4364
4365 FLEX_ALLOC_STR(entry, string, buf.buf);
4366 oidcpy(&entry->entry.oid, &commit->object.oid);
4367 oidmap_put(&commit2todo, entry);
4368 }
4369
4370 /*
4371 * Second phase:
4372 * - label branch points
4373 * - add HEAD to the branch tips
4374 */
4375 for (iter = commits; iter; iter = iter->next) {
4376 struct commit_list *parent = iter->item->parents;
4377 for (; parent; parent = parent->next) {
4378 struct object_id *oid = &parent->item->object.oid;
4379 if (!oidset_contains(&interesting, oid))
4380 continue;
4381 if (oidset_insert(&child_seen, oid))
4382 label_oid(oid, "branch-point", &state);
4383 }
4384
4385 /* Add HEAD as implict "tip of branch" */
4386 if (!iter->next)
4387 tips_tail = &commit_list_insert(iter->item,
4388 tips_tail)->next;
4389 }
4390
4391 /*
4392 * Third phase: output the todo list. This is a bit tricky, as we
4393 * want to avoid jumping back and forth between revisions. To
4394 * accomplish that goal, we walk backwards from the branch tips,
4395 * gathering commits not yet shown, reversing the list on the fly,
4396 * then outputting that list (labeling revisions as needed).
4397 */
4398 fprintf(out, "%s onto\n", cmd_label);
4399 for (iter = tips; iter; iter = iter->next) {
4400 struct commit_list *list = NULL, *iter2;
4401
4402 commit = iter->item;
4403 if (oidset_contains(&shown, &commit->object.oid))
4404 continue;
4405 entry = oidmap_get(&state.commit2label, &commit->object.oid);
4406
4407 if (entry)
4408 fprintf(out, "\n%c Branch %s\n", comment_line_char, entry->string);
4409 else
4410 fprintf(out, "\n");
4411
4412 while (oidset_contains(&interesting, &commit->object.oid) &&
4413 !oidset_contains(&shown, &commit->object.oid)) {
4414 commit_list_insert(commit, &list);
4415 if (!commit->parents) {
4416 commit = NULL;
4417 break;
4418 }
4419 commit = commit->parents->item;
4420 }
4421
4422 if (!commit)
4423 fprintf(out, "%s %s\n", cmd_reset,
4424 rebase_cousins ? "onto" : "[new root]");
4425 else {
4426 const char *to = NULL;
4427
4428 entry = oidmap_get(&state.commit2label,
4429 &commit->object.oid);
4430 if (entry)
4431 to = entry->string;
4432 else if (!rebase_cousins)
4433 to = label_oid(&commit->object.oid, NULL,
4434 &state);
4435
4436 if (!to || !strcmp(to, "onto"))
4437 fprintf(out, "%s onto\n", cmd_reset);
4438 else {
4439 strbuf_reset(&oneline);
4440 pretty_print_commit(pp, commit, &oneline);
4441 fprintf(out, "%s %s # %s\n",
4442 cmd_reset, to, oneline.buf);
4443 }
4444 }
4445
4446 for (iter2 = list; iter2; iter2 = iter2->next) {
4447 struct object_id *oid = &iter2->item->object.oid;
4448 entry = oidmap_get(&commit2todo, oid);
4449 /* only show if not already upstream */
4450 if (entry)
4451 fprintf(out, "%s\n", entry->string);
4452 entry = oidmap_get(&state.commit2label, oid);
4453 if (entry)
4454 fprintf(out, "%s %s\n",
4455 cmd_label, entry->string);
4456 oidset_insert(&shown, oid);
4457 }
4458
4459 free_commit_list(list);
4460 }
4461
4462 free_commit_list(commits);
4463 free_commit_list(tips);
4464
4465 strbuf_release(&label);
4466 strbuf_release(&oneline);
4467 strbuf_release(&buf);
4468
4469 oidmap_free(&commit2todo, 1);
4470 oidmap_free(&state.commit2label, 1);
4471 hashmap_free(&state.labels, 1);
4472 strbuf_release(&state.buf);
4473
4474 return 0;
4475}
4476
4477int sequencer_make_script(struct repository *r, FILE *out,
4478 int argc, const char **argv,
4479 unsigned flags)
4480{
4481 char *format = NULL;
4482 struct pretty_print_context pp = {0};
4483 struct strbuf buf = STRBUF_INIT;
4484 struct rev_info revs;
4485 struct commit *commit;
4486 int keep_empty = flags & TODO_LIST_KEEP_EMPTY;
4487 const char *insn = flags & TODO_LIST_ABBREVIATE_CMDS ? "p" : "pick";
4488 int rebase_merges = flags & TODO_LIST_REBASE_MERGES;
4489
4490 repo_init_revisions(r, &revs, NULL);
4491 revs.verbose_header = 1;
4492 if (!rebase_merges)
4493 revs.max_parents = 1;
4494 revs.cherry_mark = 1;
4495 revs.limited = 1;
4496 revs.reverse = 1;
4497 revs.right_only = 1;
4498 revs.sort_order = REV_SORT_IN_GRAPH_ORDER;
4499 revs.topo_order = 1;
4500
4501 revs.pretty_given = 1;
4502 git_config_get_string("rebase.instructionFormat", &format);
4503 if (!format || !*format) {
4504 free(format);
4505 format = xstrdup("%s");
4506 }
4507 get_commit_format(format, &revs);
4508 free(format);
4509 pp.fmt = revs.commit_format;
4510 pp.output_encoding = get_log_output_encoding();
4511
4512 if (setup_revisions(argc, argv, &revs, NULL) > 1)
4513 return error(_("make_script: unhandled options"));
4514
4515 if (prepare_revision_walk(&revs) < 0)
4516 return error(_("make_script: error preparing revisions"));
4517
4518 if (rebase_merges)
4519 return make_script_with_merges(&pp, &revs, out, flags);
4520
4521 while ((commit = get_revision(&revs))) {
4522 int is_empty = is_original_commit_empty(commit);
4523
4524 if (!is_empty && (commit->object.flags & PATCHSAME))
4525 continue;
4526 strbuf_reset(&buf);
4527 if (!keep_empty && is_empty)
4528 strbuf_addf(&buf, "%c ", comment_line_char);
4529 strbuf_addf(&buf, "%s %s ", insn,
4530 oid_to_hex(&commit->object.oid));
4531 pretty_print_commit(&pp, commit, &buf);
4532 strbuf_addch(&buf, '\n');
4533 fputs(buf.buf, out);
4534 }
4535 strbuf_release(&buf);
4536 return 0;
4537}
4538
4539/*
4540 * Add commands after pick and (series of) squash/fixup commands
4541 * in the todo list.
4542 */
4543int sequencer_add_exec_commands(struct repository *r,
4544 const char *commands)
4545{
4546 const char *todo_file = rebase_path_todo();
4547 struct todo_list todo_list = TODO_LIST_INIT;
4548 struct strbuf *buf = &todo_list.buf;
4549 size_t offset = 0, commands_len = strlen(commands);
4550 int i, insert;
4551
4552 if (strbuf_read_file(&todo_list.buf, todo_file, 0) < 0)
4553 return error(_("could not read '%s'."), todo_file);
4554
4555 if (parse_insn_buffer(r, todo_list.buf.buf, &todo_list)) {
4556 todo_list_release(&todo_list);
4557 return error(_("unusable todo list: '%s'"), todo_file);
4558 }
4559
4560 /*
4561 * Insert <commands> after every pick. Here, fixup/squash chains
4562 * are considered part of the pick, so we insert the commands *after*
4563 * those chains if there are any.
4564 */
4565 insert = -1;
4566 for (i = 0; i < todo_list.nr; i++) {
4567 enum todo_command command = todo_list.items[i].command;
4568
4569 if (insert >= 0) {
4570 /* skip fixup/squash chains */
4571 if (command == TODO_COMMENT)
4572 continue;
4573 else if (is_fixup(command)) {
4574 insert = i + 1;
4575 continue;
4576 }
4577 strbuf_insert(buf,
4578 todo_list.items[insert].offset_in_buf +
4579 offset, commands, commands_len);
4580 offset += commands_len;
4581 insert = -1;
4582 }
4583
4584 if (command == TODO_PICK || command == TODO_MERGE)
4585 insert = i + 1;
4586 }
4587
4588 /* insert or append final <commands> */
4589 if (insert >= 0 && insert < todo_list.nr)
4590 strbuf_insert(buf, todo_list.items[insert].offset_in_buf +
4591 offset, commands, commands_len);
4592 else if (insert >= 0 || !offset)
4593 strbuf_add(buf, commands, commands_len);
4594
4595 i = write_message(buf->buf, buf->len, todo_file, 0);
4596 todo_list_release(&todo_list);
4597 return i;
4598}
4599
4600int transform_todos(struct repository *r, unsigned flags)
4601{
4602 const char *todo_file = rebase_path_todo();
4603 struct todo_list todo_list = TODO_LIST_INIT;
4604 struct strbuf buf = STRBUF_INIT;
4605 struct todo_item *item;
4606 int i;
4607
4608 if (strbuf_read_file(&todo_list.buf, todo_file, 0) < 0)
4609 return error(_("could not read '%s'."), todo_file);
4610
4611 if (parse_insn_buffer(r, todo_list.buf.buf, &todo_list)) {
4612 todo_list_release(&todo_list);
4613 return error(_("unusable todo list: '%s'"), todo_file);
4614 }
4615
4616 for (item = todo_list.items, i = 0; i < todo_list.nr; i++, item++) {
4617 /* if the item is not a command write it and continue */
4618 if (item->command >= TODO_COMMENT) {
4619 strbuf_addf(&buf, "%.*s\n", item->arg_len, item->arg);
4620 continue;
4621 }
4622
4623 /* add command to the buffer */
4624 if (flags & TODO_LIST_ABBREVIATE_CMDS)
4625 strbuf_addch(&buf, command_to_char(item->command));
4626 else
4627 strbuf_addstr(&buf, command_to_string(item->command));
4628
4629 /* add commit id */
4630 if (item->commit) {
4631 const char *oid = flags & TODO_LIST_SHORTEN_IDS ?
4632 short_commit_name(item->commit) :
4633 oid_to_hex(&item->commit->object.oid);
4634
4635 if (item->command == TODO_MERGE) {
4636 if (item->flags & TODO_EDIT_MERGE_MSG)
4637 strbuf_addstr(&buf, " -c");
4638 else
4639 strbuf_addstr(&buf, " -C");
4640 }
4641
4642 strbuf_addf(&buf, " %s", oid);
4643 }
4644
4645 /* add all the rest */
4646 if (!item->arg_len)
4647 strbuf_addch(&buf, '\n');
4648 else
4649 strbuf_addf(&buf, " %.*s\n", item->arg_len, item->arg);
4650 }
4651
4652 i = write_message(buf.buf, buf.len, todo_file, 0);
4653 todo_list_release(&todo_list);
4654 return i;
4655}
4656
4657enum missing_commit_check_level get_missing_commit_check_level(void)
4658{
4659 const char *value;
4660
4661 if (git_config_get_value("rebase.missingcommitscheck", &value) ||
4662 !strcasecmp("ignore", value))
4663 return MISSING_COMMIT_CHECK_IGNORE;
4664 if (!strcasecmp("warn", value))
4665 return MISSING_COMMIT_CHECK_WARN;
4666 if (!strcasecmp("error", value))
4667 return MISSING_COMMIT_CHECK_ERROR;
4668 warning(_("unrecognized setting %s for option "
4669 "rebase.missingCommitsCheck. Ignoring."), value);
4670 return MISSING_COMMIT_CHECK_IGNORE;
4671}
4672
4673define_commit_slab(commit_seen, unsigned char);
4674/*
4675 * Check if the user dropped some commits by mistake
4676 * Behaviour determined by rebase.missingCommitsCheck.
4677 * Check if there is an unrecognized command or a
4678 * bad SHA-1 in a command.
4679 */
4680int check_todo_list(struct repository *r)
4681{
4682 enum missing_commit_check_level check_level = get_missing_commit_check_level();
4683 struct strbuf todo_file = STRBUF_INIT;
4684 struct todo_list todo_list = TODO_LIST_INIT;
4685 struct strbuf missing = STRBUF_INIT;
4686 int advise_to_edit_todo = 0, res = 0, i;
4687 struct commit_seen commit_seen;
4688
4689 init_commit_seen(&commit_seen);
4690
4691 strbuf_addstr(&todo_file, rebase_path_todo());
4692 if (strbuf_read_file_or_whine(&todo_list.buf, todo_file.buf) < 0) {
4693 res = -1;
4694 goto leave_check;
4695 }
4696 advise_to_edit_todo = res =
4697 parse_insn_buffer(r, todo_list.buf.buf, &todo_list);
4698
4699 if (res || check_level == MISSING_COMMIT_CHECK_IGNORE)
4700 goto leave_check;
4701
4702 /* Mark the commits in git-rebase-todo as seen */
4703 for (i = 0; i < todo_list.nr; i++) {
4704 struct commit *commit = todo_list.items[i].commit;
4705 if (commit)
4706 *commit_seen_at(&commit_seen, commit) = 1;
4707 }
4708
4709 todo_list_release(&todo_list);
4710 strbuf_addstr(&todo_file, ".backup");
4711 if (strbuf_read_file_or_whine(&todo_list.buf, todo_file.buf) < 0) {
4712 res = -1;
4713 goto leave_check;
4714 }
4715 strbuf_release(&todo_file);
4716 res = !!parse_insn_buffer(r, todo_list.buf.buf, &todo_list);
4717
4718 /* Find commits in git-rebase-todo.backup yet unseen */
4719 for (i = todo_list.nr - 1; i >= 0; i--) {
4720 struct todo_item *item = todo_list.items + i;
4721 struct commit *commit = item->commit;
4722 if (commit && !*commit_seen_at(&commit_seen, commit)) {
4723 strbuf_addf(&missing, " - %s %.*s\n",
4724 short_commit_name(commit),
4725 item->arg_len, item->arg);
4726 *commit_seen_at(&commit_seen, commit) = 1;
4727 }
4728 }
4729
4730 /* Warn about missing commits */
4731 if (!missing.len)
4732 goto leave_check;
4733
4734 if (check_level == MISSING_COMMIT_CHECK_ERROR)
4735 advise_to_edit_todo = res = 1;
4736
4737 fprintf(stderr,
4738 _("Warning: some commits may have been dropped accidentally.\n"
4739 "Dropped commits (newer to older):\n"));
4740
4741 /* Make the list user-friendly and display */
4742 fputs(missing.buf, stderr);
4743 strbuf_release(&missing);
4744
4745 fprintf(stderr, _("To avoid this message, use \"drop\" to "
4746 "explicitly remove a commit.\n\n"
4747 "Use 'git config rebase.missingCommitsCheck' to change "
4748 "the level of warnings.\n"
4749 "The possible behaviours are: ignore, warn, error.\n\n"));
4750
4751leave_check:
4752 clear_commit_seen(&commit_seen);
4753 strbuf_release(&todo_file);
4754 todo_list_release(&todo_list);
4755
4756 if (advise_to_edit_todo)
4757 fprintf(stderr,
4758 _("You can fix this with 'git rebase --edit-todo' "
4759 "and then run 'git rebase --continue'.\n"
4760 "Or you can abort the rebase with 'git rebase"
4761 " --abort'.\n"));
4762
4763 return res;
4764}
4765
4766static int rewrite_file(const char *path, const char *buf, size_t len)
4767{
4768 int rc = 0;
4769 int fd = open(path, O_WRONLY | O_TRUNC);
4770 if (fd < 0)
4771 return error_errno(_("could not open '%s' for writing"), path);
4772 if (write_in_full(fd, buf, len) < 0)
4773 rc = error_errno(_("could not write to '%s'"), path);
4774 if (close(fd) && !rc)
4775 rc = error_errno(_("could not close '%s'"), path);
4776 return rc;
4777}
4778
4779/* skip picking commits whose parents are unchanged */
4780static int skip_unnecessary_picks(struct repository *r, struct object_id *output_oid)
4781{
4782 const char *todo_file = rebase_path_todo();
4783 struct strbuf buf = STRBUF_INIT;
4784 struct todo_list todo_list = TODO_LIST_INIT;
4785 struct object_id *parent_oid;
4786 int fd, i;
4787
4788 if (!read_oneliner(&buf, rebase_path_onto(), 0))
4789 return error(_("could not read 'onto'"));
4790 if (get_oid(buf.buf, output_oid)) {
4791 strbuf_release(&buf);
4792 return error(_("need a HEAD to fixup"));
4793 }
4794 strbuf_release(&buf);
4795
4796 if (strbuf_read_file_or_whine(&todo_list.buf, todo_file) < 0)
4797 return -1;
4798 if (parse_insn_buffer(r, todo_list.buf.buf, &todo_list) < 0) {
4799 todo_list_release(&todo_list);
4800 return -1;
4801 }
4802
4803 for (i = 0; i < todo_list.nr; i++) {
4804 struct todo_item *item = todo_list.items + i;
4805
4806 if (item->command >= TODO_NOOP)
4807 continue;
4808 if (item->command != TODO_PICK)
4809 break;
4810 if (parse_commit(item->commit)) {
4811 todo_list_release(&todo_list);
4812 return error(_("could not parse commit '%s'"),
4813 oid_to_hex(&item->commit->object.oid));
4814 }
4815 if (!item->commit->parents)
4816 break; /* root commit */
4817 if (item->commit->parents->next)
4818 break; /* merge commit */
4819 parent_oid = &item->commit->parents->item->object.oid;
4820 if (!oideq(parent_oid, output_oid))
4821 break;
4822 oidcpy(output_oid, &item->commit->object.oid);
4823 }
4824 if (i > 0) {
4825 int offset = get_item_line_offset(&todo_list, i);
4826 const char *done_path = rebase_path_done();
4827
4828 fd = open(done_path, O_CREAT | O_WRONLY | O_APPEND, 0666);
4829 if (fd < 0) {
4830 error_errno(_("could not open '%s' for writing"),
4831 done_path);
4832 todo_list_release(&todo_list);
4833 return -1;
4834 }
4835 if (write_in_full(fd, todo_list.buf.buf, offset) < 0) {
4836 error_errno(_("could not write to '%s'"), done_path);
4837 todo_list_release(&todo_list);
4838 close(fd);
4839 return -1;
4840 }
4841 close(fd);
4842
4843 if (rewrite_file(rebase_path_todo(), todo_list.buf.buf + offset,
4844 todo_list.buf.len - offset) < 0) {
4845 todo_list_release(&todo_list);
4846 return -1;
4847 }
4848
4849 todo_list.current = i;
4850 if (is_fixup(peek_command(&todo_list, 0)))
4851 record_in_rewritten(output_oid, peek_command(&todo_list, 0));
4852 }
4853
4854 todo_list_release(&todo_list);
4855
4856 return 0;
4857}
4858
4859int complete_action(struct repository *r, struct replay_opts *opts, unsigned flags,
4860 const char *shortrevisions, const char *onto_name,
4861 const char *onto, const char *orig_head, const char *cmd,
4862 unsigned autosquash)
4863{
4864 const char *shortonto, *todo_file = rebase_path_todo();
4865 struct todo_list todo_list = TODO_LIST_INIT;
4866 struct strbuf *buf = &(todo_list.buf);
4867 struct object_id oid;
4868 struct stat st;
4869
4870 get_oid(onto, &oid);
4871 shortonto = find_unique_abbrev(&oid, DEFAULT_ABBREV);
4872
4873 if (!lstat(todo_file, &st) && st.st_size == 0 &&
4874 write_message("noop\n", 5, todo_file, 0))
4875 return -1;
4876
4877 if (autosquash && rearrange_squash(r))
4878 return -1;
4879
4880 if (cmd && *cmd)
4881 sequencer_add_exec_commands(r, cmd);
4882
4883 if (strbuf_read_file(buf, todo_file, 0) < 0)
4884 return error_errno(_("could not read '%s'."), todo_file);
4885
4886 if (parse_insn_buffer(r, buf->buf, &todo_list)) {
4887 todo_list_release(&todo_list);
4888 return error(_("unusable todo list: '%s'"), todo_file);
4889 }
4890
4891 if (count_commands(&todo_list) == 0) {
4892 apply_autostash(opts);
4893 sequencer_remove_state(opts);
4894 todo_list_release(&todo_list);
4895
4896 return error(_("nothing to do"));
4897 }
4898
4899 strbuf_addch(buf, '\n');
4900 strbuf_commented_addf(buf, Q_("Rebase %s onto %s (%d command)",
4901 "Rebase %s onto %s (%d commands)",
4902 count_commands(&todo_list)),
4903 shortrevisions, shortonto, count_commands(&todo_list));
4904 append_todo_help(0, flags & TODO_LIST_KEEP_EMPTY, buf);
4905
4906 if (write_message(buf->buf, buf->len, todo_file, 0)) {
4907 todo_list_release(&todo_list);
4908 return -1;
4909 }
4910
4911 if (copy_file(rebase_path_todo_backup(), todo_file, 0666))
4912 return error(_("could not copy '%s' to '%s'."), todo_file,
4913 rebase_path_todo_backup());
4914
4915 if (transform_todos(r, flags | TODO_LIST_SHORTEN_IDS))
4916 return error(_("could not transform the todo list"));
4917
4918 strbuf_reset(buf);
4919
4920 if (launch_sequence_editor(todo_file, buf, NULL)) {
4921 apply_autostash(opts);
4922 sequencer_remove_state(opts);
4923 todo_list_release(&todo_list);
4924
4925 return -1;
4926 }
4927
4928 strbuf_stripspace(buf, 1);
4929 if (buf->len == 0) {
4930 apply_autostash(opts);
4931 sequencer_remove_state(opts);
4932 todo_list_release(&todo_list);
4933
4934 return error(_("nothing to do"));
4935 }
4936
4937 todo_list_release(&todo_list);
4938
4939 if (check_todo_list(r)) {
4940 checkout_onto(opts, onto_name, onto, orig_head);
4941 return -1;
4942 }
4943
4944 if (transform_todos(r, flags & ~(TODO_LIST_SHORTEN_IDS)))
4945 return error(_("could not transform the todo list"));
4946
4947 if (opts->allow_ff && skip_unnecessary_picks(r, &oid))
4948 return error(_("could not skip unnecessary pick commands"));
4949
4950 if (checkout_onto(opts, onto_name, oid_to_hex(&oid), orig_head))
4951 return -1;
4952
4953 if (require_clean_work_tree(r, "rebase", "", 1, 1))
4954 return -1;
4955
4956 return sequencer_continue(r, opts);
4957}
4958
4959struct subject2item_entry {
4960 struct hashmap_entry entry;
4961 int i;
4962 char subject[FLEX_ARRAY];
4963};
4964
4965static int subject2item_cmp(const void *fndata,
4966 const struct subject2item_entry *a,
4967 const struct subject2item_entry *b, const void *key)
4968{
4969 return key ? strcmp(a->subject, key) : strcmp(a->subject, b->subject);
4970}
4971
4972define_commit_slab(commit_todo_item, struct todo_item *);
4973
4974/*
4975 * Rearrange the todo list that has both "pick commit-id msg" and "pick
4976 * commit-id fixup!/squash! msg" in it so that the latter is put immediately
4977 * after the former, and change "pick" to "fixup"/"squash".
4978 *
4979 * Note that if the config has specified a custom instruction format, each log
4980 * message will have to be retrieved from the commit (as the oneline in the
4981 * script cannot be trusted) in order to normalize the autosquash arrangement.
4982 */
4983int rearrange_squash(struct repository *r)
4984{
4985 const char *todo_file = rebase_path_todo();
4986 struct todo_list todo_list = TODO_LIST_INIT;
4987 struct hashmap subject2item;
4988 int res = 0, rearranged = 0, *next, *tail, i;
4989 char **subjects;
4990 struct commit_todo_item commit_todo;
4991
4992 if (strbuf_read_file_or_whine(&todo_list.buf, todo_file) < 0)
4993 return -1;
4994 if (parse_insn_buffer(r, todo_list.buf.buf, &todo_list) < 0) {
4995 todo_list_release(&todo_list);
4996 return -1;
4997 }
4998
4999 init_commit_todo_item(&commit_todo);
5000 /*
5001 * The hashmap maps onelines to the respective todo list index.
5002 *
5003 * If any items need to be rearranged, the next[i] value will indicate
5004 * which item was moved directly after the i'th.
5005 *
5006 * In that case, last[i] will indicate the index of the latest item to
5007 * be moved to appear after the i'th.
5008 */
5009 hashmap_init(&subject2item, (hashmap_cmp_fn) subject2item_cmp,
5010 NULL, todo_list.nr);
5011 ALLOC_ARRAY(next, todo_list.nr);
5012 ALLOC_ARRAY(tail, todo_list.nr);
5013 ALLOC_ARRAY(subjects, todo_list.nr);
5014 for (i = 0; i < todo_list.nr; i++) {
5015 struct strbuf buf = STRBUF_INIT;
5016 struct todo_item *item = todo_list.items + i;
5017 const char *commit_buffer, *subject, *p;
5018 size_t subject_len;
5019 int i2 = -1;
5020 struct subject2item_entry *entry;
5021
5022 next[i] = tail[i] = -1;
5023 if (!item->commit || item->command == TODO_DROP) {
5024 subjects[i] = NULL;
5025 continue;
5026 }
5027
5028 if (is_fixup(item->command)) {
5029 todo_list_release(&todo_list);
5030 clear_commit_todo_item(&commit_todo);
5031 return error(_("the script was already rearranged."));
5032 }
5033
5034 *commit_todo_item_at(&commit_todo, item->commit) = item;
5035
5036 parse_commit(item->commit);
5037 commit_buffer = get_commit_buffer(item->commit, NULL);
5038 find_commit_subject(commit_buffer, &subject);
5039 format_subject(&buf, subject, " ");
5040 subject = subjects[i] = strbuf_detach(&buf, &subject_len);
5041 unuse_commit_buffer(item->commit, commit_buffer);
5042 if ((skip_prefix(subject, "fixup! ", &p) ||
5043 skip_prefix(subject, "squash! ", &p))) {
5044 struct commit *commit2;
5045
5046 for (;;) {
5047 while (isspace(*p))
5048 p++;
5049 if (!skip_prefix(p, "fixup! ", &p) &&
5050 !skip_prefix(p, "squash! ", &p))
5051 break;
5052 }
5053
5054 if ((entry = hashmap_get_from_hash(&subject2item,
5055 strhash(p), p)))
5056 /* found by title */
5057 i2 = entry->i;
5058 else if (!strchr(p, ' ') &&
5059 (commit2 =
5060 lookup_commit_reference_by_name(p)) &&
5061 *commit_todo_item_at(&commit_todo, commit2))
5062 /* found by commit name */
5063 i2 = *commit_todo_item_at(&commit_todo, commit2)
5064 - todo_list.items;
5065 else {
5066 /* copy can be a prefix of the commit subject */
5067 for (i2 = 0; i2 < i; i2++)
5068 if (subjects[i2] &&
5069 starts_with(subjects[i2], p))
5070 break;
5071 if (i2 == i)
5072 i2 = -1;
5073 }
5074 }
5075 if (i2 >= 0) {
5076 rearranged = 1;
5077 todo_list.items[i].command =
5078 starts_with(subject, "fixup!") ?
5079 TODO_FIXUP : TODO_SQUASH;
5080 if (next[i2] < 0)
5081 next[i2] = i;
5082 else
5083 next[tail[i2]] = i;
5084 tail[i2] = i;
5085 } else if (!hashmap_get_from_hash(&subject2item,
5086 strhash(subject), subject)) {
5087 FLEX_ALLOC_MEM(entry, subject, subject, subject_len);
5088 entry->i = i;
5089 hashmap_entry_init(entry, strhash(entry->subject));
5090 hashmap_put(&subject2item, entry);
5091 }
5092 }
5093
5094 if (rearranged) {
5095 struct strbuf buf = STRBUF_INIT;
5096
5097 for (i = 0; i < todo_list.nr; i++) {
5098 enum todo_command command = todo_list.items[i].command;
5099 int cur = i;
5100
5101 /*
5102 * Initially, all commands are 'pick's. If it is a
5103 * fixup or a squash now, we have rearranged it.
5104 */
5105 if (is_fixup(command))
5106 continue;
5107
5108 while (cur >= 0) {
5109 const char *bol =
5110 get_item_line(&todo_list, cur);
5111 const char *eol =
5112 get_item_line(&todo_list, cur + 1);
5113
5114 /* replace 'pick', by 'fixup' or 'squash' */
5115 command = todo_list.items[cur].command;
5116 if (is_fixup(command)) {
5117 strbuf_addstr(&buf,
5118 todo_command_info[command].str);
5119 bol += strcspn(bol, " \t");
5120 }
5121
5122 strbuf_add(&buf, bol, eol - bol);
5123
5124 cur = next[cur];
5125 }
5126 }
5127
5128 res = rewrite_file(todo_file, buf.buf, buf.len);
5129 strbuf_release(&buf);
5130 }
5131
5132 free(next);
5133 free(tail);
5134 for (i = 0; i < todo_list.nr; i++)
5135 free(subjects[i]);
5136 free(subjects);
5137 hashmap_free(&subject2item, 1);
5138 todo_list_release(&todo_list);
5139
5140 clear_commit_todo_item(&commit_todo);
5141 return res;
5142}