Merge branch 'ls/no-double-utf8-author-name' of ../git-gui into ls/git-gui-no-double...
[git/git.git] / sequencer.c
1 #include "cache.h"
2 #include "config.h"
3 #include "lockfile.h"
4 #include "sequencer.h"
5 #include "dir.h"
6 #include "object.h"
7 #include "commit.h"
8 #include "tag.h"
9 #include "run-command.h"
10 #include "exec_cmd.h"
11 #include "utf8.h"
12 #include "cache-tree.h"
13 #include "diff.h"
14 #include "revision.h"
15 #include "rerere.h"
16 #include "merge-recursive.h"
17 #include "refs.h"
18 #include "argv-array.h"
19 #include "quote.h"
20 #include "trailer.h"
21 #include "log-tree.h"
22 #include "wt-status.h"
23 #include "hashmap.h"
24
25 #define GIT_REFLOG_ACTION "GIT_REFLOG_ACTION"
26
27 const char sign_off_header[] = "Signed-off-by: ";
28 static const char cherry_picked_prefix[] = "(cherry picked from commit ";
29
30 GIT_PATH_FUNC(git_path_seq_dir, "sequencer")
31
32 static GIT_PATH_FUNC(git_path_todo_file, "sequencer/todo")
33 static GIT_PATH_FUNC(git_path_opts_file, "sequencer/opts")
34 static GIT_PATH_FUNC(git_path_head_file, "sequencer/head")
35 static GIT_PATH_FUNC(git_path_abort_safety_file, "sequencer/abort-safety")
36
37 static GIT_PATH_FUNC(rebase_path, "rebase-merge")
38 /*
39 * The file containing rebase commands, comments, and empty lines.
40 * This file is created by "git rebase -i" then edited by the user. As
41 * the lines are processed, they are removed from the front of this
42 * file and written to the tail of 'done'.
43 */
44 static GIT_PATH_FUNC(rebase_path_todo, "rebase-merge/git-rebase-todo")
45 /*
46 * The rebase command lines that have already been processed. A line
47 * is moved here when it is first handled, before any associated user
48 * actions.
49 */
50 static GIT_PATH_FUNC(rebase_path_done, "rebase-merge/done")
51 /*
52 * The file to keep track of how many commands were already processed (e.g.
53 * for the prompt).
54 */
55 static GIT_PATH_FUNC(rebase_path_msgnum, "rebase-merge/msgnum");
56 /*
57 * The file to keep track of how many commands are to be processed in total
58 * (e.g. for the prompt).
59 */
60 static GIT_PATH_FUNC(rebase_path_msgtotal, "rebase-merge/end");
61 /*
62 * The commit message that is planned to be used for any changes that
63 * need to be committed following a user interaction.
64 */
65 static GIT_PATH_FUNC(rebase_path_message, "rebase-merge/message")
66 /*
67 * The file into which is accumulated the suggested commit message for
68 * squash/fixup commands. When the first of a series of squash/fixups
69 * is seen, the file is created and the commit message from the
70 * previous commit and from the first squash/fixup commit are written
71 * to it. The commit message for each subsequent squash/fixup commit
72 * is appended to the file as it is processed.
73 *
74 * The first line of the file is of the form
75 * # This is a combination of $count commits.
76 * where $count is the number of commits whose messages have been
77 * written to the file so far (including the initial "pick" commit).
78 * Each time that a commit message is processed, this line is read and
79 * updated. It is deleted just before the combined commit is made.
80 */
81 static GIT_PATH_FUNC(rebase_path_squash_msg, "rebase-merge/message-squash")
82 /*
83 * If the current series of squash/fixups has not yet included a squash
84 * command, then this file exists and holds the commit message of the
85 * original "pick" commit. (If the series ends without a "squash"
86 * command, then this can be used as the commit message of the combined
87 * commit without opening the editor.)
88 */
89 static GIT_PATH_FUNC(rebase_path_fixup_msg, "rebase-merge/message-fixup")
90 /*
91 * A script to set the GIT_AUTHOR_NAME, GIT_AUTHOR_EMAIL, and
92 * GIT_AUTHOR_DATE that will be used for the commit that is currently
93 * being rebased.
94 */
95 static GIT_PATH_FUNC(rebase_path_author_script, "rebase-merge/author-script")
96 /*
97 * When an "edit" rebase command is being processed, the SHA1 of the
98 * commit to be edited is recorded in this file. When "git rebase
99 * --continue" is executed, if there are any staged changes then they
100 * will be amended to the HEAD commit, but only provided the HEAD
101 * commit is still the commit to be edited. When any other rebase
102 * command is processed, this file is deleted.
103 */
104 static GIT_PATH_FUNC(rebase_path_amend, "rebase-merge/amend")
105 /*
106 * When we stop at a given patch via the "edit" command, this file contains
107 * the abbreviated commit name of the corresponding patch.
108 */
109 static GIT_PATH_FUNC(rebase_path_stopped_sha, "rebase-merge/stopped-sha")
110 /*
111 * For the post-rewrite hook, we make a list of rewritten commits and
112 * their new sha1s. The rewritten-pending list keeps the sha1s of
113 * commits that have been processed, but not committed yet,
114 * e.g. because they are waiting for a 'squash' command.
115 */
116 static GIT_PATH_FUNC(rebase_path_rewritten_list, "rebase-merge/rewritten-list")
117 static GIT_PATH_FUNC(rebase_path_rewritten_pending,
118 "rebase-merge/rewritten-pending")
119 /*
120 * The following files are written by git-rebase just after parsing the
121 * command-line (and are only consumed, not modified, by the sequencer).
122 */
123 static GIT_PATH_FUNC(rebase_path_gpg_sign_opt, "rebase-merge/gpg_sign_opt")
124 static GIT_PATH_FUNC(rebase_path_orig_head, "rebase-merge/orig-head")
125 static GIT_PATH_FUNC(rebase_path_verbose, "rebase-merge/verbose")
126 static GIT_PATH_FUNC(rebase_path_head_name, "rebase-merge/head-name")
127 static GIT_PATH_FUNC(rebase_path_onto, "rebase-merge/onto")
128 static GIT_PATH_FUNC(rebase_path_autostash, "rebase-merge/autostash")
129 static GIT_PATH_FUNC(rebase_path_strategy, "rebase-merge/strategy")
130 static GIT_PATH_FUNC(rebase_path_strategy_opts, "rebase-merge/strategy_opts")
131 static GIT_PATH_FUNC(rebase_path_allow_rerere_autoupdate, "rebase-merge/allow_rerere_autoupdate")
132
133 static inline int is_rebase_i(const struct replay_opts *opts)
134 {
135 return opts->action == REPLAY_INTERACTIVE_REBASE;
136 }
137
138 static const char *get_dir(const struct replay_opts *opts)
139 {
140 if (is_rebase_i(opts))
141 return rebase_path();
142 return git_path_seq_dir();
143 }
144
145 static const char *get_todo_path(const struct replay_opts *opts)
146 {
147 if (is_rebase_i(opts))
148 return rebase_path_todo();
149 return git_path_todo_file();
150 }
151
152 /*
153 * Returns 0 for non-conforming footer
154 * Returns 1 for conforming footer
155 * Returns 2 when sob exists within conforming footer
156 * Returns 3 when sob exists within conforming footer as last entry
157 */
158 static int has_conforming_footer(struct strbuf *sb, struct strbuf *sob,
159 int ignore_footer)
160 {
161 struct trailer_info info;
162 int i;
163 int found_sob = 0, found_sob_last = 0;
164
165 trailer_info_get(&info, sb->buf);
166
167 if (info.trailer_start == info.trailer_end)
168 return 0;
169
170 for (i = 0; i < info.trailer_nr; i++)
171 if (sob && !strncmp(info.trailers[i], sob->buf, sob->len)) {
172 found_sob = 1;
173 if (i == info.trailer_nr - 1)
174 found_sob_last = 1;
175 }
176
177 trailer_info_release(&info);
178
179 if (found_sob_last)
180 return 3;
181 if (found_sob)
182 return 2;
183 return 1;
184 }
185
186 static const char *gpg_sign_opt_quoted(struct replay_opts *opts)
187 {
188 static struct strbuf buf = STRBUF_INIT;
189
190 strbuf_reset(&buf);
191 if (opts->gpg_sign)
192 sq_quotef(&buf, "-S%s", opts->gpg_sign);
193 return buf.buf;
194 }
195
196 int sequencer_remove_state(struct replay_opts *opts)
197 {
198 struct strbuf dir = STRBUF_INIT;
199 int i;
200
201 free(opts->gpg_sign);
202 free(opts->strategy);
203 for (i = 0; i < opts->xopts_nr; i++)
204 free(opts->xopts[i]);
205 free(opts->xopts);
206
207 strbuf_addstr(&dir, get_dir(opts));
208 remove_dir_recursively(&dir, 0);
209 strbuf_release(&dir);
210
211 return 0;
212 }
213
214 static const char *action_name(const struct replay_opts *opts)
215 {
216 switch (opts->action) {
217 case REPLAY_REVERT:
218 return N_("revert");
219 case REPLAY_PICK:
220 return N_("cherry-pick");
221 case REPLAY_INTERACTIVE_REBASE:
222 return N_("rebase -i");
223 }
224 die(_("Unknown action: %d"), opts->action);
225 }
226
227 struct commit_message {
228 char *parent_label;
229 char *label;
230 char *subject;
231 const char *message;
232 };
233
234 static const char *short_commit_name(struct commit *commit)
235 {
236 return find_unique_abbrev(commit->object.oid.hash, DEFAULT_ABBREV);
237 }
238
239 static int get_message(struct commit *commit, struct commit_message *out)
240 {
241 const char *abbrev, *subject;
242 int subject_len;
243
244 out->message = logmsg_reencode(commit, NULL, get_commit_output_encoding());
245 abbrev = short_commit_name(commit);
246
247 subject_len = find_commit_subject(out->message, &subject);
248
249 out->subject = xmemdupz(subject, subject_len);
250 out->label = xstrfmt("%s... %s", abbrev, out->subject);
251 out->parent_label = xstrfmt("parent of %s", out->label);
252
253 return 0;
254 }
255
256 static void free_message(struct commit *commit, struct commit_message *msg)
257 {
258 free(msg->parent_label);
259 free(msg->label);
260 free(msg->subject);
261 unuse_commit_buffer(commit, msg->message);
262 }
263
264 static void print_advice(int show_hint, struct replay_opts *opts)
265 {
266 char *msg = getenv("GIT_CHERRY_PICK_HELP");
267
268 if (msg) {
269 fprintf(stderr, "%s\n", msg);
270 /*
271 * A conflict has occurred but the porcelain
272 * (typically rebase --interactive) wants to take care
273 * of the commit itself so remove CHERRY_PICK_HEAD
274 */
275 unlink(git_path_cherry_pick_head());
276 return;
277 }
278
279 if (show_hint) {
280 if (opts->no_commit)
281 advise(_("after resolving the conflicts, mark the corrected paths\n"
282 "with 'git add <paths>' or 'git rm <paths>'"));
283 else
284 advise(_("after resolving the conflicts, mark the corrected paths\n"
285 "with 'git add <paths>' or 'git rm <paths>'\n"
286 "and commit the result with 'git commit'"));
287 }
288 }
289
290 static int write_message(const void *buf, size_t len, const char *filename,
291 int append_eol)
292 {
293 static struct lock_file msg_file;
294
295 int msg_fd = hold_lock_file_for_update(&msg_file, filename, 0);
296 if (msg_fd < 0)
297 return error_errno(_("could not lock '%s'"), filename);
298 if (write_in_full(msg_fd, buf, len) < 0) {
299 rollback_lock_file(&msg_file);
300 return error_errno(_("could not write to '%s'"), filename);
301 }
302 if (append_eol && write(msg_fd, "\n", 1) < 0) {
303 rollback_lock_file(&msg_file);
304 return error_errno(_("could not write eol to '%s'"), filename);
305 }
306 if (commit_lock_file(&msg_file) < 0) {
307 rollback_lock_file(&msg_file);
308 return error(_("failed to finalize '%s'."), filename);
309 }
310
311 return 0;
312 }
313
314 /*
315 * Reads a file that was presumably written by a shell script, i.e. with an
316 * end-of-line marker that needs to be stripped.
317 *
318 * Note that only the last end-of-line marker is stripped, consistent with the
319 * behavior of "$(cat path)" in a shell script.
320 *
321 * Returns 1 if the file was read, 0 if it could not be read or does not exist.
322 */
323 static int read_oneliner(struct strbuf *buf,
324 const char *path, int skip_if_empty)
325 {
326 int orig_len = buf->len;
327
328 if (!file_exists(path))
329 return 0;
330
331 if (strbuf_read_file(buf, path, 0) < 0) {
332 warning_errno(_("could not read '%s'"), path);
333 return 0;
334 }
335
336 if (buf->len > orig_len && buf->buf[buf->len - 1] == '\n') {
337 if (--buf->len > orig_len && buf->buf[buf->len - 1] == '\r')
338 --buf->len;
339 buf->buf[buf->len] = '\0';
340 }
341
342 if (skip_if_empty && buf->len == orig_len)
343 return 0;
344
345 return 1;
346 }
347
348 static struct tree *empty_tree(void)
349 {
350 return lookup_tree(&empty_tree_oid);
351 }
352
353 static int error_dirty_index(struct replay_opts *opts)
354 {
355 if (read_cache_unmerged())
356 return error_resolve_conflict(_(action_name(opts)));
357
358 error(_("your local changes would be overwritten by %s."),
359 _(action_name(opts)));
360
361 if (advice_commit_before_merge)
362 advise(_("commit your changes or stash them to proceed."));
363 return -1;
364 }
365
366 static void update_abort_safety_file(void)
367 {
368 struct object_id head;
369
370 /* Do nothing on a single-pick */
371 if (!file_exists(git_path_seq_dir()))
372 return;
373
374 if (!get_oid("HEAD", &head))
375 write_file(git_path_abort_safety_file(), "%s", oid_to_hex(&head));
376 else
377 write_file(git_path_abort_safety_file(), "%s", "");
378 }
379
380 static int fast_forward_to(const struct object_id *to, const struct object_id *from,
381 int unborn, struct replay_opts *opts)
382 {
383 struct ref_transaction *transaction;
384 struct strbuf sb = STRBUF_INIT;
385 struct strbuf err = STRBUF_INIT;
386
387 read_cache();
388 if (checkout_fast_forward(from, to, 1))
389 return -1; /* the callee should have complained already */
390
391 strbuf_addf(&sb, _("%s: fast-forward"), _(action_name(opts)));
392
393 transaction = ref_transaction_begin(&err);
394 if (!transaction ||
395 ref_transaction_update(transaction, "HEAD",
396 to, unborn ? &null_oid : from,
397 0, sb.buf, &err) ||
398 ref_transaction_commit(transaction, &err)) {
399 ref_transaction_free(transaction);
400 error("%s", err.buf);
401 strbuf_release(&sb);
402 strbuf_release(&err);
403 return -1;
404 }
405
406 strbuf_release(&sb);
407 strbuf_release(&err);
408 ref_transaction_free(transaction);
409 update_abort_safety_file();
410 return 0;
411 }
412
413 void append_conflicts_hint(struct strbuf *msgbuf)
414 {
415 int i;
416
417 strbuf_addch(msgbuf, '\n');
418 strbuf_commented_addf(msgbuf, "Conflicts:\n");
419 for (i = 0; i < active_nr;) {
420 const struct cache_entry *ce = active_cache[i++];
421 if (ce_stage(ce)) {
422 strbuf_commented_addf(msgbuf, "\t%s\n", ce->name);
423 while (i < active_nr && !strcmp(ce->name,
424 active_cache[i]->name))
425 i++;
426 }
427 }
428 }
429
430 static int do_recursive_merge(struct commit *base, struct commit *next,
431 const char *base_label, const char *next_label,
432 struct object_id *head, struct strbuf *msgbuf,
433 struct replay_opts *opts)
434 {
435 struct merge_options o;
436 struct tree *result, *next_tree, *base_tree, *head_tree;
437 int clean;
438 char **xopt;
439 static struct lock_file index_lock;
440
441 if (hold_locked_index(&index_lock, LOCK_REPORT_ON_ERROR) < 0)
442 return -1;
443
444 read_cache();
445
446 init_merge_options(&o);
447 o.ancestor = base ? base_label : "(empty tree)";
448 o.branch1 = "HEAD";
449 o.branch2 = next ? next_label : "(empty tree)";
450 if (is_rebase_i(opts))
451 o.buffer_output = 2;
452
453 head_tree = parse_tree_indirect(head);
454 next_tree = next ? next->tree : empty_tree();
455 base_tree = base ? base->tree : empty_tree();
456
457 for (xopt = opts->xopts; xopt != opts->xopts + opts->xopts_nr; xopt++)
458 parse_merge_opt(&o, *xopt);
459
460 clean = merge_trees(&o,
461 head_tree,
462 next_tree, base_tree, &result);
463 if (is_rebase_i(opts) && clean <= 0)
464 fputs(o.obuf.buf, stdout);
465 strbuf_release(&o.obuf);
466 if (clean < 0)
467 return clean;
468
469 if (active_cache_changed &&
470 write_locked_index(&the_index, &index_lock, COMMIT_LOCK))
471 /*
472 * TRANSLATORS: %s will be "revert", "cherry-pick" or
473 * "rebase -i".
474 */
475 return error(_("%s: Unable to write new index file"),
476 _(action_name(opts)));
477 rollback_lock_file(&index_lock);
478
479 if (opts->signoff)
480 append_signoff(msgbuf, 0, 0);
481
482 if (!clean)
483 append_conflicts_hint(msgbuf);
484
485 return !clean;
486 }
487
488 static int is_index_unchanged(void)
489 {
490 struct object_id head_oid;
491 struct commit *head_commit;
492
493 if (!resolve_ref_unsafe("HEAD", RESOLVE_REF_READING, &head_oid, NULL))
494 return error(_("could not resolve HEAD commit\n"));
495
496 head_commit = lookup_commit(&head_oid);
497
498 /*
499 * If head_commit is NULL, check_commit, called from
500 * lookup_commit, would have indicated that head_commit is not
501 * a commit object already. parse_commit() will return failure
502 * without further complaints in such a case. Otherwise, if
503 * the commit is invalid, parse_commit() will complain. So
504 * there is nothing for us to say here. Just return failure.
505 */
506 if (parse_commit(head_commit))
507 return -1;
508
509 if (!active_cache_tree)
510 active_cache_tree = cache_tree();
511
512 if (!cache_tree_fully_valid(active_cache_tree))
513 if (cache_tree_update(&the_index, 0))
514 return error(_("unable to update cache tree\n"));
515
516 return !oidcmp(&active_cache_tree->oid,
517 &head_commit->tree->object.oid);
518 }
519
520 static int write_author_script(const char *message)
521 {
522 struct strbuf buf = STRBUF_INIT;
523 const char *eol;
524 int res;
525
526 for (;;)
527 if (!*message || starts_with(message, "\n")) {
528 missing_author:
529 /* Missing 'author' line? */
530 unlink(rebase_path_author_script());
531 return 0;
532 } else if (skip_prefix(message, "author ", &message))
533 break;
534 else if ((eol = strchr(message, '\n')))
535 message = eol + 1;
536 else
537 goto missing_author;
538
539 strbuf_addstr(&buf, "GIT_AUTHOR_NAME='");
540 while (*message && *message != '\n' && *message != '\r')
541 if (skip_prefix(message, " <", &message))
542 break;
543 else if (*message != '\'')
544 strbuf_addch(&buf, *(message++));
545 else
546 strbuf_addf(&buf, "'\\\\%c'", *(message++));
547 strbuf_addstr(&buf, "'\nGIT_AUTHOR_EMAIL='");
548 while (*message && *message != '\n' && *message != '\r')
549 if (skip_prefix(message, "> ", &message))
550 break;
551 else if (*message != '\'')
552 strbuf_addch(&buf, *(message++));
553 else
554 strbuf_addf(&buf, "'\\\\%c'", *(message++));
555 strbuf_addstr(&buf, "'\nGIT_AUTHOR_DATE='@");
556 while (*message && *message != '\n' && *message != '\r')
557 if (*message != '\'')
558 strbuf_addch(&buf, *(message++));
559 else
560 strbuf_addf(&buf, "'\\\\%c'", *(message++));
561 res = write_message(buf.buf, buf.len, rebase_path_author_script(), 1);
562 strbuf_release(&buf);
563 return res;
564 }
565
566 /*
567 * Read a list of environment variable assignments (such as the author-script
568 * file) into an environment block. Returns -1 on error, 0 otherwise.
569 */
570 static int read_env_script(struct argv_array *env)
571 {
572 struct strbuf script = STRBUF_INIT;
573 int i, count = 0;
574 char *p, *p2;
575
576 if (strbuf_read_file(&script, rebase_path_author_script(), 256) <= 0)
577 return -1;
578
579 for (p = script.buf; *p; p++)
580 if (skip_prefix(p, "'\\\\''", (const char **)&p2))
581 strbuf_splice(&script, p - script.buf, p2 - p, "'", 1);
582 else if (*p == '\'')
583 strbuf_splice(&script, p-- - script.buf, 1, "", 0);
584 else if (*p == '\n') {
585 *p = '\0';
586 count++;
587 }
588
589 for (i = 0, p = script.buf; i < count; i++) {
590 argv_array_push(env, p);
591 p += strlen(p) + 1;
592 }
593
594 return 0;
595 }
596
597 static const char staged_changes_advice[] =
598 N_("you have staged changes in your working tree\n"
599 "If these changes are meant to be squashed into the previous commit, run:\n"
600 "\n"
601 " git commit --amend %s\n"
602 "\n"
603 "If they are meant to go into a new commit, run:\n"
604 "\n"
605 " git commit %s\n"
606 "\n"
607 "In both cases, once you're done, continue with:\n"
608 "\n"
609 " git rebase --continue\n");
610
611 #define ALLOW_EMPTY (1<<0)
612 #define EDIT_MSG (1<<1)
613 #define AMEND_MSG (1<<2)
614 #define CLEANUP_MSG (1<<3)
615 #define VERIFY_MSG (1<<4)
616
617 /*
618 * If we are cherry-pick, and if the merge did not result in
619 * hand-editing, we will hit this commit and inherit the original
620 * author date and name.
621 *
622 * If we are revert, or if our cherry-pick results in a hand merge,
623 * we had better say that the current user is responsible for that.
624 *
625 * An exception is when run_git_commit() is called during an
626 * interactive rebase: in that case, we will want to retain the
627 * author metadata.
628 */
629 static int run_git_commit(const char *defmsg, struct replay_opts *opts,
630 unsigned int flags)
631 {
632 struct child_process cmd = CHILD_PROCESS_INIT;
633 const char *value;
634
635 cmd.git_cmd = 1;
636
637 if (is_rebase_i(opts)) {
638 if (!(flags & EDIT_MSG)) {
639 cmd.stdout_to_stderr = 1;
640 cmd.err = -1;
641 }
642
643 if (read_env_script(&cmd.env_array)) {
644 const char *gpg_opt = gpg_sign_opt_quoted(opts);
645
646 return error(_(staged_changes_advice),
647 gpg_opt, gpg_opt);
648 }
649 }
650
651 argv_array_push(&cmd.args, "commit");
652
653 if (!(flags & VERIFY_MSG))
654 argv_array_push(&cmd.args, "-n");
655 if ((flags & AMEND_MSG))
656 argv_array_push(&cmd.args, "--amend");
657 if (opts->gpg_sign)
658 argv_array_pushf(&cmd.args, "-S%s", opts->gpg_sign);
659 if (opts->signoff)
660 argv_array_push(&cmd.args, "-s");
661 if (defmsg)
662 argv_array_pushl(&cmd.args, "-F", defmsg, NULL);
663 if ((flags & CLEANUP_MSG))
664 argv_array_push(&cmd.args, "--cleanup=strip");
665 if ((flags & EDIT_MSG))
666 argv_array_push(&cmd.args, "-e");
667 else if (!(flags & CLEANUP_MSG) &&
668 !opts->signoff && !opts->record_origin &&
669 git_config_get_value("commit.cleanup", &value))
670 argv_array_push(&cmd.args, "--cleanup=verbatim");
671
672 if ((flags & ALLOW_EMPTY))
673 argv_array_push(&cmd.args, "--allow-empty");
674
675 if (opts->allow_empty_message)
676 argv_array_push(&cmd.args, "--allow-empty-message");
677
678 if (cmd.err == -1) {
679 /* hide stderr on success */
680 struct strbuf buf = STRBUF_INIT;
681 int rc = pipe_command(&cmd,
682 NULL, 0,
683 /* stdout is already redirected */
684 NULL, 0,
685 &buf, 0);
686 if (rc)
687 fputs(buf.buf, stderr);
688 strbuf_release(&buf);
689 return rc;
690 }
691
692 return run_command(&cmd);
693 }
694
695 static int is_original_commit_empty(struct commit *commit)
696 {
697 const struct object_id *ptree_oid;
698
699 if (parse_commit(commit))
700 return error(_("could not parse commit %s\n"),
701 oid_to_hex(&commit->object.oid));
702 if (commit->parents) {
703 struct commit *parent = commit->parents->item;
704 if (parse_commit(parent))
705 return error(_("could not parse parent commit %s\n"),
706 oid_to_hex(&parent->object.oid));
707 ptree_oid = &parent->tree->object.oid;
708 } else {
709 ptree_oid = &empty_tree_oid; /* commit is root */
710 }
711
712 return !oidcmp(ptree_oid, &commit->tree->object.oid);
713 }
714
715 /*
716 * Do we run "git commit" with "--allow-empty"?
717 */
718 static int allow_empty(struct replay_opts *opts, struct commit *commit)
719 {
720 int index_unchanged, empty_commit;
721
722 /*
723 * Three cases:
724 *
725 * (1) we do not allow empty at all and error out.
726 *
727 * (2) we allow ones that were initially empty, but
728 * forbid the ones that become empty;
729 *
730 * (3) we allow both.
731 */
732 if (!opts->allow_empty)
733 return 0; /* let "git commit" barf as necessary */
734
735 index_unchanged = is_index_unchanged();
736 if (index_unchanged < 0)
737 return index_unchanged;
738 if (!index_unchanged)
739 return 0; /* we do not have to say --allow-empty */
740
741 if (opts->keep_redundant_commits)
742 return 1;
743
744 empty_commit = is_original_commit_empty(commit);
745 if (empty_commit < 0)
746 return empty_commit;
747 if (!empty_commit)
748 return 0;
749 else
750 return 1;
751 }
752
753 /*
754 * Note that ordering matters in this enum. Not only must it match the mapping
755 * below, it is also divided into several sections that matter. When adding
756 * new commands, make sure you add it in the right section.
757 */
758 enum todo_command {
759 /* commands that handle commits */
760 TODO_PICK = 0,
761 TODO_REVERT,
762 TODO_EDIT,
763 TODO_REWORD,
764 TODO_FIXUP,
765 TODO_SQUASH,
766 /* commands that do something else than handling a single commit */
767 TODO_EXEC,
768 /* commands that do nothing but are counted for reporting progress */
769 TODO_NOOP,
770 TODO_DROP,
771 /* comments (not counted for reporting progress) */
772 TODO_COMMENT
773 };
774
775 static struct {
776 char c;
777 const char *str;
778 } todo_command_info[] = {
779 { 'p', "pick" },
780 { 0, "revert" },
781 { 'e', "edit" },
782 { 'r', "reword" },
783 { 'f', "fixup" },
784 { 's', "squash" },
785 { 'x', "exec" },
786 { 0, "noop" },
787 { 'd', "drop" },
788 { 0, NULL }
789 };
790
791 static const char *command_to_string(const enum todo_command command)
792 {
793 if (command < TODO_COMMENT)
794 return todo_command_info[command].str;
795 die("Unknown command: %d", command);
796 }
797
798 static int is_noop(const enum todo_command command)
799 {
800 return TODO_NOOP <= command;
801 }
802
803 static int is_fixup(enum todo_command command)
804 {
805 return command == TODO_FIXUP || command == TODO_SQUASH;
806 }
807
808 static int update_squash_messages(enum todo_command command,
809 struct commit *commit, struct replay_opts *opts)
810 {
811 struct strbuf buf = STRBUF_INIT;
812 int count, res;
813 const char *message, *body;
814
815 if (file_exists(rebase_path_squash_msg())) {
816 struct strbuf header = STRBUF_INIT;
817 char *eol, *p;
818
819 if (strbuf_read_file(&buf, rebase_path_squash_msg(), 2048) <= 0)
820 return error(_("could not read '%s'"),
821 rebase_path_squash_msg());
822
823 p = buf.buf + 1;
824 eol = strchrnul(buf.buf, '\n');
825 if (buf.buf[0] != comment_line_char ||
826 (p += strcspn(p, "0123456789\n")) == eol)
827 return error(_("unexpected 1st line of squash message:"
828 "\n\n\t%.*s"),
829 (int)(eol - buf.buf), buf.buf);
830 count = strtol(p, NULL, 10);
831
832 if (count < 1)
833 return error(_("invalid 1st line of squash message:\n"
834 "\n\t%.*s"),
835 (int)(eol - buf.buf), buf.buf);
836
837 strbuf_addf(&header, "%c ", comment_line_char);
838 strbuf_addf(&header,
839 _("This is a combination of %d commits."), ++count);
840 strbuf_splice(&buf, 0, eol - buf.buf, header.buf, header.len);
841 strbuf_release(&header);
842 } else {
843 struct object_id head;
844 struct commit *head_commit;
845 const char *head_message, *body;
846
847 if (get_oid("HEAD", &head))
848 return error(_("need a HEAD to fixup"));
849 if (!(head_commit = lookup_commit_reference(&head)))
850 return error(_("could not read HEAD"));
851 if (!(head_message = get_commit_buffer(head_commit, NULL)))
852 return error(_("could not read HEAD's commit message"));
853
854 find_commit_subject(head_message, &body);
855 if (write_message(body, strlen(body),
856 rebase_path_fixup_msg(), 0)) {
857 unuse_commit_buffer(head_commit, head_message);
858 return error(_("cannot write '%s'"),
859 rebase_path_fixup_msg());
860 }
861
862 count = 2;
863 strbuf_addf(&buf, "%c ", comment_line_char);
864 strbuf_addf(&buf, _("This is a combination of %d commits."),
865 count);
866 strbuf_addf(&buf, "\n%c ", comment_line_char);
867 strbuf_addstr(&buf, _("This is the 1st commit message:"));
868 strbuf_addstr(&buf, "\n\n");
869 strbuf_addstr(&buf, body);
870
871 unuse_commit_buffer(head_commit, head_message);
872 }
873
874 if (!(message = get_commit_buffer(commit, NULL)))
875 return error(_("could not read commit message of %s"),
876 oid_to_hex(&commit->object.oid));
877 find_commit_subject(message, &body);
878
879 if (command == TODO_SQUASH) {
880 unlink(rebase_path_fixup_msg());
881 strbuf_addf(&buf, "\n%c ", comment_line_char);
882 strbuf_addf(&buf, _("This is the commit message #%d:"), count);
883 strbuf_addstr(&buf, "\n\n");
884 strbuf_addstr(&buf, body);
885 } else if (command == TODO_FIXUP) {
886 strbuf_addf(&buf, "\n%c ", comment_line_char);
887 strbuf_addf(&buf, _("The commit message #%d will be skipped:"),
888 count);
889 strbuf_addstr(&buf, "\n\n");
890 strbuf_add_commented_lines(&buf, body, strlen(body));
891 } else
892 return error(_("unknown command: %d"), command);
893 unuse_commit_buffer(commit, message);
894
895 res = write_message(buf.buf, buf.len, rebase_path_squash_msg(), 0);
896 strbuf_release(&buf);
897 return res;
898 }
899
900 static void flush_rewritten_pending(void) {
901 struct strbuf buf = STRBUF_INIT;
902 struct object_id newoid;
903 FILE *out;
904
905 if (strbuf_read_file(&buf, rebase_path_rewritten_pending(), (GIT_MAX_HEXSZ + 1) * 2) > 0 &&
906 !get_oid("HEAD", &newoid) &&
907 (out = fopen_or_warn(rebase_path_rewritten_list(), "a"))) {
908 char *bol = buf.buf, *eol;
909
910 while (*bol) {
911 eol = strchrnul(bol, '\n');
912 fprintf(out, "%.*s %s\n", (int)(eol - bol),
913 bol, oid_to_hex(&newoid));
914 if (!*eol)
915 break;
916 bol = eol + 1;
917 }
918 fclose(out);
919 unlink(rebase_path_rewritten_pending());
920 }
921 strbuf_release(&buf);
922 }
923
924 static void record_in_rewritten(struct object_id *oid,
925 enum todo_command next_command) {
926 FILE *out = fopen_or_warn(rebase_path_rewritten_pending(), "a");
927
928 if (!out)
929 return;
930
931 fprintf(out, "%s\n", oid_to_hex(oid));
932 fclose(out);
933
934 if (!is_fixup(next_command))
935 flush_rewritten_pending();
936 }
937
938 static int do_pick_commit(enum todo_command command, struct commit *commit,
939 struct replay_opts *opts, int final_fixup)
940 {
941 unsigned int flags = opts->edit ? EDIT_MSG : 0;
942 const char *msg_file = opts->edit ? NULL : git_path_merge_msg();
943 struct object_id head;
944 struct commit *base, *next, *parent;
945 const char *base_label, *next_label;
946 struct commit_message msg = { NULL, NULL, NULL, NULL };
947 struct strbuf msgbuf = STRBUF_INIT;
948 int res, unborn = 0, allow;
949
950 if (opts->no_commit) {
951 /*
952 * We do not intend to commit immediately. We just want to
953 * merge the differences in, so let's compute the tree
954 * that represents the "current" state for merge-recursive
955 * to work on.
956 */
957 if (write_cache_as_tree(head.hash, 0, NULL))
958 return error(_("your index file is unmerged."));
959 } else {
960 unborn = get_oid("HEAD", &head);
961 if (unborn)
962 oidcpy(&head, &empty_tree_oid);
963 if (index_differs_from(unborn ? EMPTY_TREE_SHA1_HEX : "HEAD",
964 NULL, 0))
965 return error_dirty_index(opts);
966 }
967 discard_cache();
968
969 if (!commit->parents)
970 parent = NULL;
971 else if (commit->parents->next) {
972 /* Reverting or cherry-picking a merge commit */
973 int cnt;
974 struct commit_list *p;
975
976 if (!opts->mainline)
977 return error(_("commit %s is a merge but no -m option was given."),
978 oid_to_hex(&commit->object.oid));
979
980 for (cnt = 1, p = commit->parents;
981 cnt != opts->mainline && p;
982 cnt++)
983 p = p->next;
984 if (cnt != opts->mainline || !p)
985 return error(_("commit %s does not have parent %d"),
986 oid_to_hex(&commit->object.oid), opts->mainline);
987 parent = p->item;
988 } else if (0 < opts->mainline)
989 return error(_("mainline was specified but commit %s is not a merge."),
990 oid_to_hex(&commit->object.oid));
991 else
992 parent = commit->parents->item;
993
994 if (get_message(commit, &msg) != 0)
995 return error(_("cannot get commit message for %s"),
996 oid_to_hex(&commit->object.oid));
997
998 if (opts->allow_ff && !is_fixup(command) &&
999 ((parent && !oidcmp(&parent->object.oid, &head)) ||
1000 (!parent && unborn))) {
1001 if (is_rebase_i(opts))
1002 write_author_script(msg.message);
1003 res = fast_forward_to(&commit->object.oid, &head, unborn,
1004 opts);
1005 if (res || command != TODO_REWORD)
1006 goto leave;
1007 flags |= EDIT_MSG | AMEND_MSG;
1008 if (command == TODO_REWORD)
1009 flags |= VERIFY_MSG;
1010 msg_file = NULL;
1011 goto fast_forward_edit;
1012 }
1013 if (parent && parse_commit(parent) < 0)
1014 /* TRANSLATORS: The first %s will be a "todo" command like
1015 "revert" or "pick", the second %s a SHA1. */
1016 return error(_("%s: cannot parse parent commit %s"),
1017 command_to_string(command),
1018 oid_to_hex(&parent->object.oid));
1019
1020 /*
1021 * "commit" is an existing commit. We would want to apply
1022 * the difference it introduces since its first parent "prev"
1023 * on top of the current HEAD if we are cherry-pick. Or the
1024 * reverse of it if we are revert.
1025 */
1026
1027 if (command == TODO_REVERT) {
1028 base = commit;
1029 base_label = msg.label;
1030 next = parent;
1031 next_label = msg.parent_label;
1032 strbuf_addstr(&msgbuf, "Revert \"");
1033 strbuf_addstr(&msgbuf, msg.subject);
1034 strbuf_addstr(&msgbuf, "\"\n\nThis reverts commit ");
1035 strbuf_addstr(&msgbuf, oid_to_hex(&commit->object.oid));
1036
1037 if (commit->parents && commit->parents->next) {
1038 strbuf_addstr(&msgbuf, ", reversing\nchanges made to ");
1039 strbuf_addstr(&msgbuf, oid_to_hex(&parent->object.oid));
1040 }
1041 strbuf_addstr(&msgbuf, ".\n");
1042 } else {
1043 const char *p;
1044
1045 base = parent;
1046 base_label = msg.parent_label;
1047 next = commit;
1048 next_label = msg.label;
1049
1050 /* Append the commit log message to msgbuf. */
1051 if (find_commit_subject(msg.message, &p))
1052 strbuf_addstr(&msgbuf, p);
1053
1054 if (opts->record_origin) {
1055 strbuf_complete_line(&msgbuf);
1056 if (!has_conforming_footer(&msgbuf, NULL, 0))
1057 strbuf_addch(&msgbuf, '\n');
1058 strbuf_addstr(&msgbuf, cherry_picked_prefix);
1059 strbuf_addstr(&msgbuf, oid_to_hex(&commit->object.oid));
1060 strbuf_addstr(&msgbuf, ")\n");
1061 }
1062 }
1063
1064 if (command == TODO_REWORD)
1065 flags |= EDIT_MSG | VERIFY_MSG;
1066 else if (is_fixup(command)) {
1067 if (update_squash_messages(command, commit, opts))
1068 return -1;
1069 flags |= AMEND_MSG;
1070 if (!final_fixup)
1071 msg_file = rebase_path_squash_msg();
1072 else if (file_exists(rebase_path_fixup_msg())) {
1073 flags |= CLEANUP_MSG;
1074 msg_file = rebase_path_fixup_msg();
1075 } else {
1076 const char *dest = git_path_squash_msg();
1077 unlink(dest);
1078 if (copy_file(dest, rebase_path_squash_msg(), 0666))
1079 return error(_("could not rename '%s' to '%s'"),
1080 rebase_path_squash_msg(), dest);
1081 unlink(git_path_merge_msg());
1082 msg_file = dest;
1083 flags |= EDIT_MSG;
1084 }
1085 }
1086
1087 if (is_rebase_i(opts) && write_author_script(msg.message) < 0)
1088 res = -1;
1089 else if (!opts->strategy || !strcmp(opts->strategy, "recursive") || command == TODO_REVERT) {
1090 res = do_recursive_merge(base, next, base_label, next_label,
1091 &head, &msgbuf, opts);
1092 if (res < 0)
1093 return res;
1094 res |= write_message(msgbuf.buf, msgbuf.len,
1095 git_path_merge_msg(), 0);
1096 } else {
1097 struct commit_list *common = NULL;
1098 struct commit_list *remotes = NULL;
1099
1100 res = write_message(msgbuf.buf, msgbuf.len,
1101 git_path_merge_msg(), 0);
1102
1103 commit_list_insert(base, &common);
1104 commit_list_insert(next, &remotes);
1105 res |= try_merge_command(opts->strategy,
1106 opts->xopts_nr, (const char **)opts->xopts,
1107 common, oid_to_hex(&head), remotes);
1108 free_commit_list(common);
1109 free_commit_list(remotes);
1110 }
1111 strbuf_release(&msgbuf);
1112
1113 /*
1114 * If the merge was clean or if it failed due to conflict, we write
1115 * CHERRY_PICK_HEAD for the subsequent invocation of commit to use.
1116 * However, if the merge did not even start, then we don't want to
1117 * write it at all.
1118 */
1119 if (command == TODO_PICK && !opts->no_commit && (res == 0 || res == 1) &&
1120 update_ref(NULL, "CHERRY_PICK_HEAD", &commit->object.oid, NULL,
1121 REF_NO_DEREF, UPDATE_REFS_MSG_ON_ERR))
1122 res = -1;
1123 if (command == TODO_REVERT && ((opts->no_commit && res == 0) || res == 1) &&
1124 update_ref(NULL, "REVERT_HEAD", &commit->object.oid, NULL,
1125 REF_NO_DEREF, UPDATE_REFS_MSG_ON_ERR))
1126 res = -1;
1127
1128 if (res) {
1129 error(command == TODO_REVERT
1130 ? _("could not revert %s... %s")
1131 : _("could not apply %s... %s"),
1132 short_commit_name(commit), msg.subject);
1133 print_advice(res == 1, opts);
1134 rerere(opts->allow_rerere_auto);
1135 goto leave;
1136 }
1137
1138 allow = allow_empty(opts, commit);
1139 if (allow < 0) {
1140 res = allow;
1141 goto leave;
1142 } else if (allow)
1143 flags |= ALLOW_EMPTY;
1144 if (!opts->no_commit)
1145 fast_forward_edit:
1146 res = run_git_commit(msg_file, opts, flags);
1147
1148 if (!res && final_fixup) {
1149 unlink(rebase_path_fixup_msg());
1150 unlink(rebase_path_squash_msg());
1151 }
1152
1153 leave:
1154 free_message(commit, &msg);
1155 update_abort_safety_file();
1156
1157 return res;
1158 }
1159
1160 static int prepare_revs(struct replay_opts *opts)
1161 {
1162 /*
1163 * picking (but not reverting) ranges (but not individual revisions)
1164 * should be done in reverse
1165 */
1166 if (opts->action == REPLAY_PICK && !opts->revs->no_walk)
1167 opts->revs->reverse ^= 1;
1168
1169 if (prepare_revision_walk(opts->revs))
1170 return error(_("revision walk setup failed"));
1171
1172 if (!opts->revs->commits)
1173 return error(_("empty commit set passed"));
1174 return 0;
1175 }
1176
1177 static int read_and_refresh_cache(struct replay_opts *opts)
1178 {
1179 static struct lock_file index_lock;
1180 int index_fd = hold_locked_index(&index_lock, 0);
1181 if (read_index_preload(&the_index, NULL) < 0) {
1182 rollback_lock_file(&index_lock);
1183 return error(_("git %s: failed to read the index"),
1184 _(action_name(opts)));
1185 }
1186 refresh_index(&the_index, REFRESH_QUIET|REFRESH_UNMERGED, NULL, NULL, NULL);
1187 if (the_index.cache_changed && index_fd >= 0) {
1188 if (write_locked_index(&the_index, &index_lock, COMMIT_LOCK)) {
1189 return error(_("git %s: failed to refresh the index"),
1190 _(action_name(opts)));
1191 }
1192 }
1193 rollback_lock_file(&index_lock);
1194 return 0;
1195 }
1196
1197 struct todo_item {
1198 enum todo_command command;
1199 struct commit *commit;
1200 const char *arg;
1201 int arg_len;
1202 size_t offset_in_buf;
1203 };
1204
1205 struct todo_list {
1206 struct strbuf buf;
1207 struct todo_item *items;
1208 int nr, alloc, current;
1209 int done_nr, total_nr;
1210 struct stat_data stat;
1211 };
1212
1213 #define TODO_LIST_INIT { STRBUF_INIT }
1214
1215 static void todo_list_release(struct todo_list *todo_list)
1216 {
1217 strbuf_release(&todo_list->buf);
1218 FREE_AND_NULL(todo_list->items);
1219 todo_list->nr = todo_list->alloc = 0;
1220 }
1221
1222 static struct todo_item *append_new_todo(struct todo_list *todo_list)
1223 {
1224 ALLOC_GROW(todo_list->items, todo_list->nr + 1, todo_list->alloc);
1225 return todo_list->items + todo_list->nr++;
1226 }
1227
1228 static int parse_insn_line(struct todo_item *item, const char *bol, char *eol)
1229 {
1230 struct object_id commit_oid;
1231 char *end_of_object_name;
1232 int i, saved, status, padding;
1233
1234 /* left-trim */
1235 bol += strspn(bol, " \t");
1236
1237 if (bol == eol || *bol == '\r' || *bol == comment_line_char) {
1238 item->command = TODO_COMMENT;
1239 item->commit = NULL;
1240 item->arg = bol;
1241 item->arg_len = eol - bol;
1242 return 0;
1243 }
1244
1245 for (i = 0; i < TODO_COMMENT; i++)
1246 if (skip_prefix(bol, todo_command_info[i].str, &bol)) {
1247 item->command = i;
1248 break;
1249 } else if (bol[1] == ' ' && *bol == todo_command_info[i].c) {
1250 bol++;
1251 item->command = i;
1252 break;
1253 }
1254 if (i >= TODO_COMMENT)
1255 return -1;
1256
1257 if (item->command == TODO_NOOP) {
1258 item->commit = NULL;
1259 item->arg = bol;
1260 item->arg_len = eol - bol;
1261 return 0;
1262 }
1263
1264 /* Eat up extra spaces/ tabs before object name */
1265 padding = strspn(bol, " \t");
1266 if (!padding)
1267 return -1;
1268 bol += padding;
1269
1270 if (item->command == TODO_EXEC) {
1271 item->arg = bol;
1272 item->arg_len = (int)(eol - bol);
1273 return 0;
1274 }
1275
1276 end_of_object_name = (char *) bol + strcspn(bol, " \t\n");
1277 saved = *end_of_object_name;
1278 *end_of_object_name = '\0';
1279 status = get_oid(bol, &commit_oid);
1280 *end_of_object_name = saved;
1281
1282 item->arg = end_of_object_name + strspn(end_of_object_name, " \t");
1283 item->arg_len = (int)(eol - item->arg);
1284
1285 if (status < 0)
1286 return -1;
1287
1288 item->commit = lookup_commit_reference(&commit_oid);
1289 return !item->commit;
1290 }
1291
1292 static int parse_insn_buffer(char *buf, struct todo_list *todo_list)
1293 {
1294 struct todo_item *item;
1295 char *p = buf, *next_p;
1296 int i, res = 0, fixup_okay = file_exists(rebase_path_done());
1297
1298 for (i = 1; *p; i++, p = next_p) {
1299 char *eol = strchrnul(p, '\n');
1300
1301 next_p = *eol ? eol + 1 /* skip LF */ : eol;
1302
1303 if (p != eol && eol[-1] == '\r')
1304 eol--; /* strip Carriage Return */
1305
1306 item = append_new_todo(todo_list);
1307 item->offset_in_buf = p - todo_list->buf.buf;
1308 if (parse_insn_line(item, p, eol)) {
1309 res = error(_("invalid line %d: %.*s"),
1310 i, (int)(eol - p), p);
1311 item->command = TODO_NOOP;
1312 }
1313
1314 if (fixup_okay)
1315 ; /* do nothing */
1316 else if (is_fixup(item->command))
1317 return error(_("cannot '%s' without a previous commit"),
1318 command_to_string(item->command));
1319 else if (!is_noop(item->command))
1320 fixup_okay = 1;
1321 }
1322
1323 return res;
1324 }
1325
1326 static int count_commands(struct todo_list *todo_list)
1327 {
1328 int count = 0, i;
1329
1330 for (i = 0; i < todo_list->nr; i++)
1331 if (todo_list->items[i].command != TODO_COMMENT)
1332 count++;
1333
1334 return count;
1335 }
1336
1337 static int read_populate_todo(struct todo_list *todo_list,
1338 struct replay_opts *opts)
1339 {
1340 struct stat st;
1341 const char *todo_file = get_todo_path(opts);
1342 int fd, res;
1343
1344 strbuf_reset(&todo_list->buf);
1345 fd = open(todo_file, O_RDONLY);
1346 if (fd < 0)
1347 return error_errno(_("could not open '%s'"), todo_file);
1348 if (strbuf_read(&todo_list->buf, fd, 0) < 0) {
1349 close(fd);
1350 return error(_("could not read '%s'."), todo_file);
1351 }
1352 close(fd);
1353
1354 res = stat(todo_file, &st);
1355 if (res)
1356 return error(_("could not stat '%s'"), todo_file);
1357 fill_stat_data(&todo_list->stat, &st);
1358
1359 res = parse_insn_buffer(todo_list->buf.buf, todo_list);
1360 if (res) {
1361 if (is_rebase_i(opts))
1362 return error(_("please fix this using "
1363 "'git rebase --edit-todo'."));
1364 return error(_("unusable instruction sheet: '%s'"), todo_file);
1365 }
1366
1367 if (!todo_list->nr &&
1368 (!is_rebase_i(opts) || !file_exists(rebase_path_done())))
1369 return error(_("no commits parsed."));
1370
1371 if (!is_rebase_i(opts)) {
1372 enum todo_command valid =
1373 opts->action == REPLAY_PICK ? TODO_PICK : TODO_REVERT;
1374 int i;
1375
1376 for (i = 0; i < todo_list->nr; i++)
1377 if (valid == todo_list->items[i].command)
1378 continue;
1379 else if (valid == TODO_PICK)
1380 return error(_("cannot cherry-pick during a revert."));
1381 else
1382 return error(_("cannot revert during a cherry-pick."));
1383 }
1384
1385 if (is_rebase_i(opts)) {
1386 struct todo_list done = TODO_LIST_INIT;
1387 FILE *f = fopen_or_warn(rebase_path_msgtotal(), "w");
1388
1389 if (strbuf_read_file(&done.buf, rebase_path_done(), 0) > 0 &&
1390 !parse_insn_buffer(done.buf.buf, &done))
1391 todo_list->done_nr = count_commands(&done);
1392 else
1393 todo_list->done_nr = 0;
1394
1395 todo_list->total_nr = todo_list->done_nr
1396 + count_commands(todo_list);
1397 todo_list_release(&done);
1398
1399 if (f) {
1400 fprintf(f, "%d\n", todo_list->total_nr);
1401 fclose(f);
1402 }
1403 }
1404
1405 return 0;
1406 }
1407
1408 static int git_config_string_dup(char **dest,
1409 const char *var, const char *value)
1410 {
1411 if (!value)
1412 return config_error_nonbool(var);
1413 free(*dest);
1414 *dest = xstrdup(value);
1415 return 0;
1416 }
1417
1418 static int populate_opts_cb(const char *key, const char *value, void *data)
1419 {
1420 struct replay_opts *opts = data;
1421 int error_flag = 1;
1422
1423 if (!value)
1424 error_flag = 0;
1425 else if (!strcmp(key, "options.no-commit"))
1426 opts->no_commit = git_config_bool_or_int(key, value, &error_flag);
1427 else if (!strcmp(key, "options.edit"))
1428 opts->edit = git_config_bool_or_int(key, value, &error_flag);
1429 else if (!strcmp(key, "options.signoff"))
1430 opts->signoff = git_config_bool_or_int(key, value, &error_flag);
1431 else if (!strcmp(key, "options.record-origin"))
1432 opts->record_origin = git_config_bool_or_int(key, value, &error_flag);
1433 else if (!strcmp(key, "options.allow-ff"))
1434 opts->allow_ff = git_config_bool_or_int(key, value, &error_flag);
1435 else if (!strcmp(key, "options.mainline"))
1436 opts->mainline = git_config_int(key, value);
1437 else if (!strcmp(key, "options.strategy"))
1438 git_config_string_dup(&opts->strategy, key, value);
1439 else if (!strcmp(key, "options.gpg-sign"))
1440 git_config_string_dup(&opts->gpg_sign, key, value);
1441 else if (!strcmp(key, "options.strategy-option")) {
1442 ALLOC_GROW(opts->xopts, opts->xopts_nr + 1, opts->xopts_alloc);
1443 opts->xopts[opts->xopts_nr++] = xstrdup(value);
1444 } else if (!strcmp(key, "options.allow-rerere-auto"))
1445 opts->allow_rerere_auto =
1446 git_config_bool_or_int(key, value, &error_flag) ?
1447 RERERE_AUTOUPDATE : RERERE_NOAUTOUPDATE;
1448 else
1449 return error(_("invalid key: %s"), key);
1450
1451 if (!error_flag)
1452 return error(_("invalid value for %s: %s"), key, value);
1453
1454 return 0;
1455 }
1456
1457 static void read_strategy_opts(struct replay_opts *opts, struct strbuf *buf)
1458 {
1459 int i;
1460
1461 strbuf_reset(buf);
1462 if (!read_oneliner(buf, rebase_path_strategy(), 0))
1463 return;
1464 opts->strategy = strbuf_detach(buf, NULL);
1465 if (!read_oneliner(buf, rebase_path_strategy_opts(), 0))
1466 return;
1467
1468 opts->xopts_nr = split_cmdline(buf->buf, (const char ***)&opts->xopts);
1469 for (i = 0; i < opts->xopts_nr; i++) {
1470 const char *arg = opts->xopts[i];
1471
1472 skip_prefix(arg, "--", &arg);
1473 opts->xopts[i] = xstrdup(arg);
1474 }
1475 }
1476
1477 static int read_populate_opts(struct replay_opts *opts)
1478 {
1479 if (is_rebase_i(opts)) {
1480 struct strbuf buf = STRBUF_INIT;
1481
1482 if (read_oneliner(&buf, rebase_path_gpg_sign_opt(), 1)) {
1483 if (!starts_with(buf.buf, "-S"))
1484 strbuf_reset(&buf);
1485 else {
1486 free(opts->gpg_sign);
1487 opts->gpg_sign = xstrdup(buf.buf + 2);
1488 }
1489 strbuf_reset(&buf);
1490 }
1491
1492 if (read_oneliner(&buf, rebase_path_allow_rerere_autoupdate(), 1)) {
1493 if (!strcmp(buf.buf, "--rerere-autoupdate"))
1494 opts->allow_rerere_auto = RERERE_AUTOUPDATE;
1495 else if (!strcmp(buf.buf, "--no-rerere-autoupdate"))
1496 opts->allow_rerere_auto = RERERE_NOAUTOUPDATE;
1497 strbuf_reset(&buf);
1498 }
1499
1500 if (file_exists(rebase_path_verbose()))
1501 opts->verbose = 1;
1502
1503 read_strategy_opts(opts, &buf);
1504 strbuf_release(&buf);
1505
1506 return 0;
1507 }
1508
1509 if (!file_exists(git_path_opts_file()))
1510 return 0;
1511 /*
1512 * The function git_parse_source(), called from git_config_from_file(),
1513 * may die() in case of a syntactically incorrect file. We do not care
1514 * about this case, though, because we wrote that file ourselves, so we
1515 * are pretty certain that it is syntactically correct.
1516 */
1517 if (git_config_from_file(populate_opts_cb, git_path_opts_file(), opts) < 0)
1518 return error(_("malformed options sheet: '%s'"),
1519 git_path_opts_file());
1520 return 0;
1521 }
1522
1523 static int walk_revs_populate_todo(struct todo_list *todo_list,
1524 struct replay_opts *opts)
1525 {
1526 enum todo_command command = opts->action == REPLAY_PICK ?
1527 TODO_PICK : TODO_REVERT;
1528 const char *command_string = todo_command_info[command].str;
1529 struct commit *commit;
1530
1531 if (prepare_revs(opts))
1532 return -1;
1533
1534 while ((commit = get_revision(opts->revs))) {
1535 struct todo_item *item = append_new_todo(todo_list);
1536 const char *commit_buffer = get_commit_buffer(commit, NULL);
1537 const char *subject;
1538 int subject_len;
1539
1540 item->command = command;
1541 item->commit = commit;
1542 item->arg = NULL;
1543 item->arg_len = 0;
1544 item->offset_in_buf = todo_list->buf.len;
1545 subject_len = find_commit_subject(commit_buffer, &subject);
1546 strbuf_addf(&todo_list->buf, "%s %s %.*s\n", command_string,
1547 short_commit_name(commit), subject_len, subject);
1548 unuse_commit_buffer(commit, commit_buffer);
1549 }
1550 return 0;
1551 }
1552
1553 static int create_seq_dir(void)
1554 {
1555 if (file_exists(git_path_seq_dir())) {
1556 error(_("a cherry-pick or revert is already in progress"));
1557 advise(_("try \"git cherry-pick (--continue | --quit | --abort)\""));
1558 return -1;
1559 } else if (mkdir(git_path_seq_dir(), 0777) < 0)
1560 return error_errno(_("could not create sequencer directory '%s'"),
1561 git_path_seq_dir());
1562 return 0;
1563 }
1564
1565 static int save_head(const char *head)
1566 {
1567 static struct lock_file head_lock;
1568 struct strbuf buf = STRBUF_INIT;
1569 int fd;
1570 ssize_t written;
1571
1572 fd = hold_lock_file_for_update(&head_lock, git_path_head_file(), 0);
1573 if (fd < 0) {
1574 rollback_lock_file(&head_lock);
1575 return error_errno(_("could not lock HEAD"));
1576 }
1577 strbuf_addf(&buf, "%s\n", head);
1578 written = write_in_full(fd, buf.buf, buf.len);
1579 strbuf_release(&buf);
1580 if (written < 0) {
1581 rollback_lock_file(&head_lock);
1582 return error_errno(_("could not write to '%s'"),
1583 git_path_head_file());
1584 }
1585 if (commit_lock_file(&head_lock) < 0) {
1586 rollback_lock_file(&head_lock);
1587 return error(_("failed to finalize '%s'."), git_path_head_file());
1588 }
1589 return 0;
1590 }
1591
1592 static int rollback_is_safe(void)
1593 {
1594 struct strbuf sb = STRBUF_INIT;
1595 struct object_id expected_head, actual_head;
1596
1597 if (strbuf_read_file(&sb, git_path_abort_safety_file(), 0) >= 0) {
1598 strbuf_trim(&sb);
1599 if (get_oid_hex(sb.buf, &expected_head)) {
1600 strbuf_release(&sb);
1601 die(_("could not parse %s"), git_path_abort_safety_file());
1602 }
1603 strbuf_release(&sb);
1604 }
1605 else if (errno == ENOENT)
1606 oidclr(&expected_head);
1607 else
1608 die_errno(_("could not read '%s'"), git_path_abort_safety_file());
1609
1610 if (get_oid("HEAD", &actual_head))
1611 oidclr(&actual_head);
1612
1613 return !oidcmp(&actual_head, &expected_head);
1614 }
1615
1616 static int reset_for_rollback(const struct object_id *oid)
1617 {
1618 const char *argv[4]; /* reset --merge <arg> + NULL */
1619
1620 argv[0] = "reset";
1621 argv[1] = "--merge";
1622 argv[2] = oid_to_hex(oid);
1623 argv[3] = NULL;
1624 return run_command_v_opt(argv, RUN_GIT_CMD);
1625 }
1626
1627 static int rollback_single_pick(void)
1628 {
1629 struct object_id head_oid;
1630
1631 if (!file_exists(git_path_cherry_pick_head()) &&
1632 !file_exists(git_path_revert_head()))
1633 return error(_("no cherry-pick or revert in progress"));
1634 if (read_ref_full("HEAD", 0, &head_oid, NULL))
1635 return error(_("cannot resolve HEAD"));
1636 if (is_null_oid(&head_oid))
1637 return error(_("cannot abort from a branch yet to be born"));
1638 return reset_for_rollback(&head_oid);
1639 }
1640
1641 int sequencer_rollback(struct replay_opts *opts)
1642 {
1643 FILE *f;
1644 struct object_id oid;
1645 struct strbuf buf = STRBUF_INIT;
1646 const char *p;
1647
1648 f = fopen(git_path_head_file(), "r");
1649 if (!f && errno == ENOENT) {
1650 /*
1651 * There is no multiple-cherry-pick in progress.
1652 * If CHERRY_PICK_HEAD or REVERT_HEAD indicates
1653 * a single-cherry-pick in progress, abort that.
1654 */
1655 return rollback_single_pick();
1656 }
1657 if (!f)
1658 return error_errno(_("cannot open '%s'"), git_path_head_file());
1659 if (strbuf_getline_lf(&buf, f)) {
1660 error(_("cannot read '%s': %s"), git_path_head_file(),
1661 ferror(f) ? strerror(errno) : _("unexpected end of file"));
1662 fclose(f);
1663 goto fail;
1664 }
1665 fclose(f);
1666 if (parse_oid_hex(buf.buf, &oid, &p) || *p != '\0') {
1667 error(_("stored pre-cherry-pick HEAD file '%s' is corrupt"),
1668 git_path_head_file());
1669 goto fail;
1670 }
1671 if (is_null_oid(&oid)) {
1672 error(_("cannot abort from a branch yet to be born"));
1673 goto fail;
1674 }
1675
1676 if (!rollback_is_safe()) {
1677 /* Do not error, just do not rollback */
1678 warning(_("You seem to have moved HEAD. "
1679 "Not rewinding, check your HEAD!"));
1680 } else
1681 if (reset_for_rollback(&oid))
1682 goto fail;
1683 strbuf_release(&buf);
1684 return sequencer_remove_state(opts);
1685 fail:
1686 strbuf_release(&buf);
1687 return -1;
1688 }
1689
1690 static int save_todo(struct todo_list *todo_list, struct replay_opts *opts)
1691 {
1692 static struct lock_file todo_lock;
1693 const char *todo_path = get_todo_path(opts);
1694 int next = todo_list->current, offset, fd;
1695
1696 /*
1697 * rebase -i writes "git-rebase-todo" without the currently executing
1698 * command, appending it to "done" instead.
1699 */
1700 if (is_rebase_i(opts))
1701 next++;
1702
1703 fd = hold_lock_file_for_update(&todo_lock, todo_path, 0);
1704 if (fd < 0)
1705 return error_errno(_("could not lock '%s'"), todo_path);
1706 offset = next < todo_list->nr ?
1707 todo_list->items[next].offset_in_buf : todo_list->buf.len;
1708 if (write_in_full(fd, todo_list->buf.buf + offset,
1709 todo_list->buf.len - offset) < 0)
1710 return error_errno(_("could not write to '%s'"), todo_path);
1711 if (commit_lock_file(&todo_lock) < 0)
1712 return error(_("failed to finalize '%s'."), todo_path);
1713
1714 if (is_rebase_i(opts)) {
1715 const char *done_path = rebase_path_done();
1716 int fd = open(done_path, O_CREAT | O_WRONLY | O_APPEND, 0666);
1717 int prev_offset = !next ? 0 :
1718 todo_list->items[next - 1].offset_in_buf;
1719
1720 if (fd >= 0 && offset > prev_offset &&
1721 write_in_full(fd, todo_list->buf.buf + prev_offset,
1722 offset - prev_offset) < 0) {
1723 close(fd);
1724 return error_errno(_("could not write to '%s'"),
1725 done_path);
1726 }
1727 if (fd >= 0)
1728 close(fd);
1729 }
1730 return 0;
1731 }
1732
1733 static int save_opts(struct replay_opts *opts)
1734 {
1735 const char *opts_file = git_path_opts_file();
1736 int res = 0;
1737
1738 if (opts->no_commit)
1739 res |= git_config_set_in_file_gently(opts_file, "options.no-commit", "true");
1740 if (opts->edit)
1741 res |= git_config_set_in_file_gently(opts_file, "options.edit", "true");
1742 if (opts->signoff)
1743 res |= git_config_set_in_file_gently(opts_file, "options.signoff", "true");
1744 if (opts->record_origin)
1745 res |= git_config_set_in_file_gently(opts_file, "options.record-origin", "true");
1746 if (opts->allow_ff)
1747 res |= git_config_set_in_file_gently(opts_file, "options.allow-ff", "true");
1748 if (opts->mainline) {
1749 struct strbuf buf = STRBUF_INIT;
1750 strbuf_addf(&buf, "%d", opts->mainline);
1751 res |= git_config_set_in_file_gently(opts_file, "options.mainline", buf.buf);
1752 strbuf_release(&buf);
1753 }
1754 if (opts->strategy)
1755 res |= git_config_set_in_file_gently(opts_file, "options.strategy", opts->strategy);
1756 if (opts->gpg_sign)
1757 res |= git_config_set_in_file_gently(opts_file, "options.gpg-sign", opts->gpg_sign);
1758 if (opts->xopts) {
1759 int i;
1760 for (i = 0; i < opts->xopts_nr; i++)
1761 res |= git_config_set_multivar_in_file_gently(opts_file,
1762 "options.strategy-option",
1763 opts->xopts[i], "^$", 0);
1764 }
1765 if (opts->allow_rerere_auto)
1766 res |= git_config_set_in_file_gently(opts_file, "options.allow-rerere-auto",
1767 opts->allow_rerere_auto == RERERE_AUTOUPDATE ?
1768 "true" : "false");
1769 return res;
1770 }
1771
1772 static int make_patch(struct commit *commit, struct replay_opts *opts)
1773 {
1774 struct strbuf buf = STRBUF_INIT;
1775 struct rev_info log_tree_opt;
1776 const char *subject, *p;
1777 int res = 0;
1778
1779 p = short_commit_name(commit);
1780 if (write_message(p, strlen(p), rebase_path_stopped_sha(), 1) < 0)
1781 return -1;
1782
1783 strbuf_addf(&buf, "%s/patch", get_dir(opts));
1784 memset(&log_tree_opt, 0, sizeof(log_tree_opt));
1785 init_revisions(&log_tree_opt, NULL);
1786 log_tree_opt.abbrev = 0;
1787 log_tree_opt.diff = 1;
1788 log_tree_opt.diffopt.output_format = DIFF_FORMAT_PATCH;
1789 log_tree_opt.disable_stdin = 1;
1790 log_tree_opt.no_commit_id = 1;
1791 log_tree_opt.diffopt.file = fopen(buf.buf, "w");
1792 log_tree_opt.diffopt.use_color = GIT_COLOR_NEVER;
1793 if (!log_tree_opt.diffopt.file)
1794 res |= error_errno(_("could not open '%s'"), buf.buf);
1795 else {
1796 res |= log_tree_commit(&log_tree_opt, commit);
1797 fclose(log_tree_opt.diffopt.file);
1798 }
1799 strbuf_reset(&buf);
1800
1801 strbuf_addf(&buf, "%s/message", get_dir(opts));
1802 if (!file_exists(buf.buf)) {
1803 const char *commit_buffer = get_commit_buffer(commit, NULL);
1804 find_commit_subject(commit_buffer, &subject);
1805 res |= write_message(subject, strlen(subject), buf.buf, 1);
1806 unuse_commit_buffer(commit, commit_buffer);
1807 }
1808 strbuf_release(&buf);
1809
1810 return res;
1811 }
1812
1813 static int intend_to_amend(void)
1814 {
1815 struct object_id head;
1816 char *p;
1817
1818 if (get_oid("HEAD", &head))
1819 return error(_("cannot read HEAD"));
1820
1821 p = oid_to_hex(&head);
1822 return write_message(p, strlen(p), rebase_path_amend(), 1);
1823 }
1824
1825 static int error_with_patch(struct commit *commit,
1826 const char *subject, int subject_len,
1827 struct replay_opts *opts, int exit_code, int to_amend)
1828 {
1829 if (make_patch(commit, opts))
1830 return -1;
1831
1832 if (to_amend) {
1833 if (intend_to_amend())
1834 return -1;
1835
1836 fprintf(stderr, "You can amend the commit now, with\n"
1837 "\n"
1838 " git commit --amend %s\n"
1839 "\n"
1840 "Once you are satisfied with your changes, run\n"
1841 "\n"
1842 " git rebase --continue\n", gpg_sign_opt_quoted(opts));
1843 } else if (exit_code)
1844 fprintf(stderr, "Could not apply %s... %.*s\n",
1845 short_commit_name(commit), subject_len, subject);
1846
1847 return exit_code;
1848 }
1849
1850 static int error_failed_squash(struct commit *commit,
1851 struct replay_opts *opts, int subject_len, const char *subject)
1852 {
1853 if (rename(rebase_path_squash_msg(), rebase_path_message()))
1854 return error(_("could not rename '%s' to '%s'"),
1855 rebase_path_squash_msg(), rebase_path_message());
1856 unlink(rebase_path_fixup_msg());
1857 unlink(git_path_merge_msg());
1858 if (copy_file(git_path_merge_msg(), rebase_path_message(), 0666))
1859 return error(_("could not copy '%s' to '%s'"),
1860 rebase_path_message(), git_path_merge_msg());
1861 return error_with_patch(commit, subject, subject_len, opts, 1, 0);
1862 }
1863
1864 static int do_exec(const char *command_line)
1865 {
1866 struct argv_array child_env = ARGV_ARRAY_INIT;
1867 const char *child_argv[] = { NULL, NULL };
1868 int dirty, status;
1869
1870 fprintf(stderr, "Executing: %s\n", command_line);
1871 child_argv[0] = command_line;
1872 argv_array_pushf(&child_env, "GIT_DIR=%s", absolute_path(get_git_dir()));
1873 status = run_command_v_opt_cd_env(child_argv, RUN_USING_SHELL, NULL,
1874 child_env.argv);
1875
1876 /* force re-reading of the cache */
1877 if (discard_cache() < 0 || read_cache() < 0)
1878 return error(_("could not read index"));
1879
1880 dirty = require_clean_work_tree("rebase", NULL, 1, 1);
1881
1882 if (status) {
1883 warning(_("execution failed: %s\n%s"
1884 "You can fix the problem, and then run\n"
1885 "\n"
1886 " git rebase --continue\n"
1887 "\n"),
1888 command_line,
1889 dirty ? N_("and made changes to the index and/or the "
1890 "working tree\n") : "");
1891 if (status == 127)
1892 /* command not found */
1893 status = 1;
1894 } else if (dirty) {
1895 warning(_("execution succeeded: %s\nbut "
1896 "left changes to the index and/or the working tree\n"
1897 "Commit or stash your changes, and then run\n"
1898 "\n"
1899 " git rebase --continue\n"
1900 "\n"), command_line);
1901 status = 1;
1902 }
1903
1904 argv_array_clear(&child_env);
1905
1906 return status;
1907 }
1908
1909 static int is_final_fixup(struct todo_list *todo_list)
1910 {
1911 int i = todo_list->current;
1912
1913 if (!is_fixup(todo_list->items[i].command))
1914 return 0;
1915
1916 while (++i < todo_list->nr)
1917 if (is_fixup(todo_list->items[i].command))
1918 return 0;
1919 else if (!is_noop(todo_list->items[i].command))
1920 break;
1921 return 1;
1922 }
1923
1924 static enum todo_command peek_command(struct todo_list *todo_list, int offset)
1925 {
1926 int i;
1927
1928 for (i = todo_list->current + offset; i < todo_list->nr; i++)
1929 if (!is_noop(todo_list->items[i].command))
1930 return todo_list->items[i].command;
1931
1932 return -1;
1933 }
1934
1935 static int apply_autostash(struct replay_opts *opts)
1936 {
1937 struct strbuf stash_sha1 = STRBUF_INIT;
1938 struct child_process child = CHILD_PROCESS_INIT;
1939 int ret = 0;
1940
1941 if (!read_oneliner(&stash_sha1, rebase_path_autostash(), 1)) {
1942 strbuf_release(&stash_sha1);
1943 return 0;
1944 }
1945 strbuf_trim(&stash_sha1);
1946
1947 child.git_cmd = 1;
1948 child.no_stdout = 1;
1949 child.no_stderr = 1;
1950 argv_array_push(&child.args, "stash");
1951 argv_array_push(&child.args, "apply");
1952 argv_array_push(&child.args, stash_sha1.buf);
1953 if (!run_command(&child))
1954 fprintf(stderr, _("Applied autostash.\n"));
1955 else {
1956 struct child_process store = CHILD_PROCESS_INIT;
1957
1958 store.git_cmd = 1;
1959 argv_array_push(&store.args, "stash");
1960 argv_array_push(&store.args, "store");
1961 argv_array_push(&store.args, "-m");
1962 argv_array_push(&store.args, "autostash");
1963 argv_array_push(&store.args, "-q");
1964 argv_array_push(&store.args, stash_sha1.buf);
1965 if (run_command(&store))
1966 ret = error(_("cannot store %s"), stash_sha1.buf);
1967 else
1968 fprintf(stderr,
1969 _("Applying autostash resulted in conflicts.\n"
1970 "Your changes are safe in the stash.\n"
1971 "You can run \"git stash pop\" or"
1972 " \"git stash drop\" at any time.\n"));
1973 }
1974
1975 strbuf_release(&stash_sha1);
1976 return ret;
1977 }
1978
1979 static const char *reflog_message(struct replay_opts *opts,
1980 const char *sub_action, const char *fmt, ...)
1981 {
1982 va_list ap;
1983 static struct strbuf buf = STRBUF_INIT;
1984
1985 va_start(ap, fmt);
1986 strbuf_reset(&buf);
1987 strbuf_addstr(&buf, action_name(opts));
1988 if (sub_action)
1989 strbuf_addf(&buf, " (%s)", sub_action);
1990 if (fmt) {
1991 strbuf_addstr(&buf, ": ");
1992 strbuf_vaddf(&buf, fmt, ap);
1993 }
1994 va_end(ap);
1995
1996 return buf.buf;
1997 }
1998
1999 static int pick_commits(struct todo_list *todo_list, struct replay_opts *opts)
2000 {
2001 int res = 0;
2002
2003 setenv(GIT_REFLOG_ACTION, action_name(opts), 0);
2004 if (opts->allow_ff)
2005 assert(!(opts->signoff || opts->no_commit ||
2006 opts->record_origin || opts->edit));
2007 if (read_and_refresh_cache(opts))
2008 return -1;
2009
2010 while (todo_list->current < todo_list->nr) {
2011 struct todo_item *item = todo_list->items + todo_list->current;
2012 if (save_todo(todo_list, opts))
2013 return -1;
2014 if (is_rebase_i(opts)) {
2015 if (item->command != TODO_COMMENT) {
2016 FILE *f = fopen(rebase_path_msgnum(), "w");
2017
2018 todo_list->done_nr++;
2019
2020 if (f) {
2021 fprintf(f, "%d\n", todo_list->done_nr);
2022 fclose(f);
2023 }
2024 fprintf(stderr, "Rebasing (%d/%d)%s",
2025 todo_list->done_nr,
2026 todo_list->total_nr,
2027 opts->verbose ? "\n" : "\r");
2028 }
2029 unlink(rebase_path_message());
2030 unlink(rebase_path_author_script());
2031 unlink(rebase_path_stopped_sha());
2032 unlink(rebase_path_amend());
2033 }
2034 if (item->command <= TODO_SQUASH) {
2035 if (is_rebase_i(opts))
2036 setenv("GIT_REFLOG_ACTION", reflog_message(opts,
2037 command_to_string(item->command), NULL),
2038 1);
2039 res = do_pick_commit(item->command, item->commit,
2040 opts, is_final_fixup(todo_list));
2041 if (is_rebase_i(opts) && res < 0) {
2042 /* Reschedule */
2043 todo_list->current--;
2044 if (save_todo(todo_list, opts))
2045 return -1;
2046 }
2047 if (item->command == TODO_EDIT) {
2048 struct commit *commit = item->commit;
2049 if (!res)
2050 fprintf(stderr,
2051 _("Stopped at %s... %.*s\n"),
2052 short_commit_name(commit),
2053 item->arg_len, item->arg);
2054 return error_with_patch(commit,
2055 item->arg, item->arg_len, opts, res,
2056 !res);
2057 }
2058 if (is_rebase_i(opts) && !res)
2059 record_in_rewritten(&item->commit->object.oid,
2060 peek_command(todo_list, 1));
2061 if (res && is_fixup(item->command)) {
2062 if (res == 1)
2063 intend_to_amend();
2064 return error_failed_squash(item->commit, opts,
2065 item->arg_len, item->arg);
2066 } else if (res && is_rebase_i(opts))
2067 return res | error_with_patch(item->commit,
2068 item->arg, item->arg_len, opts, res,
2069 item->command == TODO_REWORD);
2070 } else if (item->command == TODO_EXEC) {
2071 char *end_of_arg = (char *)(item->arg + item->arg_len);
2072 int saved = *end_of_arg;
2073 struct stat st;
2074
2075 *end_of_arg = '\0';
2076 res = do_exec(item->arg);
2077 *end_of_arg = saved;
2078
2079 /* Reread the todo file if it has changed. */
2080 if (res)
2081 ; /* fall through */
2082 else if (stat(get_todo_path(opts), &st))
2083 res = error_errno(_("could not stat '%s'"),
2084 get_todo_path(opts));
2085 else if (match_stat_data(&todo_list->stat, &st)) {
2086 todo_list_release(todo_list);
2087 if (read_populate_todo(todo_list, opts))
2088 res = -1; /* message was printed */
2089 /* `current` will be incremented below */
2090 todo_list->current = -1;
2091 }
2092 } else if (!is_noop(item->command))
2093 return error(_("unknown command %d"), item->command);
2094
2095 todo_list->current++;
2096 if (res)
2097 return res;
2098 }
2099
2100 if (is_rebase_i(opts)) {
2101 struct strbuf head_ref = STRBUF_INIT, buf = STRBUF_INIT;
2102 struct stat st;
2103
2104 /* Stopped in the middle, as planned? */
2105 if (todo_list->current < todo_list->nr)
2106 return 0;
2107
2108 if (read_oneliner(&head_ref, rebase_path_head_name(), 0) &&
2109 starts_with(head_ref.buf, "refs/")) {
2110 const char *msg;
2111 struct object_id head, orig;
2112 int res;
2113
2114 if (get_oid("HEAD", &head)) {
2115 res = error(_("cannot read HEAD"));
2116 cleanup_head_ref:
2117 strbuf_release(&head_ref);
2118 strbuf_release(&buf);
2119 return res;
2120 }
2121 if (!read_oneliner(&buf, rebase_path_orig_head(), 0) ||
2122 get_oid_hex(buf.buf, &orig)) {
2123 res = error(_("could not read orig-head"));
2124 goto cleanup_head_ref;
2125 }
2126 strbuf_reset(&buf);
2127 if (!read_oneliner(&buf, rebase_path_onto(), 0)) {
2128 res = error(_("could not read 'onto'"));
2129 goto cleanup_head_ref;
2130 }
2131 msg = reflog_message(opts, "finish", "%s onto %s",
2132 head_ref.buf, buf.buf);
2133 if (update_ref(msg, head_ref.buf, &head, &orig,
2134 REF_NO_DEREF, UPDATE_REFS_MSG_ON_ERR)) {
2135 res = error(_("could not update %s"),
2136 head_ref.buf);
2137 goto cleanup_head_ref;
2138 }
2139 msg = reflog_message(opts, "finish", "returning to %s",
2140 head_ref.buf);
2141 if (create_symref("HEAD", head_ref.buf, msg)) {
2142 res = error(_("could not update HEAD to %s"),
2143 head_ref.buf);
2144 goto cleanup_head_ref;
2145 }
2146 strbuf_reset(&buf);
2147 }
2148
2149 if (opts->verbose) {
2150 struct rev_info log_tree_opt;
2151 struct object_id orig, head;
2152
2153 memset(&log_tree_opt, 0, sizeof(log_tree_opt));
2154 init_revisions(&log_tree_opt, NULL);
2155 log_tree_opt.diff = 1;
2156 log_tree_opt.diffopt.output_format =
2157 DIFF_FORMAT_DIFFSTAT;
2158 log_tree_opt.disable_stdin = 1;
2159
2160 if (read_oneliner(&buf, rebase_path_orig_head(), 0) &&
2161 !get_oid(buf.buf, &orig) &&
2162 !get_oid("HEAD", &head)) {
2163 diff_tree_oid(&orig, &head, "",
2164 &log_tree_opt.diffopt);
2165 log_tree_diff_flush(&log_tree_opt);
2166 }
2167 }
2168 flush_rewritten_pending();
2169 if (!stat(rebase_path_rewritten_list(), &st) &&
2170 st.st_size > 0) {
2171 struct child_process child = CHILD_PROCESS_INIT;
2172 const char *post_rewrite_hook =
2173 find_hook("post-rewrite");
2174
2175 child.in = open(rebase_path_rewritten_list(), O_RDONLY);
2176 child.git_cmd = 1;
2177 argv_array_push(&child.args, "notes");
2178 argv_array_push(&child.args, "copy");
2179 argv_array_push(&child.args, "--for-rewrite=rebase");
2180 /* we don't care if this copying failed */
2181 run_command(&child);
2182
2183 if (post_rewrite_hook) {
2184 struct child_process hook = CHILD_PROCESS_INIT;
2185
2186 hook.in = open(rebase_path_rewritten_list(),
2187 O_RDONLY);
2188 hook.stdout_to_stderr = 1;
2189 argv_array_push(&hook.args, post_rewrite_hook);
2190 argv_array_push(&hook.args, "rebase");
2191 /* we don't care if this hook failed */
2192 run_command(&hook);
2193 }
2194 }
2195 apply_autostash(opts);
2196
2197 fprintf(stderr, "Successfully rebased and updated %s.\n",
2198 head_ref.buf);
2199
2200 strbuf_release(&buf);
2201 strbuf_release(&head_ref);
2202 }
2203
2204 /*
2205 * Sequence of picks finished successfully; cleanup by
2206 * removing the .git/sequencer directory
2207 */
2208 return sequencer_remove_state(opts);
2209 }
2210
2211 static int continue_single_pick(void)
2212 {
2213 const char *argv[] = { "commit", NULL };
2214
2215 if (!file_exists(git_path_cherry_pick_head()) &&
2216 !file_exists(git_path_revert_head()))
2217 return error(_("no cherry-pick or revert in progress"));
2218 return run_command_v_opt(argv, RUN_GIT_CMD);
2219 }
2220
2221 static int commit_staged_changes(struct replay_opts *opts)
2222 {
2223 unsigned int flags = ALLOW_EMPTY | EDIT_MSG;
2224
2225 if (has_unstaged_changes(1))
2226 return error(_("cannot rebase: You have unstaged changes."));
2227 if (!has_uncommitted_changes(0)) {
2228 const char *cherry_pick_head = git_path_cherry_pick_head();
2229
2230 if (file_exists(cherry_pick_head) && unlink(cherry_pick_head))
2231 return error(_("could not remove CHERRY_PICK_HEAD"));
2232 return 0;
2233 }
2234
2235 if (file_exists(rebase_path_amend())) {
2236 struct strbuf rev = STRBUF_INIT;
2237 struct object_id head, to_amend;
2238
2239 if (get_oid("HEAD", &head))
2240 return error(_("cannot amend non-existing commit"));
2241 if (!read_oneliner(&rev, rebase_path_amend(), 0))
2242 return error(_("invalid file: '%s'"), rebase_path_amend());
2243 if (get_oid_hex(rev.buf, &to_amend))
2244 return error(_("invalid contents: '%s'"),
2245 rebase_path_amend());
2246 if (oidcmp(&head, &to_amend))
2247 return error(_("\nYou have uncommitted changes in your "
2248 "working tree. Please, commit them\n"
2249 "first and then run 'git rebase "
2250 "--continue' again."));
2251
2252 strbuf_release(&rev);
2253 flags |= AMEND_MSG;
2254 }
2255
2256 if (run_git_commit(rebase_path_message(), opts, flags))
2257 return error(_("could not commit staged changes."));
2258 unlink(rebase_path_amend());
2259 return 0;
2260 }
2261
2262 int sequencer_continue(struct replay_opts *opts)
2263 {
2264 struct todo_list todo_list = TODO_LIST_INIT;
2265 int res;
2266
2267 if (read_and_refresh_cache(opts))
2268 return -1;
2269
2270 if (is_rebase_i(opts)) {
2271 if (commit_staged_changes(opts))
2272 return -1;
2273 } else if (!file_exists(get_todo_path(opts)))
2274 return continue_single_pick();
2275 if (read_populate_opts(opts))
2276 return -1;
2277 if ((res = read_populate_todo(&todo_list, opts)))
2278 goto release_todo_list;
2279
2280 if (!is_rebase_i(opts)) {
2281 /* Verify that the conflict has been resolved */
2282 if (file_exists(git_path_cherry_pick_head()) ||
2283 file_exists(git_path_revert_head())) {
2284 res = continue_single_pick();
2285 if (res)
2286 goto release_todo_list;
2287 }
2288 if (index_differs_from("HEAD", NULL, 0)) {
2289 res = error_dirty_index(opts);
2290 goto release_todo_list;
2291 }
2292 todo_list.current++;
2293 } else if (file_exists(rebase_path_stopped_sha())) {
2294 struct strbuf buf = STRBUF_INIT;
2295 struct object_id oid;
2296
2297 if (read_oneliner(&buf, rebase_path_stopped_sha(), 1) &&
2298 !get_oid_committish(buf.buf, &oid))
2299 record_in_rewritten(&oid, peek_command(&todo_list, 0));
2300 strbuf_release(&buf);
2301 }
2302
2303 res = pick_commits(&todo_list, opts);
2304 release_todo_list:
2305 todo_list_release(&todo_list);
2306 return res;
2307 }
2308
2309 static int single_pick(struct commit *cmit, struct replay_opts *opts)
2310 {
2311 setenv(GIT_REFLOG_ACTION, action_name(opts), 0);
2312 return do_pick_commit(opts->action == REPLAY_PICK ?
2313 TODO_PICK : TODO_REVERT, cmit, opts, 0);
2314 }
2315
2316 int sequencer_pick_revisions(struct replay_opts *opts)
2317 {
2318 struct todo_list todo_list = TODO_LIST_INIT;
2319 struct object_id oid;
2320 int i, res;
2321
2322 assert(opts->revs);
2323 if (read_and_refresh_cache(opts))
2324 return -1;
2325
2326 for (i = 0; i < opts->revs->pending.nr; i++) {
2327 struct object_id oid;
2328 const char *name = opts->revs->pending.objects[i].name;
2329
2330 /* This happens when using --stdin. */
2331 if (!strlen(name))
2332 continue;
2333
2334 if (!get_oid(name, &oid)) {
2335 if (!lookup_commit_reference_gently(&oid, 1)) {
2336 enum object_type type = sha1_object_info(oid.hash, NULL);
2337 return error(_("%s: can't cherry-pick a %s"),
2338 name, typename(type));
2339 }
2340 } else
2341 return error(_("%s: bad revision"), name);
2342 }
2343
2344 /*
2345 * If we were called as "git cherry-pick <commit>", just
2346 * cherry-pick/revert it, set CHERRY_PICK_HEAD /
2347 * REVERT_HEAD, and don't touch the sequencer state.
2348 * This means it is possible to cherry-pick in the middle
2349 * of a cherry-pick sequence.
2350 */
2351 if (opts->revs->cmdline.nr == 1 &&
2352 opts->revs->cmdline.rev->whence == REV_CMD_REV &&
2353 opts->revs->no_walk &&
2354 !opts->revs->cmdline.rev->flags) {
2355 struct commit *cmit;
2356 if (prepare_revision_walk(opts->revs))
2357 return error(_("revision walk setup failed"));
2358 cmit = get_revision(opts->revs);
2359 if (!cmit || get_revision(opts->revs))
2360 return error("BUG: expected exactly one commit from walk");
2361 return single_pick(cmit, opts);
2362 }
2363
2364 /*
2365 * Start a new cherry-pick/ revert sequence; but
2366 * first, make sure that an existing one isn't in
2367 * progress
2368 */
2369
2370 if (walk_revs_populate_todo(&todo_list, opts) ||
2371 create_seq_dir() < 0)
2372 return -1;
2373 if (get_oid("HEAD", &oid) && (opts->action == REPLAY_REVERT))
2374 return error(_("can't revert as initial commit"));
2375 if (save_head(oid_to_hex(&oid)))
2376 return -1;
2377 if (save_opts(opts))
2378 return -1;
2379 update_abort_safety_file();
2380 res = pick_commits(&todo_list, opts);
2381 todo_list_release(&todo_list);
2382 return res;
2383 }
2384
2385 void append_signoff(struct strbuf *msgbuf, int ignore_footer, unsigned flag)
2386 {
2387 unsigned no_dup_sob = flag & APPEND_SIGNOFF_DEDUP;
2388 struct strbuf sob = STRBUF_INIT;
2389 int has_footer;
2390
2391 strbuf_addstr(&sob, sign_off_header);
2392 strbuf_addstr(&sob, fmt_name(getenv("GIT_COMMITTER_NAME"),
2393 getenv("GIT_COMMITTER_EMAIL")));
2394 strbuf_addch(&sob, '\n');
2395
2396 if (!ignore_footer)
2397 strbuf_complete_line(msgbuf);
2398
2399 /*
2400 * If the whole message buffer is equal to the sob, pretend that we
2401 * found a conforming footer with a matching sob
2402 */
2403 if (msgbuf->len - ignore_footer == sob.len &&
2404 !strncmp(msgbuf->buf, sob.buf, sob.len))
2405 has_footer = 3;
2406 else
2407 has_footer = has_conforming_footer(msgbuf, &sob, ignore_footer);
2408
2409 if (!has_footer) {
2410 const char *append_newlines = NULL;
2411 size_t len = msgbuf->len - ignore_footer;
2412
2413 if (!len) {
2414 /*
2415 * The buffer is completely empty. Leave foom for
2416 * the title and body to be filled in by the user.
2417 */
2418 append_newlines = "\n\n";
2419 } else if (len == 1) {
2420 /*
2421 * Buffer contains a single newline. Add another
2422 * so that we leave room for the title and body.
2423 */
2424 append_newlines = "\n";
2425 } else if (msgbuf->buf[len - 2] != '\n') {
2426 /*
2427 * Buffer ends with a single newline. Add another
2428 * so that there is an empty line between the message
2429 * body and the sob.
2430 */
2431 append_newlines = "\n";
2432 } /* else, the buffer already ends with two newlines. */
2433
2434 if (append_newlines)
2435 strbuf_splice(msgbuf, msgbuf->len - ignore_footer, 0,
2436 append_newlines, strlen(append_newlines));
2437 }
2438
2439 if (has_footer != 3 && (!no_dup_sob || has_footer != 2))
2440 strbuf_splice(msgbuf, msgbuf->len - ignore_footer, 0,
2441 sob.buf, sob.len);
2442
2443 strbuf_release(&sob);
2444 }
2445
2446 int sequencer_make_script(int keep_empty, FILE *out,
2447 int argc, const char **argv)
2448 {
2449 char *format = NULL;
2450 struct pretty_print_context pp = {0};
2451 struct strbuf buf = STRBUF_INIT;
2452 struct rev_info revs;
2453 struct commit *commit;
2454
2455 init_revisions(&revs, NULL);
2456 revs.verbose_header = 1;
2457 revs.max_parents = 1;
2458 revs.cherry_pick = 1;
2459 revs.limited = 1;
2460 revs.reverse = 1;
2461 revs.right_only = 1;
2462 revs.sort_order = REV_SORT_IN_GRAPH_ORDER;
2463 revs.topo_order = 1;
2464
2465 revs.pretty_given = 1;
2466 git_config_get_string("rebase.instructionFormat", &format);
2467 if (!format || !*format) {
2468 free(format);
2469 format = xstrdup("%s");
2470 }
2471 get_commit_format(format, &revs);
2472 free(format);
2473 pp.fmt = revs.commit_format;
2474 pp.output_encoding = get_log_output_encoding();
2475
2476 if (setup_revisions(argc, argv, &revs, NULL) > 1)
2477 return error(_("make_script: unhandled options"));
2478
2479 if (prepare_revision_walk(&revs) < 0)
2480 return error(_("make_script: error preparing revisions"));
2481
2482 while ((commit = get_revision(&revs))) {
2483 strbuf_reset(&buf);
2484 if (!keep_empty && is_original_commit_empty(commit))
2485 strbuf_addf(&buf, "%c ", comment_line_char);
2486 strbuf_addf(&buf, "pick %s ", oid_to_hex(&commit->object.oid));
2487 pretty_print_commit(&pp, commit, &buf);
2488 strbuf_addch(&buf, '\n');
2489 fputs(buf.buf, out);
2490 }
2491 strbuf_release(&buf);
2492 return 0;
2493 }
2494
2495
2496 int transform_todo_ids(int shorten_ids)
2497 {
2498 const char *todo_file = rebase_path_todo();
2499 struct todo_list todo_list = TODO_LIST_INIT;
2500 int fd, res, i;
2501 FILE *out;
2502
2503 strbuf_reset(&todo_list.buf);
2504 fd = open(todo_file, O_RDONLY);
2505 if (fd < 0)
2506 return error_errno(_("could not open '%s'"), todo_file);
2507 if (strbuf_read(&todo_list.buf, fd, 0) < 0) {
2508 close(fd);
2509 return error(_("could not read '%s'."), todo_file);
2510 }
2511 close(fd);
2512
2513 res = parse_insn_buffer(todo_list.buf.buf, &todo_list);
2514 if (res) {
2515 todo_list_release(&todo_list);
2516 return error(_("unusable todo list: '%s'"), todo_file);
2517 }
2518
2519 out = fopen(todo_file, "w");
2520 if (!out) {
2521 todo_list_release(&todo_list);
2522 return error(_("unable to open '%s' for writing"), todo_file);
2523 }
2524 for (i = 0; i < todo_list.nr; i++) {
2525 struct todo_item *item = todo_list.items + i;
2526 int bol = item->offset_in_buf;
2527 const char *p = todo_list.buf.buf + bol;
2528 int eol = i + 1 < todo_list.nr ?
2529 todo_list.items[i + 1].offset_in_buf :
2530 todo_list.buf.len;
2531
2532 if (item->command >= TODO_EXEC && item->command != TODO_DROP)
2533 fwrite(p, eol - bol, 1, out);
2534 else {
2535 const char *id = shorten_ids ?
2536 short_commit_name(item->commit) :
2537 oid_to_hex(&item->commit->object.oid);
2538 int len;
2539
2540 p += strspn(p, " \t"); /* left-trim command */
2541 len = strcspn(p, " \t"); /* length of command */
2542
2543 fprintf(out, "%.*s %s %.*s\n",
2544 len, p, id, item->arg_len, item->arg);
2545 }
2546 }
2547 fclose(out);
2548 todo_list_release(&todo_list);
2549 return 0;
2550 }
2551
2552 enum check_level {
2553 CHECK_IGNORE = 0, CHECK_WARN, CHECK_ERROR
2554 };
2555
2556 static enum check_level get_missing_commit_check_level(void)
2557 {
2558 const char *value;
2559
2560 if (git_config_get_value("rebase.missingcommitscheck", &value) ||
2561 !strcasecmp("ignore", value))
2562 return CHECK_IGNORE;
2563 if (!strcasecmp("warn", value))
2564 return CHECK_WARN;
2565 if (!strcasecmp("error", value))
2566 return CHECK_ERROR;
2567 warning(_("unrecognized setting %s for option "
2568 "rebase.missingCommitsCheck. Ignoring."), value);
2569 return CHECK_IGNORE;
2570 }
2571
2572 /*
2573 * Check if the user dropped some commits by mistake
2574 * Behaviour determined by rebase.missingCommitsCheck.
2575 * Check if there is an unrecognized command or a
2576 * bad SHA-1 in a command.
2577 */
2578 int check_todo_list(void)
2579 {
2580 enum check_level check_level = get_missing_commit_check_level();
2581 struct strbuf todo_file = STRBUF_INIT;
2582 struct todo_list todo_list = TODO_LIST_INIT;
2583 struct strbuf missing = STRBUF_INIT;
2584 int advise_to_edit_todo = 0, res = 0, fd, i;
2585
2586 strbuf_addstr(&todo_file, rebase_path_todo());
2587 fd = open(todo_file.buf, O_RDONLY);
2588 if (fd < 0) {
2589 res = error_errno(_("could not open '%s'"), todo_file.buf);
2590 goto leave_check;
2591 }
2592 if (strbuf_read(&todo_list.buf, fd, 0) < 0) {
2593 close(fd);
2594 res = error(_("could not read '%s'."), todo_file.buf);
2595 goto leave_check;
2596 }
2597 close(fd);
2598 advise_to_edit_todo = res =
2599 parse_insn_buffer(todo_list.buf.buf, &todo_list);
2600
2601 if (res || check_level == CHECK_IGNORE)
2602 goto leave_check;
2603
2604 /* Mark the commits in git-rebase-todo as seen */
2605 for (i = 0; i < todo_list.nr; i++) {
2606 struct commit *commit = todo_list.items[i].commit;
2607 if (commit)
2608 commit->util = (void *)1;
2609 }
2610
2611 todo_list_release(&todo_list);
2612 strbuf_addstr(&todo_file, ".backup");
2613 fd = open(todo_file.buf, O_RDONLY);
2614 if (fd < 0) {
2615 res = error_errno(_("could not open '%s'"), todo_file.buf);
2616 goto leave_check;
2617 }
2618 if (strbuf_read(&todo_list.buf, fd, 0) < 0) {
2619 close(fd);
2620 res = error(_("could not read '%s'."), todo_file.buf);
2621 goto leave_check;
2622 }
2623 close(fd);
2624 strbuf_release(&todo_file);
2625 res = !!parse_insn_buffer(todo_list.buf.buf, &todo_list);
2626
2627 /* Find commits in git-rebase-todo.backup yet unseen */
2628 for (i = todo_list.nr - 1; i >= 0; i--) {
2629 struct todo_item *item = todo_list.items + i;
2630 struct commit *commit = item->commit;
2631 if (commit && !commit->util) {
2632 strbuf_addf(&missing, " - %s %.*s\n",
2633 short_commit_name(commit),
2634 item->arg_len, item->arg);
2635 commit->util = (void *)1;
2636 }
2637 }
2638
2639 /* Warn about missing commits */
2640 if (!missing.len)
2641 goto leave_check;
2642
2643 if (check_level == CHECK_ERROR)
2644 advise_to_edit_todo = res = 1;
2645
2646 fprintf(stderr,
2647 _("Warning: some commits may have been dropped accidentally.\n"
2648 "Dropped commits (newer to older):\n"));
2649
2650 /* Make the list user-friendly and display */
2651 fputs(missing.buf, stderr);
2652 strbuf_release(&missing);
2653
2654 fprintf(stderr, _("To avoid this message, use \"drop\" to "
2655 "explicitly remove a commit.\n\n"
2656 "Use 'git config rebase.missingCommitsCheck' to change "
2657 "the level of warnings.\n"
2658 "The possible behaviours are: ignore, warn, error.\n\n"));
2659
2660 leave_check:
2661 strbuf_release(&todo_file);
2662 todo_list_release(&todo_list);
2663
2664 if (advise_to_edit_todo)
2665 fprintf(stderr,
2666 _("You can fix this with 'git rebase --edit-todo' "
2667 "and then run 'git rebase --continue'.\n"
2668 "Or you can abort the rebase with 'git rebase"
2669 " --abort'.\n"));
2670
2671 return res;
2672 }
2673
2674 static int rewrite_file(const char *path, const char *buf, size_t len)
2675 {
2676 int rc = 0;
2677 int fd = open(path, O_WRONLY | O_TRUNC);
2678 if (fd < 0)
2679 return error_errno(_("could not open '%s' for writing"), path);
2680 if (write_in_full(fd, buf, len) < 0)
2681 rc = error_errno(_("could not write to '%s'"), path);
2682 if (close(fd) && !rc)
2683 rc = error_errno(_("could not close '%s'"), path);
2684 return rc;
2685 }
2686
2687 /* skip picking commits whose parents are unchanged */
2688 int skip_unnecessary_picks(void)
2689 {
2690 const char *todo_file = rebase_path_todo();
2691 struct strbuf buf = STRBUF_INIT;
2692 struct todo_list todo_list = TODO_LIST_INIT;
2693 struct object_id onto_oid, *oid = &onto_oid, *parent_oid;
2694 int fd, i;
2695
2696 if (!read_oneliner(&buf, rebase_path_onto(), 0))
2697 return error(_("could not read 'onto'"));
2698 if (get_oid(buf.buf, &onto_oid)) {
2699 strbuf_release(&buf);
2700 return error(_("need a HEAD to fixup"));
2701 }
2702 strbuf_release(&buf);
2703
2704 fd = open(todo_file, O_RDONLY);
2705 if (fd < 0) {
2706 return error_errno(_("could not open '%s'"), todo_file);
2707 }
2708 if (strbuf_read(&todo_list.buf, fd, 0) < 0) {
2709 close(fd);
2710 return error(_("could not read '%s'."), todo_file);
2711 }
2712 close(fd);
2713 if (parse_insn_buffer(todo_list.buf.buf, &todo_list) < 0) {
2714 todo_list_release(&todo_list);
2715 return -1;
2716 }
2717
2718 for (i = 0; i < todo_list.nr; i++) {
2719 struct todo_item *item = todo_list.items + i;
2720
2721 if (item->command >= TODO_NOOP)
2722 continue;
2723 if (item->command != TODO_PICK)
2724 break;
2725 if (parse_commit(item->commit)) {
2726 todo_list_release(&todo_list);
2727 return error(_("could not parse commit '%s'"),
2728 oid_to_hex(&item->commit->object.oid));
2729 }
2730 if (!item->commit->parents)
2731 break; /* root commit */
2732 if (item->commit->parents->next)
2733 break; /* merge commit */
2734 parent_oid = &item->commit->parents->item->object.oid;
2735 if (hashcmp(parent_oid->hash, oid->hash))
2736 break;
2737 oid = &item->commit->object.oid;
2738 }
2739 if (i > 0) {
2740 int offset = i < todo_list.nr ?
2741 todo_list.items[i].offset_in_buf : todo_list.buf.len;
2742 const char *done_path = rebase_path_done();
2743
2744 fd = open(done_path, O_CREAT | O_WRONLY | O_APPEND, 0666);
2745 if (fd < 0) {
2746 error_errno(_("could not open '%s' for writing"),
2747 done_path);
2748 todo_list_release(&todo_list);
2749 return -1;
2750 }
2751 if (write_in_full(fd, todo_list.buf.buf, offset) < 0) {
2752 error_errno(_("could not write to '%s'"), done_path);
2753 todo_list_release(&todo_list);
2754 close(fd);
2755 return -1;
2756 }
2757 close(fd);
2758
2759 if (rewrite_file(rebase_path_todo(), todo_list.buf.buf + offset,
2760 todo_list.buf.len - offset) < 0) {
2761 todo_list_release(&todo_list);
2762 return -1;
2763 }
2764
2765 todo_list.current = i;
2766 if (is_fixup(peek_command(&todo_list, 0)))
2767 record_in_rewritten(oid, peek_command(&todo_list, 0));
2768 }
2769
2770 todo_list_release(&todo_list);
2771 printf("%s\n", oid_to_hex(oid));
2772
2773 return 0;
2774 }
2775
2776 struct subject2item_entry {
2777 struct hashmap_entry entry;
2778 int i;
2779 char subject[FLEX_ARRAY];
2780 };
2781
2782 static int subject2item_cmp(const void *fndata,
2783 const struct subject2item_entry *a,
2784 const struct subject2item_entry *b, const void *key)
2785 {
2786 return key ? strcmp(a->subject, key) : strcmp(a->subject, b->subject);
2787 }
2788
2789 /*
2790 * Rearrange the todo list that has both "pick commit-id msg" and "pick
2791 * commit-id fixup!/squash! msg" in it so that the latter is put immediately
2792 * after the former, and change "pick" to "fixup"/"squash".
2793 *
2794 * Note that if the config has specified a custom instruction format, each log
2795 * message will have to be retrieved from the commit (as the oneline in the
2796 * script cannot be trusted) in order to normalize the autosquash arrangement.
2797 */
2798 int rearrange_squash(void)
2799 {
2800 const char *todo_file = rebase_path_todo();
2801 struct todo_list todo_list = TODO_LIST_INIT;
2802 struct hashmap subject2item;
2803 int res = 0, rearranged = 0, *next, *tail, fd, i;
2804 char **subjects;
2805
2806 fd = open(todo_file, O_RDONLY);
2807 if (fd < 0)
2808 return error_errno(_("could not open '%s'"), todo_file);
2809 if (strbuf_read(&todo_list.buf, fd, 0) < 0) {
2810 close(fd);
2811 return error(_("could not read '%s'."), todo_file);
2812 }
2813 close(fd);
2814 if (parse_insn_buffer(todo_list.buf.buf, &todo_list) < 0) {
2815 todo_list_release(&todo_list);
2816 return -1;
2817 }
2818
2819 /*
2820 * The hashmap maps onelines to the respective todo list index.
2821 *
2822 * If any items need to be rearranged, the next[i] value will indicate
2823 * which item was moved directly after the i'th.
2824 *
2825 * In that case, last[i] will indicate the index of the latest item to
2826 * be moved to appear after the i'th.
2827 */
2828 hashmap_init(&subject2item, (hashmap_cmp_fn) subject2item_cmp,
2829 NULL, todo_list.nr);
2830 ALLOC_ARRAY(next, todo_list.nr);
2831 ALLOC_ARRAY(tail, todo_list.nr);
2832 ALLOC_ARRAY(subjects, todo_list.nr);
2833 for (i = 0; i < todo_list.nr; i++) {
2834 struct strbuf buf = STRBUF_INIT;
2835 struct todo_item *item = todo_list.items + i;
2836 const char *commit_buffer, *subject, *p;
2837 size_t subject_len;
2838 int i2 = -1;
2839 struct subject2item_entry *entry;
2840
2841 next[i] = tail[i] = -1;
2842 if (item->command >= TODO_EXEC) {
2843 subjects[i] = NULL;
2844 continue;
2845 }
2846
2847 if (is_fixup(item->command)) {
2848 todo_list_release(&todo_list);
2849 return error(_("the script was already rearranged."));
2850 }
2851
2852 item->commit->util = item;
2853
2854 parse_commit(item->commit);
2855 commit_buffer = get_commit_buffer(item->commit, NULL);
2856 find_commit_subject(commit_buffer, &subject);
2857 format_subject(&buf, subject, " ");
2858 subject = subjects[i] = strbuf_detach(&buf, &subject_len);
2859 unuse_commit_buffer(item->commit, commit_buffer);
2860 if ((skip_prefix(subject, "fixup! ", &p) ||
2861 skip_prefix(subject, "squash! ", &p))) {
2862 struct commit *commit2;
2863
2864 for (;;) {
2865 while (isspace(*p))
2866 p++;
2867 if (!skip_prefix(p, "fixup! ", &p) &&
2868 !skip_prefix(p, "squash! ", &p))
2869 break;
2870 }
2871
2872 if ((entry = hashmap_get_from_hash(&subject2item,
2873 strhash(p), p)))
2874 /* found by title */
2875 i2 = entry->i;
2876 else if (!strchr(p, ' ') &&
2877 (commit2 =
2878 lookup_commit_reference_by_name(p)) &&
2879 commit2->util)
2880 /* found by commit name */
2881 i2 = (struct todo_item *)commit2->util
2882 - todo_list.items;
2883 else {
2884 /* copy can be a prefix of the commit subject */
2885 for (i2 = 0; i2 < i; i2++)
2886 if (subjects[i2] &&
2887 starts_with(subjects[i2], p))
2888 break;
2889 if (i2 == i)
2890 i2 = -1;
2891 }
2892 }
2893 if (i2 >= 0) {
2894 rearranged = 1;
2895 todo_list.items[i].command =
2896 starts_with(subject, "fixup!") ?
2897 TODO_FIXUP : TODO_SQUASH;
2898 if (next[i2] < 0)
2899 next[i2] = i;
2900 else
2901 next[tail[i2]] = i;
2902 tail[i2] = i;
2903 } else if (!hashmap_get_from_hash(&subject2item,
2904 strhash(subject), subject)) {
2905 FLEX_ALLOC_MEM(entry, subject, subject, subject_len);
2906 entry->i = i;
2907 hashmap_entry_init(entry, strhash(entry->subject));
2908 hashmap_put(&subject2item, entry);
2909 }
2910 }
2911
2912 if (rearranged) {
2913 struct strbuf buf = STRBUF_INIT;
2914
2915 for (i = 0; i < todo_list.nr; i++) {
2916 enum todo_command command = todo_list.items[i].command;
2917 int cur = i;
2918
2919 /*
2920 * Initially, all commands are 'pick's. If it is a
2921 * fixup or a squash now, we have rearranged it.
2922 */
2923 if (is_fixup(command))
2924 continue;
2925
2926 while (cur >= 0) {
2927 int offset = todo_list.items[cur].offset_in_buf;
2928 int end_offset = cur + 1 < todo_list.nr ?
2929 todo_list.items[cur + 1].offset_in_buf :
2930 todo_list.buf.len;
2931 char *bol = todo_list.buf.buf + offset;
2932 char *eol = todo_list.buf.buf + end_offset;
2933
2934 /* replace 'pick', by 'fixup' or 'squash' */
2935 command = todo_list.items[cur].command;
2936 if (is_fixup(command)) {
2937 strbuf_addstr(&buf,
2938 todo_command_info[command].str);
2939 bol += strcspn(bol, " \t");
2940 }
2941
2942 strbuf_add(&buf, bol, eol - bol);
2943
2944 cur = next[cur];
2945 }
2946 }
2947
2948 res = rewrite_file(todo_file, buf.buf, buf.len);
2949 strbuf_release(&buf);
2950 }
2951
2952 free(next);
2953 free(tail);
2954 for (i = 0; i < todo_list.nr; i++)
2955 free(subjects[i]);
2956 free(subjects);
2957 hashmap_free(&subject2item, 1);
2958 todo_list_release(&todo_list);
2959
2960 return res;
2961 }