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