Coverage Report

Created: 2026-11-15 06:43

next uncovered line (L), next uncovered region (R), next uncovered branch (B)
/src/git/sequencer.c
Line
Count
Source
1
#define USE_THE_REPOSITORY_VARIABLE
2
#define DISABLE_SIGN_COMPARE_WARNINGS
3
4
#include "git-compat-util.h"
5
#include "abspath.h"
6
#include "advice.h"
7
#include "config.h"
8
#include "copy.h"
9
#include "environment.h"
10
#include "gettext.h"
11
#include "hex.h"
12
#include "lockfile.h"
13
#include "dir.h"
14
#include "object-file.h"
15
#include "object-name.h"
16
#include "odb.h"
17
#include "object.h"
18
#include "pager.h"
19
#include "commit.h"
20
#include "sequencer.h"
21
#include "run-command.h"
22
#include "stash.h"
23
#include "hook.h"
24
#include "utf8.h"
25
#include "cache-tree.h"
26
#include "diff.h"
27
#include "path.h"
28
#include "revision.h"
29
#include "rerere.h"
30
#include "merge.h"
31
#include "merge-ort.h"
32
#include "merge-ort-wrappers.h"
33
#include "refs.h"
34
#include "sparse-index.h"
35
#include "strvec.h"
36
#include "quote.h"
37
#include "trailer.h"
38
#include "log-tree.h"
39
#include "wt-status.h"
40
#include "hashmap.h"
41
#include "notes-utils.h"
42
#include "sigchain.h"
43
#include "unpack-trees.h"
44
#include "oidmap.h"
45
#include "oidset.h"
46
#include "commit-slab.h"
47
#include "alias.h"
48
#include "commit-reach.h"
49
#include "rebase-interactive.h"
50
#include "reset.h"
51
#include "branch.h"
52
53
0
#define GIT_REFLOG_ACTION "GIT_REFLOG_ACTION"
54
55
/*
56
 * To accommodate common filesystem limitations, where the loose refs' file
57
 * names must not exceed `NAME_MAX`, the labels generated by `git rebase
58
 * --rebase-merges` need to be truncated if the corresponding commit subjects
59
 * are too long.
60
 * Add some margin to stay clear from reaching `NAME_MAX`.
61
 */
62
0
#define GIT_MAX_LABEL_LENGTH ((NAME_MAX) - (LOCK_SUFFIX_LEN) - 16)
63
64
static const char sign_off_header[] = "Signed-off-by: ";
65
static const char cherry_picked_prefix[] = "(cherry picked from commit ";
66
67
GIT_PATH_FUNC(git_path_commit_editmsg, "COMMIT_EDITMSG")
68
69
static GIT_PATH_FUNC(git_path_seq_dir, "sequencer")
70
71
static GIT_PATH_FUNC(git_path_todo_file, "sequencer/todo")
72
static GIT_PATH_FUNC(git_path_opts_file, "sequencer/opts")
73
static GIT_PATH_FUNC(git_path_head_file, "sequencer/head")
74
static GIT_PATH_FUNC(git_path_abort_safety_file, "sequencer/abort-safety")
75
76
static GIT_PATH_FUNC(rebase_path, "rebase-merge")
77
/*
78
 * The file containing rebase commands, comments, and empty lines.
79
 * This file is created by "git rebase -i" then edited by the user. As
80
 * the lines are processed, they are removed from the front of this
81
 * file and written to the tail of 'done'.
82
 */
83
GIT_PATH_FUNC(rebase_path_todo, "rebase-merge/git-rebase-todo")
84
GIT_PATH_FUNC(rebase_path_todo_backup, "rebase-merge/git-rebase-todo.backup")
85
86
GIT_PATH_FUNC(rebase_path_dropped, "rebase-merge/dropped")
87
88
/*
89
 * The rebase command lines that have already been processed. A line
90
 * is moved here when it is first handled, before any associated user
91
 * actions.
92
 */
93
static GIT_PATH_FUNC(rebase_path_done, "rebase-merge/done")
94
/*
95
 * The file to keep track of how many commands were already processed (e.g.
96
 * for the prompt).
97
 */
98
static GIT_PATH_FUNC(rebase_path_msgnum, "rebase-merge/msgnum")
99
/*
100
 * The file to keep track of how many commands are to be processed in total
101
 * (e.g. for the prompt).
102
 */
103
static GIT_PATH_FUNC(rebase_path_msgtotal, "rebase-merge/end")
104
/*
105
 * The commit message that is planned to be used for any changes that
106
 * need to be committed following a user interaction.
107
 */
108
static GIT_PATH_FUNC(rebase_path_message, "rebase-merge/message")
109
/*
110
 * The file into which is accumulated the suggested commit message for
111
 * squash/fixup commands. When the first of a series of squash/fixups
112
 * is seen, the file is created and the commit message from the
113
 * previous commit and from the first squash/fixup commit are written
114
 * to it. The commit message for each subsequent squash/fixup commit
115
 * is appended to the file as it is processed.
116
 */
117
static GIT_PATH_FUNC(rebase_path_squash_msg, "rebase-merge/message-squash")
118
/*
119
 * If the current series of squash/fixups has not yet included a squash
120
 * command, then this file exists and holds the commit message of the
121
 * original "pick" commit.  (If the series ends without a "squash"
122
 * command, then this can be used as the commit message of the combined
123
 * commit without opening the editor.)
124
 */
125
static GIT_PATH_FUNC(rebase_path_fixup_msg, "rebase-merge/message-fixup")
126
/*
127
 * This file contains the list fixup/squash commands that have been
128
 * accumulated into message-fixup or message-squash so far.
129
 */
130
static GIT_PATH_FUNC(rebase_path_current_fixups, "rebase-merge/current-fixups")
131
/*
132
 * A script to set the GIT_AUTHOR_NAME, GIT_AUTHOR_EMAIL, and
133
 * GIT_AUTHOR_DATE that will be used for the commit that is currently
134
 * being rebased.
135
 */
136
static GIT_PATH_FUNC(rebase_path_author_script, "rebase-merge/author-script")
137
/*
138
 * When an "edit" rebase command is being processed, the SHA1 of the
139
 * commit to be edited is recorded in this file.  When "git rebase
140
 * --continue" is executed, if there are any staged changes then they
141
 * will be amended to the HEAD commit, but only provided the HEAD
142
 * commit is still the commit to be edited.  When any other rebase
143
 * command is processed, this file is deleted.
144
 */
145
static GIT_PATH_FUNC(rebase_path_amend, "rebase-merge/amend")
146
/*
147
 * When we stop at a given patch via the "edit" command, this file contains
148
 * the commit object name of the corresponding patch.
149
 */
150
static GIT_PATH_FUNC(rebase_path_stopped_sha, "rebase-merge/stopped-sha")
151
/*
152
 * When we stop for the user to resolve conflicts this file contains
153
 * the patch of the commit that is being picked.
154
 */
155
static GIT_PATH_FUNC(rebase_path_patch, "rebase-merge/patch")
156
/*
157
 * For the post-rewrite hook, we make a list of rewritten commits and
158
 * their new sha1s.  The rewritten-pending list keeps the sha1s of
159
 * commits that have been processed, but not committed yet,
160
 * e.g. because they are waiting for a 'squash' command.
161
 */
162
static GIT_PATH_FUNC(rebase_path_rewritten_list, "rebase-merge/rewritten-list")
163
static GIT_PATH_FUNC(rebase_path_rewritten_pending,
164
  "rebase-merge/rewritten-pending")
165
166
/*
167
 * The path of the file containing the OID of the "squash onto" commit, i.e.
168
 * the dummy commit used for `reset [new root]`.
169
 */
170
static GIT_PATH_FUNC(rebase_path_squash_onto, "rebase-merge/squash-onto")
171
172
/*
173
 * The path of the file listing refs that need to be deleted after the rebase
174
 * finishes. This is used by the `label` command to record the need for cleanup.
175
 */
176
static GIT_PATH_FUNC(rebase_path_refs_to_delete, "rebase-merge/refs-to-delete")
177
178
/*
179
 * The update-refs file stores a list of refs that will be updated at the end
180
 * of the rebase sequence. The 'update-ref <ref>' commands in the todo file
181
 * update the OIDs for the refs in this file, but the refs are not updated
182
 * until the end of the rebase sequence.
183
 *
184
 * rebase_path_update_refs() returns the path to this file for a given
185
 * worktree directory. For the current worktree, pass the_repository->gitdir.
186
 */
187
static char *rebase_path_update_refs(const char *wt_git_dir)
188
0
{
189
0
  return xstrfmt("%s/rebase-merge/update-refs", wt_git_dir);
190
0
}
191
192
/*
193
 * The following files are written by git-rebase just after parsing the
194
 * command-line.
195
 */
196
static GIT_PATH_FUNC(rebase_path_gpg_sign_opt, "rebase-merge/gpg_sign_opt")
197
static GIT_PATH_FUNC(rebase_path_cdate_is_adate, "rebase-merge/cdate_is_adate")
198
static GIT_PATH_FUNC(rebase_path_ignore_date, "rebase-merge/ignore_date")
199
static GIT_PATH_FUNC(rebase_path_orig_head, "rebase-merge/orig-head")
200
static GIT_PATH_FUNC(rebase_path_verbose, "rebase-merge/verbose")
201
static GIT_PATH_FUNC(rebase_path_quiet, "rebase-merge/quiet")
202
static GIT_PATH_FUNC(rebase_path_signoff, "rebase-merge/signoff")
203
static GIT_PATH_FUNC(rebase_path_head_name, "rebase-merge/head-name")
204
static GIT_PATH_FUNC(rebase_path_onto, "rebase-merge/onto")
205
static GIT_PATH_FUNC(rebase_path_autostash, "rebase-merge/autostash")
206
static GIT_PATH_FUNC(rebase_path_strategy, "rebase-merge/strategy")
207
static GIT_PATH_FUNC(rebase_path_strategy_opts, "rebase-merge/strategy_opts")
208
static GIT_PATH_FUNC(rebase_path_allow_rerere_autoupdate, "rebase-merge/allow_rerere_autoupdate")
209
static GIT_PATH_FUNC(rebase_path_reschedule_failed_exec, "rebase-merge/reschedule-failed-exec")
210
static GIT_PATH_FUNC(rebase_path_no_reschedule_failed_exec, "rebase-merge/no-reschedule-failed-exec")
211
static GIT_PATH_FUNC(rebase_path_drop_redundant_commits, "rebase-merge/drop_redundant_commits")
212
static GIT_PATH_FUNC(rebase_path_keep_redundant_commits, "rebase-merge/keep_redundant_commits")
213
static GIT_PATH_FUNC(rebase_path_trailer, "rebase-merge/trailer")
214
215
/*
216
 * A 'struct replay_ctx' represents the private state of the sequencer.
217
 */
218
struct replay_ctx {
219
  /*
220
   * The commit message that will be used except at the end of a
221
   * chain of fixup and squash commands.
222
   */
223
  struct strbuf message;
224
  /*
225
   * The list of completed fixup and squash commands in the
226
   * current chain.
227
   */
228
  struct strbuf current_fixups;
229
  /*
230
   * The number of completed fixup and squash commands in the
231
   * current chain.
232
   */
233
  int current_fixup_count;
234
  /*
235
   * Whether message contains a commit message.
236
   */
237
  unsigned have_message :1;
238
  /*
239
   * GIT_CONFIG_PARAMETERS for the commands we spawn, with auto
240
   * maintenance turned off. Built on first use.
241
   */
242
  char *config_parameters;
243
};
244
245
struct replay_ctx* replay_ctx_new(void)
246
0
{
247
0
  struct replay_ctx *ctx = xcalloc(1, sizeof(*ctx));
248
249
0
  strbuf_init(&ctx->current_fixups, 0);
250
0
  strbuf_init(&ctx->message, 0);
251
252
0
  return ctx;
253
0
}
254
255
/**
256
 * A 'struct update_refs_record' represents a value in the update-refs
257
 * list. We use a string_list to map refs to these (before, after) pairs.
258
 */
259
struct update_ref_record {
260
  struct object_id before;
261
  struct object_id after;
262
};
263
264
static struct update_ref_record *init_update_ref_record(const char *ref)
265
0
{
266
0
  struct update_ref_record *rec;
267
268
0
  CALLOC_ARRAY(rec, 1);
269
270
0
  oidcpy(&rec->before, null_oid(the_hash_algo));
271
0
  oidcpy(&rec->after, null_oid(the_hash_algo));
272
273
  /* This may fail, but that's fine, we will keep the null OID. */
274
0
  refs_read_ref(get_main_ref_store(the_repository), ref, &rec->before);
275
276
0
  return rec;
277
0
}
278
279
static int git_sequencer_config(const char *k, const char *v,
280
        const struct config_context *ctx, void *cb)
281
0
{
282
0
  struct replay_opts *opts = cb;
283
284
0
  if (!strcmp(k, "commit.cleanup")) {
285
0
    if (!v)
286
0
      return config_error_nonbool(k);
287
288
0
    if (!strcmp(v, "verbatim")) {
289
0
      opts->default_msg_cleanup = COMMIT_MSG_CLEANUP_NONE;
290
0
      opts->explicit_cleanup = 1;
291
0
    } else if (!strcmp(v, "whitespace")) {
292
0
      opts->default_msg_cleanup = COMMIT_MSG_CLEANUP_SPACE;
293
0
      opts->explicit_cleanup = 1;
294
0
    } else if (!strcmp(v, "strip")) {
295
0
      opts->default_msg_cleanup = COMMIT_MSG_CLEANUP_ALL;
296
0
      opts->explicit_cleanup = 1;
297
0
    } else if (!strcmp(v, "scissors")) {
298
0
      opts->default_msg_cleanup = COMMIT_MSG_CLEANUP_SCISSORS;
299
0
      opts->explicit_cleanup = 1;
300
0
    } else {
301
0
      warning(_("invalid commit message cleanup mode '%s'"),
302
0
          v);
303
0
    }
304
305
0
    return 0;
306
0
  }
307
308
0
  if (!strcmp(k, "commit.gpgsign")) {
309
0
    free(opts->gpg_sign);
310
0
    opts->gpg_sign = git_config_bool(k, v) ? xstrdup("") : NULL;
311
0
    return 0;
312
0
  }
313
314
0
  if (!opts->default_strategy && !strcmp(k, "pull.twohead")) {
315
0
    int ret = git_config_string(&opts->default_strategy, k, v);
316
0
    if (ret == 0) {
317
      /*
318
       * pull.twohead is allowed to be multi-valued; we only
319
       * care about the first value.
320
       */
321
0
      char *tmp = strchr(opts->default_strategy, ' ');
322
0
      if (tmp)
323
0
        *tmp = '\0';
324
0
    }
325
0
    return ret;
326
0
  }
327
328
0
  if (opts->action == REPLAY_REVERT && !strcmp(k, "revert.reference"))
329
0
    opts->commit_use_reference = git_config_bool(k, v);
330
331
0
  return git_diff_basic_config(k, v, ctx, NULL);
332
0
}
333
334
void sequencer_init_config(struct replay_opts *opts)
335
0
{
336
0
  opts->default_msg_cleanup = COMMIT_MSG_CLEANUP_NONE;
337
0
  repo_config(the_repository, git_sequencer_config, opts);
338
0
}
339
340
static inline int is_rebase_i(const struct replay_opts *opts)
341
0
{
342
0
  return opts->action == REPLAY_INTERACTIVE_REBASE;
343
0
}
344
345
static const char *get_dir(const struct replay_opts *opts)
346
0
{
347
0
  if (is_rebase_i(opts))
348
0
    return rebase_path();
349
0
  return git_path_seq_dir();
350
0
}
351
352
static const char *get_todo_path(const struct replay_opts *opts)
353
0
{
354
0
  if (is_rebase_i(opts))
355
0
    return rebase_path_todo();
356
0
  return git_path_todo_file();
357
0
}
358
359
/*
360
 * Returns 0 for non-conforming footer
361
 * Returns 1 for conforming footer
362
 * Returns 2 when sob exists within conforming footer
363
 * Returns 3 when sob exists within conforming footer as last entry
364
 */
365
static int has_conforming_footer(struct strbuf *sb, struct strbuf *sob,
366
  size_t ignore_footer)
367
0
{
368
0
  struct trailer_iterator iter;
369
0
  size_t i = 0;
370
0
  int found_sob = 0, found_sob_last = 0;
371
0
  char saved_char;
372
373
0
  if (ignore_footer) {
374
0
    saved_char = sb->buf[sb->len - ignore_footer];
375
0
    sb->buf[sb->len - ignore_footer] = '\0';
376
0
  }
377
378
0
  trailer_iterator_init(&iter, sb->buf);
379
380
0
  if (ignore_footer)
381
0
    sb->buf[sb->len - ignore_footer] = saved_char;
382
383
0
  while (trailer_iterator_advance(&iter)) {
384
0
    i++;
385
0
    if (sob && !strncmp(iter.raw, sob->buf, sob->len))
386
0
      found_sob = i;
387
0
  }
388
0
  trailer_iterator_release(&iter);
389
390
0
  if (!i)
391
0
    return 0;
392
393
0
  found_sob_last = (int)i == found_sob;
394
395
0
  if (found_sob_last)
396
0
    return 3;
397
0
  if (found_sob)
398
0
    return 2;
399
0
  return 1;
400
0
}
401
402
static const char *gpg_sign_opt_quoted(struct replay_opts *opts)
403
0
{
404
0
  static struct strbuf buf = STRBUF_INIT;
405
406
0
  strbuf_reset(&buf);
407
0
  if (opts->gpg_sign)
408
0
    sq_quotef(&buf, "-S%s", opts->gpg_sign);
409
0
  return buf.buf;
410
0
}
411
412
static void replay_ctx_release(struct replay_ctx *ctx)
413
0
{
414
0
  strbuf_release(&ctx->current_fixups);
415
0
  strbuf_release(&ctx->message);
416
0
  free(ctx->config_parameters);
417
0
}
418
419
void replay_opts_release(struct replay_opts *opts)
420
0
{
421
0
  struct replay_ctx *ctx = opts->ctx;
422
423
0
  free(opts->gpg_sign);
424
0
  free(opts->reflog_action);
425
0
  free(opts->default_strategy);
426
0
  free(opts->strategy);
427
0
  strvec_clear (&opts->xopts);
428
0
  if (opts->revs)
429
0
    release_revisions(opts->revs);
430
0
  free(opts->revs);
431
0
  strvec_clear(&opts->trailer_args);
432
0
  replay_ctx_release(ctx);
433
0
  free(opts->ctx);
434
0
}
435
436
int sequencer_remove_state(struct replay_opts *opts)
437
0
{
438
0
  struct strbuf buf = STRBUF_INIT;
439
0
  int ret = 0;
440
441
0
  if (is_rebase_i(opts) &&
442
0
      strbuf_read_file(&buf, rebase_path_refs_to_delete(), 0) > 0) {
443
0
    char *p = buf.buf;
444
0
    while (*p) {
445
0
      char *eol = strchr(p, '\n');
446
0
      if (eol)
447
0
        *eol = '\0';
448
0
      if (refs_delete_ref(get_main_ref_store(the_repository), "(rebase) cleanup", p, NULL, 0) < 0) {
449
0
        warning(_("could not delete '%s'"), p);
450
0
        ret = -1;
451
0
      }
452
0
      if (!eol)
453
0
        break;
454
0
      p = eol + 1;
455
0
    }
456
0
  }
457
458
0
  strbuf_reset(&buf);
459
0
  strbuf_addstr(&buf, get_dir(opts));
460
0
  if (remove_dir_recursively(&buf, 0))
461
0
    ret = error(_("could not remove '%s'"), buf.buf);
462
0
  strbuf_release(&buf);
463
464
0
  return ret;
465
0
}
466
467
static const char *action_name(const struct replay_opts *opts)
468
0
{
469
0
  switch (opts->action) {
470
0
  case REPLAY_REVERT:
471
0
    return N_("revert");
472
0
  case REPLAY_PICK:
473
0
    return N_("cherry-pick");
474
0
  case REPLAY_INTERACTIVE_REBASE:
475
0
    return N_("rebase");
476
0
  }
477
0
  die(_("unknown action: %d"), opts->action);
478
0
}
479
480
struct commit_message {
481
  char *parent_label;
482
  char *label;
483
  char *subject;
484
  const char *message;
485
};
486
487
static const char *short_commit_name(struct repository *r, struct commit *commit)
488
0
{
489
0
  return repo_find_unique_abbrev(r, &commit->object.oid, DEFAULT_ABBREV);
490
0
}
491
492
static int get_message(struct commit *commit, struct commit_message *out)
493
0
{
494
0
  const char *abbrev, *subject;
495
0
  int subject_len;
496
497
0
  out->message = repo_logmsg_reencode(the_repository, commit, NULL,
498
0
              get_commit_output_encoding());
499
0
  abbrev = short_commit_name(the_repository, commit);
500
501
0
  subject_len = find_commit_subject(out->message, &subject);
502
503
0
  out->subject = xmemdupz(subject, subject_len);
504
0
  out->label = xstrfmt("%s (%s)", abbrev, out->subject);
505
0
  out->parent_label = xstrfmt("parent of %s", out->label);
506
507
0
  return 0;
508
0
}
509
510
static void free_message(struct commit *commit, struct commit_message *msg)
511
0
{
512
0
  free(msg->parent_label);
513
0
  free(msg->label);
514
0
  free(msg->subject);
515
0
  repo_unuse_commit_buffer(the_repository, commit, msg->message);
516
0
}
517
518
const char *rebase_resolvemsg =
519
N_("Resolve all conflicts manually, mark them as resolved with\n"
520
"\"git add/rm <conflicted_files>\", then run \"git rebase --continue\".\n"
521
"You can instead skip this commit: run \"git rebase --skip\".\n"
522
"To abort and get back to the state before \"git rebase\", run "
523
"\"git rebase --abort\".");
524
525
static void print_advice(struct repository *r, int show_hint,
526
       struct replay_opts *opts)
527
0
{
528
0
  const char *msg;
529
530
0
  if (is_rebase_i(opts))
531
0
    msg = rebase_resolvemsg;
532
0
  else
533
0
    msg = getenv("GIT_CHERRY_PICK_HELP");
534
535
0
  if (msg) {
536
0
    advise_if_enabled(ADVICE_MERGE_CONFLICT, "%s", msg);
537
    /*
538
     * A conflict has occurred but the porcelain
539
     * (typically rebase --interactive) wants to take care
540
     * of the commit itself so remove CHERRY_PICK_HEAD
541
     */
542
0
    refs_delete_ref(get_main_ref_store(r), "", "CHERRY_PICK_HEAD",
543
0
        NULL, REF_NO_DEREF);
544
0
    return;
545
0
  }
546
547
0
  if (show_hint) {
548
0
    if (opts->no_commit)
549
0
      advise_if_enabled(ADVICE_MERGE_CONFLICT,
550
0
            _("after resolving the conflicts, mark the corrected paths\n"
551
0
              "with 'git add <paths>' or 'git rm <paths>'"));
552
0
    else if (opts->action == REPLAY_PICK)
553
0
      advise_if_enabled(ADVICE_MERGE_CONFLICT,
554
0
            _("After resolving the conflicts, mark them with\n"
555
0
              "\"git add/rm <pathspec>\", then run\n"
556
0
              "\"git cherry-pick --continue\".\n"
557
0
              "You can instead skip this commit with \"git cherry-pick --skip\".\n"
558
0
              "To abort and get back to the state before \"git cherry-pick\",\n"
559
0
              "run \"git cherry-pick --abort\"."));
560
0
    else if (opts->action == REPLAY_REVERT)
561
0
      advise_if_enabled(ADVICE_MERGE_CONFLICT,
562
0
            _("After resolving the conflicts, mark them with\n"
563
0
              "\"git add/rm <pathspec>\", then run\n"
564
0
              "\"git revert --continue\".\n"
565
0
              "You can instead skip this commit with \"git revert --skip\".\n"
566
0
              "To abort and get back to the state before \"git revert\",\n"
567
0
              "run \"git revert --abort\"."));
568
0
    else
569
0
      BUG("unexpected pick action in print_advice()");
570
0
  }
571
0
}
572
573
static int write_message(const void *buf, size_t len, const char *filename,
574
       int append_eol)
575
0
{
576
0
  struct lock_file msg_file = LOCK_INIT;
577
578
0
  int msg_fd = hold_lock_file_for_update(&msg_file, filename, 0);
579
0
  if (msg_fd < 0)
580
0
    return error_errno(_("could not lock '%s'"), filename);
581
0
  if (write_in_full(msg_fd, buf, len) < 0) {
582
0
    error_errno(_("could not write to '%s'"), filename);
583
0
    rollback_lock_file(&msg_file);
584
0
    return -1;
585
0
  }
586
0
  if (append_eol && write(msg_fd, "\n", 1) < 0) {
587
0
    error_errno(_("could not write eol to '%s'"), filename);
588
0
    rollback_lock_file(&msg_file);
589
0
    return -1;
590
0
  }
591
0
  if (commit_lock_file(&msg_file) < 0)
592
0
    return error(_("failed to finalize '%s'"), filename);
593
594
0
  return 0;
595
0
}
596
597
int read_oneliner(struct strbuf *buf,
598
  const char *path, unsigned flags)
599
0
{
600
0
  int orig_len = buf->len;
601
602
0
  if (strbuf_read_file(buf, path, 0) < 0) {
603
0
    if ((flags & READ_ONELINER_WARN_MISSING) ||
604
0
        (errno != ENOENT && errno != ENOTDIR))
605
0
      warning_errno(_("could not read '%s'"), path);
606
0
    return 0;
607
0
  }
608
609
0
  if (buf->len > orig_len && buf->buf[buf->len - 1] == '\n') {
610
0
    if (--buf->len > orig_len && buf->buf[buf->len - 1] == '\r')
611
0
      --buf->len;
612
0
    buf->buf[buf->len] = '\0';
613
0
  }
614
615
0
  if ((flags & READ_ONELINER_SKIP_IF_EMPTY) && buf->len == orig_len)
616
0
    return 0;
617
618
0
  return 1;
619
0
}
620
621
static struct tree *empty_tree(struct repository *r)
622
0
{
623
0
  return lookup_tree(r, the_hash_algo->empty_tree);
624
0
}
625
626
static int error_dirty_index(struct repository *repo, struct replay_opts *opts)
627
0
{
628
0
  if (repo_read_index_unmerged(repo))
629
0
    return error_resolve_conflict(action_name(opts));
630
631
0
  error(_("your local changes would be overwritten by %s."),
632
0
    _(action_name(opts)));
633
634
0
  if (advice_enabled(ADVICE_COMMIT_BEFORE_MERGE))
635
0
    advise(_("commit your changes or stash them to proceed."));
636
0
  return -1;
637
0
}
638
639
static void update_abort_safety_file(void)
640
0
{
641
0
  struct object_id head;
642
643
  /* Do nothing on a single-pick */
644
0
  if (!file_exists(git_path_seq_dir()))
645
0
    return;
646
647
0
  if (!repo_get_oid(the_repository, "HEAD", &head))
648
0
    write_file(git_path_abort_safety_file(), "%s", oid_to_hex(&head));
649
0
  else
650
0
    write_file(git_path_abort_safety_file(), "%s", "");
651
0
}
652
653
static int fast_forward_to(struct repository *r,
654
         const struct object_id *to,
655
         const struct object_id *from,
656
         int unborn,
657
         struct replay_opts *opts)
658
0
{
659
0
  struct ref_transaction *transaction;
660
0
  struct strbuf sb = STRBUF_INIT;
661
0
  struct strbuf err = STRBUF_INIT;
662
663
0
  repo_read_index(r);
664
0
  if (checkout_fast_forward(r, from, to, 1))
665
0
    return -1; /* the callee should have complained already */
666
667
0
  strbuf_addf(&sb, "%s: fast-forward", action_name(opts));
668
669
0
  transaction = ref_store_transaction_begin(get_main_ref_store(the_repository),
670
0
              0, &err);
671
0
  if (!transaction ||
672
0
      ref_transaction_update(transaction, "HEAD",
673
0
           to, unborn && !is_rebase_i(opts) ?
674
0
           null_oid(the_hash_algo) : from, NULL, NULL,
675
0
           0, sb.buf, &err) ||
676
0
      ref_transaction_commit(transaction, &err)) {
677
0
    ref_transaction_free(transaction);
678
0
    error("%s", err.buf);
679
0
    strbuf_release(&sb);
680
0
    strbuf_release(&err);
681
0
    return -1;
682
0
  }
683
684
0
  strbuf_release(&sb);
685
0
  strbuf_release(&err);
686
0
  ref_transaction_free(transaction);
687
0
  update_abort_safety_file();
688
0
  return 0;
689
0
}
690
691
enum commit_msg_cleanup_mode get_cleanup_mode(const char *cleanup_arg,
692
  int use_editor)
693
0
{
694
0
  if (!cleanup_arg || !strcmp(cleanup_arg, "default"))
695
0
    return use_editor ? COMMIT_MSG_CLEANUP_ALL :
696
0
            COMMIT_MSG_CLEANUP_SPACE;
697
0
  else if (!strcmp(cleanup_arg, "verbatim"))
698
0
    return COMMIT_MSG_CLEANUP_NONE;
699
0
  else if (!strcmp(cleanup_arg, "whitespace"))
700
0
    return COMMIT_MSG_CLEANUP_SPACE;
701
0
  else if (!strcmp(cleanup_arg, "strip"))
702
0
    return COMMIT_MSG_CLEANUP_ALL;
703
0
  else if (!strcmp(cleanup_arg, "scissors"))
704
0
    return use_editor ? COMMIT_MSG_CLEANUP_SCISSORS :
705
0
            COMMIT_MSG_CLEANUP_SPACE;
706
0
  else
707
0
    die(_("Invalid cleanup mode %s"), cleanup_arg);
708
0
}
709
710
/*
711
 * NB using int rather than enum cleanup_mode to stop clang's
712
 * -Wtautological-constant-out-of-range-compare complaining that the comparison
713
 * is always true.
714
 */
715
static const char *describe_cleanup_mode(int cleanup_mode)
716
0
{
717
0
  static const char *modes[] = { "whitespace",
718
0
               "verbatim",
719
0
               "scissors",
720
0
               "strip" };
721
722
0
  if (cleanup_mode < ARRAY_SIZE(modes))
723
0
    return modes[cleanup_mode];
724
725
0
  BUG("invalid cleanup_mode provided (%d)", cleanup_mode);
726
0
}
727
728
void append_conflicts_hint(struct index_state *istate,
729
  struct strbuf *msgbuf, enum commit_msg_cleanup_mode cleanup_mode)
730
0
{
731
0
  int i;
732
733
0
  if (cleanup_mode == COMMIT_MSG_CLEANUP_SCISSORS) {
734
0
    strbuf_addch(msgbuf, '\n');
735
0
    wt_status_append_cut_line(msgbuf);
736
0
    strbuf_addstr(msgbuf, comment_line_str);
737
0
  }
738
739
0
  strbuf_addch(msgbuf, '\n');
740
0
  strbuf_commented_addf(msgbuf, comment_line_str, "Conflicts:\n");
741
0
  for (i = 0; i < istate->cache_nr;) {
742
0
    const struct cache_entry *ce = istate->cache[i++];
743
0
    if (ce_stage(ce)) {
744
0
      strbuf_commented_addf(msgbuf, comment_line_str,
745
0
                "\t%s\n", ce->name);
746
0
      while (i < istate->cache_nr &&
747
0
             !strcmp(ce->name, istate->cache[i]->name))
748
0
        i++;
749
0
    }
750
0
  }
751
0
}
752
753
static int do_recursive_merge(struct repository *r,
754
            struct commit *base, struct commit *next,
755
            const char *base_label, const char *next_label,
756
            struct object_id *head, struct strbuf *msgbuf,
757
            struct replay_opts *opts)
758
0
{
759
0
  struct merge_options o;
760
0
  struct merge_result result;
761
0
  struct tree *next_tree, *base_tree, *head_tree;
762
0
  int clean, show_output;
763
0
  int i;
764
0
  struct lock_file index_lock = LOCK_INIT;
765
766
0
  if (repo_hold_locked_index(r, &index_lock, LOCK_REPORT_ON_ERROR) < 0)
767
0
    return -1;
768
769
0
  repo_read_index(r);
770
771
0
  init_ui_merge_options(&o, r);
772
0
  o.ancestor = base ? base_label : "(empty tree)";
773
0
  o.branch1 = "HEAD";
774
0
  o.branch2 = next ? next_label : "(empty tree)";
775
0
  if (is_rebase_i(opts))
776
0
    o.buffer_output = 2;
777
0
  o.show_rename_progress = 1;
778
779
0
  head_tree = repo_parse_tree_indirect(the_repository, head);
780
0
  if (!head_tree)
781
0
    return error(_("unable to read tree (%s)"), oid_to_hex(head));
782
0
  next_tree = next ? repo_get_commit_tree(r, next) : empty_tree(r);
783
0
  base_tree = base ? repo_get_commit_tree(r, base) : empty_tree(r);
784
785
0
  for (i = 0; i < opts->xopts.nr; i++)
786
0
    parse_merge_opt(&o, opts->xopts.v[i]);
787
788
0
  memset(&result, 0, sizeof(result));
789
0
  merge_incore_nonrecursive(&o, base_tree, head_tree, next_tree, &result);
790
0
  show_output = !is_rebase_i(opts) || !result.clean;
791
  /*
792
   * TODO: merge_switch_to_result will update index/working tree;
793
   * we only really want to do that if !result.clean || this is
794
   * the final patch to be picked.  But determining this is the
795
   * final patch would take some work, and "head_tree" would need
796
   * to be replace with the tree the index matched before we
797
   * started doing any picks.
798
   */
799
0
  merge_switch_to_result(&o, head_tree, &result, 1, show_output);
800
0
  clean = result.clean;
801
0
  if (clean < 0) {
802
0
    rollback_lock_file(&index_lock);
803
0
    return clean;
804
0
  }
805
806
0
  if (write_locked_index(r->index, &index_lock,
807
0
             COMMIT_LOCK | SKIP_IF_UNCHANGED))
808
    /*
809
     * TRANSLATORS: %s will be "revert", "cherry-pick" or
810
     * "rebase".
811
     */
812
0
    return error(_("%s: Unable to write new index file"),
813
0
      _(action_name(opts)));
814
815
0
  if (!clean)
816
0
    append_conflicts_hint(r->index, msgbuf,
817
0
              opts->default_msg_cleanup);
818
819
0
  return !clean;
820
0
}
821
822
static struct object_id *get_cache_tree_oid(struct index_state *istate)
823
0
{
824
0
  if (!cache_tree_fully_valid(istate))
825
0
    if (cache_tree_update(istate, 0)) {
826
0
      error(_("unable to update cache tree"));
827
0
      return NULL;
828
0
    }
829
830
0
  return &istate->cache_tree->oid;
831
0
}
832
833
static int is_index_unchanged(struct repository *r)
834
0
{
835
0
  struct object_id head_oid, *cache_tree_oid;
836
0
  const struct object_id *head_tree_oid;
837
0
  struct commit *head_commit;
838
0
  struct index_state *istate = r->index;
839
0
  const char *head_name;
840
841
0
  if (!refs_resolve_ref_unsafe(get_main_ref_store(the_repository), "HEAD", RESOLVE_REF_READING, &head_oid, NULL)) {
842
    /* Check to see if this is an unborn branch */
843
0
    head_name = refs_resolve_ref_unsafe(get_main_ref_store(the_repository),
844
0
                "HEAD",
845
0
                RESOLVE_REF_READING | RESOLVE_REF_NO_RECURSE,
846
0
                &head_oid, NULL);
847
0
    if (!head_name ||
848
0
      !starts_with(head_name, "refs/heads/") ||
849
0
      !is_null_oid(&head_oid))
850
0
      return error(_("could not resolve HEAD commit"));
851
0
    head_tree_oid = the_hash_algo->empty_tree;
852
0
  } else {
853
0
    head_commit = lookup_commit(r, &head_oid);
854
855
    /*
856
     * If head_commit is NULL, check_commit, called from
857
     * lookup_commit, would have indicated that head_commit is not
858
     * a commit object already.  repo_parse_commit() will return failure
859
     * without further complaints in such a case.  Otherwise, if
860
     * the commit is invalid, repo_parse_commit() will complain.  So
861
     * there is nothing for us to say here.  Just return failure.
862
     */
863
0
    if (repo_parse_commit(r, head_commit))
864
0
      return -1;
865
866
0
    head_tree_oid = get_commit_tree_oid(head_commit);
867
0
  }
868
869
0
  if (!(cache_tree_oid = get_cache_tree_oid(istate)))
870
0
    return -1;
871
872
0
  return oideq(cache_tree_oid, head_tree_oid);
873
0
}
874
875
static int write_author_script(const char *message)
876
0
{
877
0
  struct strbuf buf = STRBUF_INIT;
878
0
  const char *eol;
879
0
  int res;
880
881
0
  for (;;)
882
0
    if (!*message || starts_with(message, "\n")) {
883
0
missing_author:
884
      /* Missing 'author' line? */
885
0
      unlink(rebase_path_author_script());
886
0
      return 0;
887
0
    } else if (skip_prefix(message, "author ", &message))
888
0
      break;
889
0
    else if ((eol = strchr(message, '\n')))
890
0
      message = eol + 1;
891
0
    else
892
0
      goto missing_author;
893
894
0
  strbuf_addstr(&buf, "GIT_AUTHOR_NAME='");
895
0
  while (*message && *message != '\n' && *message != '\r')
896
0
    if (skip_prefix(message, " <", &message))
897
0
      break;
898
0
    else if (*message != '\'')
899
0
      strbuf_addch(&buf, *(message++));
900
0
    else
901
0
      strbuf_addf(&buf, "'\\%c'", *(message++));
902
0
  strbuf_addstr(&buf, "'\nGIT_AUTHOR_EMAIL='");
903
0
  while (*message && *message != '\n' && *message != '\r')
904
0
    if (skip_prefix(message, "> ", &message))
905
0
      break;
906
0
    else if (*message != '\'')
907
0
      strbuf_addch(&buf, *(message++));
908
0
    else
909
0
      strbuf_addf(&buf, "'\\%c'", *(message++));
910
0
  strbuf_addstr(&buf, "'\nGIT_AUTHOR_DATE='@");
911
0
  while (*message && *message != '\n' && *message != '\r')
912
0
    if (*message != '\'')
913
0
      strbuf_addch(&buf, *(message++));
914
0
    else
915
0
      strbuf_addf(&buf, "'\\%c'", *(message++));
916
0
  strbuf_addch(&buf, '\'');
917
0
  res = write_message(buf.buf, buf.len, rebase_path_author_script(), 1);
918
0
  strbuf_release(&buf);
919
0
  return res;
920
0
}
921
922
/**
923
 * Take a series of KEY='VALUE' lines where VALUE part is
924
 * sq-quoted, and append <KEY, VALUE> at the end of the string list
925
 */
926
static int parse_key_value_squoted(char *buf, struct string_list *list)
927
0
{
928
0
  while (*buf) {
929
0
    struct string_list_item *item;
930
0
    char *np;
931
0
    char *cp = strchr(buf, '=');
932
0
    if (!cp) {
933
0
      np = strchrnul(buf, '\n');
934
0
      return error(_("no key present in '%.*s'"),
935
0
             (int) (np - buf), buf);
936
0
    }
937
0
    np = strchrnul(cp, '\n');
938
0
    *cp++ = '\0';
939
0
    item = string_list_append(list, buf);
940
941
0
    buf = np + (*np == '\n');
942
0
    *np = '\0';
943
0
    cp = sq_dequote(cp);
944
0
    if (!cp)
945
0
      return error(_("unable to dequote value of '%s'"),
946
0
             item->string);
947
0
    item->util = xstrdup(cp);
948
0
  }
949
0
  return 0;
950
0
}
951
952
/**
953
 * Reads and parses the state directory's "author-script" file, and sets name,
954
 * email and date accordingly.
955
 * Returns 0 on success, -1 if the file could not be parsed.
956
 *
957
 * The author script is of the format:
958
 *
959
 *  GIT_AUTHOR_NAME='$author_name'
960
 *  GIT_AUTHOR_EMAIL='$author_email'
961
 *  GIT_AUTHOR_DATE='$author_date'
962
 *
963
 * where $author_name, $author_email and $author_date are quoted. We are strict
964
 * with our parsing, as the file was meant to be eval'd in the now-removed
965
 * git-am.sh/git-rebase--interactive.sh scripts, and thus if the file differs
966
 * from what this function expects, it is better to bail out than to do
967
 * something that the user does not expect.
968
 */
969
int read_author_script(const char *path, char **name, char **email, char **date,
970
           int allow_missing)
971
0
{
972
0
  struct strbuf buf = STRBUF_INIT;
973
0
  struct string_list kv = STRING_LIST_INIT_DUP;
974
0
  int retval = -1; /* assume failure */
975
0
  int i, name_i = -2, email_i = -2, date_i = -2, err = 0;
976
977
0
  if (strbuf_read_file(&buf, path, 256) <= 0) {
978
0
    strbuf_release(&buf);
979
0
    if (errno == ENOENT && allow_missing)
980
0
      return 0;
981
0
    else
982
0
      return error_errno(_("could not open '%s' for reading"),
983
0
             path);
984
0
  }
985
986
0
  if (parse_key_value_squoted(buf.buf, &kv))
987
0
    goto finish;
988
989
0
  for (i = 0; i < kv.nr; i++) {
990
0
    if (!strcmp(kv.items[i].string, "GIT_AUTHOR_NAME")) {
991
0
      if (name_i != -2)
992
0
        name_i = error(_("'GIT_AUTHOR_NAME' already given"));
993
0
      else
994
0
        name_i = i;
995
0
    } else if (!strcmp(kv.items[i].string, "GIT_AUTHOR_EMAIL")) {
996
0
      if (email_i != -2)
997
0
        email_i = error(_("'GIT_AUTHOR_EMAIL' already given"));
998
0
      else
999
0
        email_i = i;
1000
0
    } else if (!strcmp(kv.items[i].string, "GIT_AUTHOR_DATE")) {
1001
0
      if (date_i != -2)
1002
0
        date_i = error(_("'GIT_AUTHOR_DATE' already given"));
1003
0
      else
1004
0
        date_i = i;
1005
0
    } else {
1006
0
      err = error(_("unknown variable '%s'"),
1007
0
            kv.items[i].string);
1008
0
    }
1009
0
  }
1010
0
  if (name_i == -2)
1011
0
    error(_("missing 'GIT_AUTHOR_NAME'"));
1012
0
  if (email_i == -2)
1013
0
    error(_("missing 'GIT_AUTHOR_EMAIL'"));
1014
0
  if (date_i == -2)
1015
0
    error(_("missing 'GIT_AUTHOR_DATE'"));
1016
0
  if (name_i < 0 || email_i < 0 || date_i < 0 || err)
1017
0
    goto finish;
1018
0
  *name = kv.items[name_i].util;
1019
0
  *email = kv.items[email_i].util;
1020
0
  *date = kv.items[date_i].util;
1021
0
  retval = 0;
1022
0
finish:
1023
0
  string_list_clear(&kv, !!retval);
1024
0
  strbuf_release(&buf);
1025
0
  return retval;
1026
0
}
1027
1028
/*
1029
 * Read a GIT_AUTHOR_NAME, GIT_AUTHOR_EMAIL AND GIT_AUTHOR_DATE from a
1030
 * file with shell quoting into struct strvec. Returns -1 on
1031
 * error, 0 otherwise.
1032
 */
1033
static int read_env_script(struct strvec *env)
1034
0
{
1035
0
  char *name, *email, *date;
1036
1037
0
  if (read_author_script(rebase_path_author_script(),
1038
0
             &name, &email, &date, 0))
1039
0
    return -1;
1040
1041
0
  strvec_pushf(env, "GIT_AUTHOR_NAME=%s", name);
1042
0
  strvec_pushf(env, "GIT_AUTHOR_EMAIL=%s", email);
1043
0
  strvec_pushf(env, "GIT_AUTHOR_DATE=%s", date);
1044
0
  free(name);
1045
0
  free(email);
1046
0
  free(date);
1047
1048
0
  return 0;
1049
0
}
1050
1051
static char *get_author(const char *message)
1052
0
{
1053
0
  size_t len;
1054
0
  const char *a;
1055
1056
0
  a = find_commit_header(message, "author", &len);
1057
0
  if (a)
1058
0
    return xmemdupz(a, len);
1059
1060
0
  return NULL;
1061
0
}
1062
1063
static const char *author_date_from_env(const struct strvec *env)
1064
0
{
1065
0
  int i;
1066
0
  const char *date;
1067
1068
0
  for (i = 0; i < env->nr; i++)
1069
0
    if (skip_prefix(env->v[i],
1070
0
        "GIT_AUTHOR_DATE=", &date))
1071
0
      return date;
1072
  /*
1073
   * If GIT_AUTHOR_DATE is missing we should have already errored out when
1074
   * reading the script
1075
   */
1076
0
  BUG("GIT_AUTHOR_DATE missing from author script");
1077
0
}
1078
1079
static const char staged_changes_advice[] =
1080
N_("you have staged changes in your working tree\n"
1081
"If these changes are meant to be squashed into the previous commit, run:\n"
1082
"\n"
1083
"  git commit --amend %s\n"
1084
"\n"
1085
"If they are meant to go into a new commit, run:\n"
1086
"\n"
1087
"  git commit %s\n"
1088
"\n"
1089
"In both cases, once you're done, continue with:\n"
1090
"\n"
1091
"  git rebase --continue\n");
1092
1093
0
#define ALLOW_EMPTY (1<<0)
1094
0
#define EDIT_MSG    (1<<1)
1095
0
#define AMEND_MSG   (1<<2)
1096
0
#define CLEANUP_MSG (1<<3)
1097
0
#define VERIFY_MSG  (1<<4)
1098
0
#define CREATE_ROOT_COMMIT (1<<5)
1099
1100
static int run_command_silent_on_success(struct child_process *cmd)
1101
0
{
1102
0
  struct strbuf buf = STRBUF_INIT;
1103
0
  int rc;
1104
1105
0
  cmd->stdout_to_stderr = 1;
1106
0
  rc = pipe_command(cmd,
1107
0
        NULL, 0,
1108
0
        NULL, 0,
1109
0
        &buf, 0);
1110
1111
0
  if (rc)
1112
0
    fputs(buf.buf, stderr);
1113
0
  strbuf_release(&buf);
1114
0
  return rc;
1115
0
}
1116
1117
/*
1118
 * Don't let the commands we spawn run auto maintenance. It would race
1119
 * us for MERGE_RR.lock or delete packs we still have open. Our caller
1120
 * runs it once the sequence is done.
1121
 */
1122
static void disable_auto_maintenance(struct replay_opts *opts,
1123
             struct child_process *cmd)
1124
0
{
1125
0
  if (!opts->ctx->config_parameters) {
1126
0
    const char *old = getenv(CONFIG_DATA_ENVIRONMENT);
1127
0
    struct strbuf buf = STRBUF_INIT;
1128
1129
0
    if (old && *old)
1130
0
      strbuf_addstr(&buf, old);
1131
0
    git_config_append_parameter(&buf, "maintenance.auto", "false");
1132
0
    opts->ctx->config_parameters = strbuf_detach(&buf, NULL);
1133
0
  }
1134
0
  strvec_pushf(&cmd->env, "%s=%s", CONFIG_DATA_ENVIRONMENT,
1135
0
         opts->ctx->config_parameters);
1136
0
}
1137
1138
/*
1139
 * If we are cherry-pick, and if the merge did not result in
1140
 * hand-editing, we will hit this commit and inherit the original
1141
 * author date and name.
1142
 *
1143
 * If we are revert, or if our cherry-pick results in a hand merge,
1144
 * we had better say that the current user is responsible for that.
1145
 *
1146
 * An exception is when run_git_commit() is called during an
1147
 * interactive rebase: in that case, we will want to retain the
1148
 * author metadata.
1149
 */
1150
static int run_git_commit(const char *defmsg,
1151
        const char *reflog_action,
1152
        struct replay_opts *opts,
1153
        unsigned int flags)
1154
0
{
1155
0
  struct child_process cmd = CHILD_PROCESS_INIT;
1156
1157
0
  cmd.git_cmd = 1;
1158
0
  cmd.odb_to_close = the_repository->objects;
1159
1160
0
  if (is_rebase_i(opts) &&
1161
0
      ((opts->committer_date_is_author_date && !opts->ignore_date) ||
1162
0
       !(!defmsg && (flags & AMEND_MSG))) &&
1163
0
      read_env_script(&cmd.env)) {
1164
0
    const char *gpg_opt = gpg_sign_opt_quoted(opts);
1165
1166
0
    return error(_(staged_changes_advice),
1167
0
           gpg_opt, gpg_opt);
1168
0
  }
1169
1170
0
  strvec_pushf(&cmd.env, GIT_REFLOG_ACTION "=%s", reflog_action);
1171
1172
0
  if (opts->committer_date_is_author_date)
1173
0
    strvec_pushf(&cmd.env, "GIT_COMMITTER_DATE=%s",
1174
0
           opts->ignore_date ?
1175
0
           "" :
1176
0
           author_date_from_env(&cmd.env));
1177
0
  if (opts->ignore_date)
1178
0
    strvec_push(&cmd.env, "GIT_AUTHOR_DATE=");
1179
0
  disable_auto_maintenance(opts, &cmd);
1180
1181
0
  strvec_push(&cmd.args, "commit");
1182
1183
0
  if (!(flags & VERIFY_MSG))
1184
0
    strvec_push(&cmd.args, "-n");
1185
0
  if ((flags & AMEND_MSG))
1186
0
    strvec_push(&cmd.args, "--amend");
1187
0
  if (opts->gpg_sign)
1188
0
    strvec_pushf(&cmd.args, "-S%s", opts->gpg_sign);
1189
0
  else
1190
0
    strvec_push(&cmd.args, "--no-gpg-sign");
1191
0
  if (defmsg)
1192
0
    strvec_pushl(&cmd.args, "-F", defmsg, NULL);
1193
0
  else if (!(flags & EDIT_MSG))
1194
0
    strvec_pushl(&cmd.args, "-C", "HEAD", NULL);
1195
0
  if ((flags & CLEANUP_MSG))
1196
0
    strvec_push(&cmd.args, "--cleanup=strip");
1197
0
  if ((flags & EDIT_MSG))
1198
0
    strvec_push(&cmd.args, "-e");
1199
0
  else if (!(flags & CLEANUP_MSG) &&
1200
0
     !opts->signoff && !opts->record_origin &&
1201
0
     !opts->explicit_cleanup)
1202
0
    strvec_push(&cmd.args, "--cleanup=verbatim");
1203
1204
0
  if ((flags & ALLOW_EMPTY))
1205
0
    strvec_push(&cmd.args, "--allow-empty");
1206
1207
0
  if (!(flags & EDIT_MSG))
1208
0
    strvec_push(&cmd.args, "--allow-empty-message");
1209
1210
0
  if (is_rebase_i(opts) && !(flags & EDIT_MSG))
1211
0
    return run_command_silent_on_success(&cmd);
1212
0
  else
1213
0
    return run_command(&cmd);
1214
0
}
1215
1216
static int rest_is_empty(const struct strbuf *sb, int start)
1217
0
{
1218
0
  int i, eol;
1219
0
  const char *nl;
1220
1221
  /* Check if the rest is just whitespace and Signed-off-by's. */
1222
0
  for (i = start; i < sb->len; i++) {
1223
0
    nl = memchr(sb->buf + i, '\n', sb->len - i);
1224
0
    if (nl)
1225
0
      eol = nl - sb->buf;
1226
0
    else
1227
0
      eol = sb->len;
1228
1229
0
    if (strlen(sign_off_header) <= eol - i &&
1230
0
        starts_with(sb->buf + i, sign_off_header)) {
1231
0
      i = eol;
1232
0
      continue;
1233
0
    }
1234
0
    while (i < eol)
1235
0
      if (!isspace(sb->buf[i++]))
1236
0
        return 0;
1237
0
  }
1238
1239
0
  return 1;
1240
0
}
1241
1242
void cleanup_message(struct strbuf *msgbuf,
1243
  enum commit_msg_cleanup_mode cleanup_mode, int verbose)
1244
0
{
1245
0
  if (verbose || /* Truncate the message just before the diff, if any. */
1246
0
      cleanup_mode == COMMIT_MSG_CLEANUP_SCISSORS)
1247
0
    strbuf_setlen(msgbuf, wt_status_locate_end(msgbuf->buf, msgbuf->len));
1248
0
  if (cleanup_mode != COMMIT_MSG_CLEANUP_NONE)
1249
0
    strbuf_stripspace(msgbuf,
1250
0
      cleanup_mode == COMMIT_MSG_CLEANUP_ALL ? comment_line_str : NULL);
1251
0
}
1252
1253
/*
1254
 * Find out if the message in the strbuf contains only whitespace and
1255
 * Signed-off-by lines.
1256
 */
1257
int message_is_empty(const struct strbuf *sb,
1258
         enum commit_msg_cleanup_mode cleanup_mode)
1259
0
{
1260
0
  if (cleanup_mode == COMMIT_MSG_CLEANUP_NONE && sb->len)
1261
0
    return 0;
1262
0
  return rest_is_empty(sb, 0);
1263
0
}
1264
1265
/*
1266
 * See if the user edited the message in the editor or left what
1267
 * was in the template intact
1268
 */
1269
int template_untouched(const struct strbuf *sb, const char *template_file,
1270
           enum commit_msg_cleanup_mode cleanup_mode)
1271
0
{
1272
0
  struct strbuf tmpl = STRBUF_INIT;
1273
0
  const char *start;
1274
1275
0
  if (cleanup_mode == COMMIT_MSG_CLEANUP_NONE && sb->len)
1276
0
    return 0;
1277
1278
0
  if (!template_file || strbuf_read_file(&tmpl, template_file, 0) <= 0)
1279
0
    return 0;
1280
1281
0
  strbuf_stripspace(&tmpl,
1282
0
    cleanup_mode == COMMIT_MSG_CLEANUP_ALL ? comment_line_str : NULL);
1283
0
  if (!skip_prefix(sb->buf, tmpl.buf, &start))
1284
0
    start = sb->buf;
1285
0
  strbuf_release(&tmpl);
1286
0
  return rest_is_empty(sb, start - sb->buf);
1287
0
}
1288
1289
int update_head_with_reflog(const struct commit *old_head,
1290
          const struct object_id *new_head,
1291
          const char *action, const struct strbuf *msg,
1292
          struct strbuf *err)
1293
0
{
1294
0
  struct ref_transaction *transaction;
1295
0
  struct strbuf sb = STRBUF_INIT;
1296
0
  const char *nl;
1297
0
  int ret = 0;
1298
1299
0
  if (action) {
1300
0
    strbuf_addstr(&sb, action);
1301
0
    strbuf_addstr(&sb, ": ");
1302
0
  }
1303
1304
0
  nl = strchr(msg->buf, '\n');
1305
0
  if (nl) {
1306
0
    strbuf_add(&sb, msg->buf, nl + 1 - msg->buf);
1307
0
  } else {
1308
0
    strbuf_addbuf(&sb, msg);
1309
0
    strbuf_addch(&sb, '\n');
1310
0
  }
1311
1312
0
  transaction = ref_store_transaction_begin(get_main_ref_store(the_repository),
1313
0
              0, err);
1314
0
  if (!transaction ||
1315
0
      ref_transaction_update(transaction, "HEAD", new_head,
1316
0
           old_head ? &old_head->object.oid : null_oid(the_hash_algo),
1317
0
           NULL, NULL, 0, sb.buf, err) ||
1318
0
      ref_transaction_commit(transaction, err)) {
1319
0
    ret = -1;
1320
0
  }
1321
0
  ref_transaction_free(transaction);
1322
0
  strbuf_release(&sb);
1323
1324
0
  return ret;
1325
0
}
1326
1327
static int pipe_from_strbuf(int hook_stdin_fd, void *pp_cb, void *pp_task_cb UNUSED)
1328
0
{
1329
0
  struct hook_cb_data *hook_cb = pp_cb;
1330
0
  struct strbuf *to_pipe = hook_cb->options->feed_pipe_ctx;
1331
0
  int ret;
1332
1333
0
  if (!to_pipe)
1334
0
    BUG("pipe_from_strbuf called without feed_pipe_ctx");
1335
1336
0
  ret = write_in_full(hook_stdin_fd, to_pipe->buf, to_pipe->len);
1337
0
  if (ret < 0 && errno != EPIPE)
1338
0
    return ret;
1339
1340
0
  return 1; /* done writing */
1341
0
}
1342
1343
static int run_rewrite_hook(const struct object_id *oldoid,
1344
          const struct object_id *newoid)
1345
0
{
1346
0
  struct run_hooks_opt opt = RUN_HOOKS_OPT_INIT;
1347
0
  int code;
1348
0
  struct strbuf sb = STRBUF_INIT;
1349
1350
0
  strbuf_addf(&sb, "%s %s\n", oid_to_hex(oldoid), oid_to_hex(newoid));
1351
1352
0
  opt.feed_pipe_ctx = &sb;
1353
0
  opt.feed_pipe = pipe_from_strbuf;
1354
1355
0
  strvec_push(&opt.args, "amend");
1356
1357
0
  code = run_hooks_opt(the_repository, "post-rewrite", &opt);
1358
1359
0
  strbuf_release(&sb);
1360
0
  return code;
1361
0
}
1362
1363
void commit_post_rewrite(struct repository *r,
1364
       const struct commit *old_head,
1365
       const struct object_id *new_head)
1366
0
{
1367
0
  struct notes_rewrite_cfg *cfg;
1368
1369
0
  cfg = init_copy_notes_for_rewrite("amend");
1370
0
  if (cfg) {
1371
    /* we are amending, so old_head is not NULL */
1372
0
    copy_note_for_rewrite(cfg, &old_head->object.oid, new_head);
1373
0
    finish_copy_notes_for_rewrite(r, cfg, "Notes added by 'git commit --amend'");
1374
0
  }
1375
0
  run_rewrite_hook(&old_head->object.oid, new_head);
1376
0
}
1377
1378
static int run_prepare_commit_msg_hook(struct repository *r,
1379
               struct strbuf *msg,
1380
               const char *commit)
1381
0
{
1382
0
  int ret = 0;
1383
0
  const char *name, *arg1 = NULL, *arg2 = NULL;
1384
1385
0
  name = git_path_commit_editmsg();
1386
0
  if (write_message(msg->buf, msg->len, name, 0))
1387
0
    return -1;
1388
1389
0
  if (commit) {
1390
0
    arg1 = "commit";
1391
0
    arg2 = commit;
1392
0
  } else {
1393
0
    arg1 = "message";
1394
0
  }
1395
0
  if (run_commit_hook(0, r->index_file, NULL, "prepare-commit-msg", name,
1396
0
          arg1, arg2, NULL))
1397
0
    ret = error(_("'prepare-commit-msg' hook failed"));
1398
1399
0
  return ret;
1400
0
}
1401
1402
static const char implicit_ident_advice_noconfig[] =
1403
N_("Your name and email address were configured automatically based\n"
1404
"on your username and hostname. Please check that they are accurate.\n"
1405
"You can suppress this message by setting them explicitly. Run the\n"
1406
"following command and follow the instructions in your editor to edit\n"
1407
"your configuration file:\n"
1408
"\n"
1409
"    git config --global --edit\n"
1410
"\n"
1411
"After doing this, you may fix the identity used for this commit with:\n"
1412
"\n"
1413
"    git commit --amend --reset-author\n");
1414
1415
static const char implicit_ident_advice_config[] =
1416
N_("Your name and email address were configured automatically based\n"
1417
"on your username and hostname. Please check that they are accurate.\n"
1418
"You can suppress this message by setting them explicitly:\n"
1419
"\n"
1420
"    git config --global user.name \"Your Name\"\n"
1421
"    git config --global user.email you@example.com\n"
1422
"\n"
1423
"After doing this, you may fix the identity used for this commit with:\n"
1424
"\n"
1425
"    git commit --amend --reset-author\n");
1426
1427
static const char *implicit_ident_advice(void)
1428
0
{
1429
0
  char *user_config = interpolate_path("~/.gitconfig", 0);
1430
0
  char *xdg_config = xdg_config_home("config");
1431
0
  int config_exists = file_exists(user_config) || file_exists(xdg_config);
1432
1433
0
  free(user_config);
1434
0
  free(xdg_config);
1435
1436
0
  if (config_exists)
1437
0
    return _(implicit_ident_advice_config);
1438
0
  else
1439
0
    return _(implicit_ident_advice_noconfig);
1440
1441
0
}
1442
1443
void print_commit_summary(struct repository *r,
1444
        const char *prefix,
1445
        const struct object_id *oid,
1446
        unsigned int flags)
1447
0
{
1448
0
  struct rev_info rev;
1449
0
  struct commit *commit;
1450
0
  struct strbuf format = STRBUF_INIT;
1451
0
  const char *head;
1452
0
  struct pretty_print_context pctx = {0};
1453
0
  struct strbuf author_ident = STRBUF_INIT;
1454
0
  struct strbuf committer_ident = STRBUF_INIT;
1455
0
  struct ref_store *refs;
1456
1457
0
  commit = lookup_commit(r, oid);
1458
0
  if (!commit)
1459
0
    die(_("couldn't look up newly created commit"));
1460
0
  if (repo_parse_commit(r, commit))
1461
0
    die(_("could not parse newly created commit"));
1462
1463
0
  strbuf_addstr(&format, "format:%h] %s");
1464
1465
0
  repo_format_commit_message(r, commit, "%an <%ae>", &author_ident,
1466
0
           &pctx);
1467
0
  repo_format_commit_message(r, commit, "%cn <%ce>", &committer_ident,
1468
0
           &pctx);
1469
0
  if (strbuf_cmp(&author_ident, &committer_ident)) {
1470
0
    strbuf_addstr(&format, "\n Author: ");
1471
0
    strbuf_addbuf_percentquote(&format, &author_ident);
1472
0
  }
1473
0
  if (flags & SUMMARY_SHOW_AUTHOR_DATE) {
1474
0
    struct strbuf date = STRBUF_INIT;
1475
1476
0
    repo_format_commit_message(r, commit, "%ad", &date, &pctx);
1477
0
    strbuf_addstr(&format, "\n Date: ");
1478
0
    strbuf_addbuf_percentquote(&format, &date);
1479
0
    strbuf_release(&date);
1480
0
  }
1481
0
  if (!committer_ident_sufficiently_given()) {
1482
0
    strbuf_addstr(&format, "\n Committer: ");
1483
0
    strbuf_addbuf_percentquote(&format, &committer_ident);
1484
0
    if (advice_enabled(ADVICE_IMPLICIT_IDENTITY)) {
1485
0
      strbuf_addch(&format, '\n');
1486
0
      strbuf_addstr(&format, implicit_ident_advice());
1487
0
    }
1488
0
  }
1489
0
  strbuf_release(&author_ident);
1490
0
  strbuf_release(&committer_ident);
1491
1492
0
  repo_init_revisions(r, &rev, prefix);
1493
0
  setup_revisions(0, NULL, &rev, NULL);
1494
1495
0
  rev.diff = 1;
1496
0
  rev.diffopt.output_format =
1497
0
    DIFF_FORMAT_SHORTSTAT | DIFF_FORMAT_SUMMARY;
1498
1499
0
  rev.verbose_header = 1;
1500
0
  rev.show_root_diff = 1;
1501
0
  get_commit_format(format.buf, &rev);
1502
0
  rev.always_show_header = 0;
1503
0
  rev.diffopt.detect_rename = DIFF_DETECT_RENAME;
1504
0
  diff_setup_done(&rev.diffopt);
1505
1506
0
  refs = get_main_ref_store(r);
1507
0
  head = refs_resolve_ref_unsafe(refs, "HEAD", 0, NULL, NULL);
1508
0
  if (!head)
1509
0
    die(_("unable to resolve HEAD after creating commit"));
1510
0
  if (!strcmp(head, "HEAD"))
1511
0
    head = _("detached HEAD");
1512
0
  else
1513
0
    skip_prefix(head, "refs/heads/", &head);
1514
0
  printf("[%s%s ", head, (flags & SUMMARY_INITIAL_COMMIT) ?
1515
0
            _(" (root-commit)") : "");
1516
1517
0
  if (!log_tree_commit(&rev, commit)) {
1518
0
    rev.always_show_header = 1;
1519
0
    rev.use_terminator = 1;
1520
0
    log_tree_commit(&rev, commit);
1521
0
  }
1522
1523
0
  release_revisions(&rev);
1524
0
  strbuf_release(&format);
1525
0
}
1526
1527
static int parse_head(struct repository *r, struct commit **head)
1528
0
{
1529
0
  struct commit *current_head;
1530
0
  struct object_id oid;
1531
1532
0
  if (repo_get_oid(r, "HEAD", &oid)) {
1533
0
    current_head = NULL;
1534
0
  } else {
1535
0
    current_head = lookup_commit_reference(r, &oid);
1536
0
    if (!current_head)
1537
0
      return error(_("could not parse HEAD"));
1538
0
    if (!oideq(&oid, &current_head->object.oid)) {
1539
0
      warning(_("HEAD %s is not a commit!"),
1540
0
        oid_to_hex(&oid));
1541
0
    }
1542
0
    if (repo_parse_commit(r, current_head))
1543
0
      return error(_("could not parse HEAD commit"));
1544
0
  }
1545
0
  *head = current_head;
1546
1547
0
  return 0;
1548
0
}
1549
1550
/*
1551
 * Try to commit without forking 'git commit'. In some cases we need
1552
 * to run 'git commit' to display an error message
1553
 *
1554
 * Returns:
1555
 *  -1 - error unable to commit
1556
 *   0 - success
1557
 *   1 - run 'git commit'
1558
 */
1559
static int try_to_commit(struct repository *r,
1560
       struct strbuf *msg, const char *author,
1561
       const char *reflog_action,
1562
       struct replay_opts *opts, unsigned int flags,
1563
       struct object_id *oid)
1564
0
{
1565
0
  struct object_id tree;
1566
0
  struct commit *current_head = NULL;
1567
0
  struct commit_list *parents = NULL;
1568
0
  struct commit_extra_header *extra = NULL;
1569
0
  struct strbuf err = STRBUF_INIT;
1570
0
  struct strbuf commit_msg = STRBUF_INIT;
1571
0
  char *amend_author = NULL;
1572
0
  const char *committer = NULL;
1573
0
  const char *hook_commit = NULL;
1574
0
  enum commit_msg_cleanup_mode cleanup;
1575
0
  int res = 0;
1576
1577
0
  if (parse_head(r, &current_head))
1578
0
    return -1;
1579
1580
0
  if (flags & AMEND_MSG) {
1581
0
    const char *exclude_gpgsig[] = { "gpgsig", "gpgsig-sha256", NULL };
1582
0
    const char *out_enc = get_commit_output_encoding();
1583
0
    const char *message = repo_logmsg_reencode(r, current_head,
1584
0
                 NULL, out_enc);
1585
1586
0
    if (!msg) {
1587
0
      const char *orig_message = NULL;
1588
1589
0
      find_commit_subject(message, &orig_message);
1590
0
      msg = &commit_msg;
1591
0
      strbuf_addstr(msg, orig_message);
1592
0
      hook_commit = "HEAD";
1593
0
    }
1594
0
    author = amend_author = get_author(message);
1595
0
    repo_unuse_commit_buffer(r, current_head,
1596
0
           message);
1597
0
    if (!author) {
1598
0
      res = error(_("unable to parse commit author"));
1599
0
      goto out;
1600
0
    }
1601
0
    parents = commit_list_copy(current_head->parents);
1602
0
    extra = read_commit_extra_headers(current_head, exclude_gpgsig);
1603
0
  } else if (current_head &&
1604
0
       (!(flags & CREATE_ROOT_COMMIT) || (flags & AMEND_MSG))) {
1605
0
    commit_list_insert(current_head, &parents);
1606
0
  }
1607
1608
0
  if (write_index_as_tree(&tree, r->index, r->index_file, 0, NULL)) {
1609
0
    res = error(_("git write-tree failed to write a tree"));
1610
0
    goto out;
1611
0
  }
1612
1613
0
  if (!(flags & ALLOW_EMPTY)) {
1614
0
    struct commit *first_parent = current_head;
1615
1616
0
    if (flags & AMEND_MSG) {
1617
0
      if (current_head->parents) {
1618
0
        first_parent = current_head->parents->item;
1619
0
        if (repo_parse_commit(r, first_parent)) {
1620
0
          res = error(_("could not parse HEAD commit"));
1621
0
          goto out;
1622
0
        }
1623
0
      } else {
1624
0
        first_parent = NULL;
1625
0
      }
1626
0
    }
1627
0
    if (oideq(first_parent
1628
0
        ? get_commit_tree_oid(first_parent)
1629
0
        : the_hash_algo->empty_tree,
1630
0
        &tree)) {
1631
0
      res = 1; /* run 'git commit' to display error message */
1632
0
      goto out;
1633
0
    }
1634
0
  }
1635
1636
0
  if (hook_exists(r, "prepare-commit-msg")) {
1637
0
    res = run_prepare_commit_msg_hook(r, msg, hook_commit);
1638
0
    if (res)
1639
0
      goto out;
1640
0
    if (strbuf_read_file(&commit_msg, git_path_commit_editmsg(),
1641
0
             2048) < 0) {
1642
0
      res = error_errno(_("unable to read commit message "
1643
0
                "from '%s'"),
1644
0
              git_path_commit_editmsg());
1645
0
      goto out;
1646
0
    }
1647
0
    msg = &commit_msg;
1648
0
  }
1649
1650
0
  if (flags & CLEANUP_MSG)
1651
0
    cleanup = COMMIT_MSG_CLEANUP_ALL;
1652
0
  else if ((opts->signoff || opts->record_origin) &&
1653
0
     !opts->explicit_cleanup)
1654
0
    cleanup = COMMIT_MSG_CLEANUP_SPACE;
1655
0
  else
1656
0
    cleanup = opts->default_msg_cleanup;
1657
1658
0
  if (cleanup != COMMIT_MSG_CLEANUP_NONE)
1659
0
    strbuf_stripspace(msg,
1660
0
      cleanup == COMMIT_MSG_CLEANUP_ALL ? comment_line_str : NULL);
1661
0
  if ((flags & EDIT_MSG) && message_is_empty(msg, cleanup)) {
1662
0
    res = 1; /* run 'git commit' to display error message */
1663
0
    goto out;
1664
0
  }
1665
1666
0
  if (opts->committer_date_is_author_date) {
1667
0
    struct ident_split id;
1668
0
    struct strbuf date = STRBUF_INIT;
1669
1670
0
    if (!opts->ignore_date) {
1671
0
      if (split_ident_line(&id, author, (int)strlen(author)) < 0) {
1672
0
        res = error(_("invalid author identity '%s'"),
1673
0
              author);
1674
0
        goto out;
1675
0
      }
1676
0
      if (!id.date_begin) {
1677
0
        res = error(_(
1678
0
          "corrupt author: missing date information"));
1679
0
        goto out;
1680
0
      }
1681
0
      strbuf_addf(&date, "@%.*s %.*s",
1682
0
            (int)(id.date_end - id.date_begin),
1683
0
            id.date_begin,
1684
0
            (int)(id.tz_end - id.tz_begin),
1685
0
            id.tz_begin);
1686
0
    } else {
1687
0
      reset_ident_date();
1688
0
    }
1689
0
    committer = fmt_ident(getenv("GIT_COMMITTER_NAME"),
1690
0
              getenv("GIT_COMMITTER_EMAIL"),
1691
0
              WANT_COMMITTER_IDENT,
1692
0
              opts->ignore_date ? NULL : date.buf,
1693
0
              IDENT_STRICT);
1694
0
    strbuf_release(&date);
1695
0
  } else {
1696
0
    reset_ident_date();
1697
0
  }
1698
1699
0
  if (opts->ignore_date) {
1700
0
    struct ident_split id;
1701
0
    char *name, *email;
1702
1703
0
    if (split_ident_line(&id, author, strlen(author)) < 0) {
1704
0
      error(_("invalid author identity '%s'"), author);
1705
0
      goto out;
1706
0
    }
1707
0
    name = xmemdupz(id.name_begin, id.name_end - id.name_begin);
1708
0
    email = xmemdupz(id.mail_begin, id.mail_end - id.mail_begin);
1709
0
    author = fmt_ident(name, email, WANT_AUTHOR_IDENT, NULL,
1710
0
           IDENT_STRICT);
1711
0
    free(name);
1712
0
    free(email);
1713
0
  }
1714
1715
0
  if (commit_tree_extended(msg->buf, msg->len, &tree, parents, oid,
1716
0
         author, committer, opts->gpg_sign, extra)) {
1717
0
    res = error(_("failed to write commit object"));
1718
0
    goto out;
1719
0
  }
1720
1721
0
  if (update_head_with_reflog(current_head, oid, reflog_action,
1722
0
            msg, &err)) {
1723
0
    res = error("%s", err.buf);
1724
0
    goto out;
1725
0
  }
1726
1727
0
  run_commit_hook(0, r->index_file, NULL, "post-commit", NULL);
1728
0
  if (flags & AMEND_MSG)
1729
0
    commit_post_rewrite(r, current_head, oid);
1730
1731
0
out:
1732
0
  free_commit_extra_headers(extra);
1733
0
  commit_list_free(parents);
1734
0
  strbuf_release(&err);
1735
0
  strbuf_release(&commit_msg);
1736
0
  free(amend_author);
1737
1738
0
  return res;
1739
0
}
1740
1741
static int write_rebase_head(struct object_id *oid)
1742
0
{
1743
0
  if (refs_update_ref(get_main_ref_store(the_repository), "rebase", "REBASE_HEAD", oid,
1744
0
          NULL, REF_NO_DEREF, UPDATE_REFS_MSG_ON_ERR))
1745
0
    return error(_("could not update %s"), "REBASE_HEAD");
1746
1747
0
  return 0;
1748
0
}
1749
1750
static int do_commit(struct repository *r,
1751
         const char *msg_file, const char *author,
1752
         const char *reflog_action,
1753
         struct replay_opts *opts, unsigned int flags,
1754
         struct object_id *oid)
1755
0
{
1756
0
  int res = 1;
1757
1758
0
  if (!(flags & EDIT_MSG) && !(flags & VERIFY_MSG)) {
1759
0
    struct object_id oid;
1760
0
    struct strbuf sb = STRBUF_INIT;
1761
1762
0
    if (msg_file && strbuf_read_file(&sb, msg_file, 2048) < 0)
1763
0
      return error_errno(_("unable to read commit message "
1764
0
               "from '%s'"),
1765
0
             msg_file);
1766
1767
0
    res = try_to_commit(r, msg_file ? &sb : NULL,
1768
0
            author, reflog_action, opts, flags, &oid);
1769
0
    strbuf_release(&sb);
1770
0
    if (!res) {
1771
0
      refs_delete_ref(get_main_ref_store(r), "",
1772
0
          "CHERRY_PICK_HEAD", NULL, REF_NO_DEREF);
1773
0
      unlink(git_path_merge_msg(r));
1774
0
      if (!is_rebase_i(opts))
1775
0
        print_commit_summary(r, NULL, &oid,
1776
0
            SUMMARY_SHOW_AUTHOR_DATE);
1777
0
      return res;
1778
0
    }
1779
0
  }
1780
0
  if (res == 1) {
1781
0
    if (is_rebase_i(opts) && oid)
1782
0
      if (write_rebase_head(oid))
1783
0
          return -1;
1784
0
    res = run_git_commit(msg_file, reflog_action, opts, flags);
1785
0
    if (!res && is_rebase_i(opts) && oid)
1786
0
      refs_delete_ref(get_main_ref_store(r), "", "REBASE_HEAD",
1787
0
          NULL, REF_NO_DEREF);
1788
0
  }
1789
1790
0
  return res;
1791
0
}
1792
1793
static int is_original_commit_empty(struct commit *commit)
1794
0
{
1795
0
  const struct object_id *ptree_oid;
1796
1797
0
  if (repo_parse_commit(the_repository, commit))
1798
0
    return error(_("could not parse commit %s"),
1799
0
           oid_to_hex(&commit->object.oid));
1800
0
  if (commit->parents) {
1801
0
    struct commit *parent = commit->parents->item;
1802
0
    if (repo_parse_commit(the_repository, parent))
1803
0
      return error(_("could not parse parent commit %s"),
1804
0
        oid_to_hex(&parent->object.oid));
1805
0
    ptree_oid = get_commit_tree_oid(parent);
1806
0
  } else {
1807
0
    ptree_oid = the_hash_algo->empty_tree; /* commit is root */
1808
0
  }
1809
1810
0
  return oideq(ptree_oid, get_commit_tree_oid(commit));
1811
0
}
1812
1813
/*
1814
 * Should empty commits be allowed?  Return status:
1815
 *    <0: Error in is_index_unchanged(r) or is_original_commit_empty(commit)
1816
 *     0: Halt on empty commit
1817
 *     1: Allow empty commit
1818
 *     2: Drop empty commit
1819
 */
1820
static int allow_empty(struct repository *r,
1821
           struct replay_opts *opts,
1822
           struct commit *commit)
1823
0
{
1824
0
  int index_unchanged, originally_empty;
1825
1826
  /*
1827
   * For a commit that is initially empty, allow_empty determines if it
1828
   * should be kept or not
1829
   *
1830
   * For a commit that becomes empty, keep_redundant_commits and
1831
   * drop_redundant_commits determine whether the commit should be kept or
1832
   * dropped. If neither is specified, halt.
1833
   */
1834
0
  index_unchanged = is_index_unchanged(r);
1835
0
  if (index_unchanged < 0)
1836
0
    return index_unchanged;
1837
0
  if (!index_unchanged)
1838
0
    return 0; /* we do not have to say --allow-empty */
1839
1840
0
  originally_empty = is_original_commit_empty(commit);
1841
0
  if (originally_empty < 0)
1842
0
    return originally_empty;
1843
0
  if (originally_empty)
1844
0
    return opts->allow_empty;
1845
0
  else if (opts->keep_redundant_commits)
1846
0
    return 1;
1847
0
  else if (opts->drop_redundant_commits)
1848
0
    return 2;
1849
0
  else
1850
0
    return 0;
1851
0
}
1852
1853
static struct {
1854
  char c;
1855
  const char *str;
1856
} todo_command_info[] = {
1857
  [TODO_PICK] = { 'p', "pick" },
1858
  [TODO_REVERT] = { 0,   "revert" },
1859
  [TODO_EDIT] = { 'e', "edit" },
1860
  [TODO_REWORD] = { 'r', "reword" },
1861
  [TODO_FIXUP] = { 'f', "fixup" },
1862
  [TODO_SQUASH] = { 's', "squash" },
1863
  [TODO_EXEC] = { 'x', "exec" },
1864
  [TODO_BREAK] = { 'b', "break" },
1865
  [TODO_LABEL] = { 'l', "label" },
1866
  [TODO_RESET] = { 't', "reset" },
1867
  [TODO_MERGE] = { 'm', "merge" },
1868
  [TODO_UPDATE_REF] = { 'u', "update-ref" },
1869
  [TODO_NOOP] = { 0,   "noop" },
1870
  [TODO_DROP] = { 'd', "drop" },
1871
  [TODO_COMMENT] = { 0,   NULL },
1872
};
1873
1874
static const char *command_to_string(const enum todo_command command)
1875
0
{
1876
0
  if (command < TODO_COMMENT)
1877
0
    return todo_command_info[command].str;
1878
0
  if (command == TODO_COMMENT)
1879
0
    return comment_line_str;
1880
0
  die(_("unknown command: %d"), command);
1881
0
}
1882
1883
static char command_to_char(const enum todo_command command)
1884
0
{
1885
0
  if (command < TODO_COMMENT)
1886
0
    return todo_command_info[command].c;
1887
0
  return 0;
1888
0
}
1889
1890
static int is_noop(const enum todo_command command)
1891
0
{
1892
0
  return TODO_NOOP <= command;
1893
0
}
1894
1895
static int is_fixup(enum todo_command command)
1896
0
{
1897
0
  return command == TODO_FIXUP || command == TODO_SQUASH;
1898
0
}
1899
1900
/* Does this command create a (non-merge) commit? */
1901
static int is_pick_or_similar(enum todo_command command)
1902
0
{
1903
0
  switch (command) {
1904
0
  case TODO_PICK:
1905
0
  case TODO_REVERT:
1906
0
  case TODO_EDIT:
1907
0
  case TODO_REWORD:
1908
0
  case TODO_FIXUP:
1909
0
  case TODO_SQUASH:
1910
0
    return 1;
1911
0
  default:
1912
0
    return 0;
1913
0
  }
1914
0
}
1915
1916
static const char first_commit_msg_str[] = N_("This is the 1st commit message:");
1917
static const char nth_commit_msg_fmt[] = N_("This is the commit message #%d:");
1918
static const char skip_first_commit_msg_str[] = N_("The 1st commit message will be skipped:");
1919
static const char skip_nth_commit_msg_fmt[] = N_("The commit message #%d will be skipped:");
1920
static const char combined_commit_msg_fmt[] = N_("This is a combination of %d commits.");
1921
1922
void add_squash_combination_header(struct strbuf *buf, int n)
1923
0
{
1924
0
  strbuf_addf(buf, "%s ", comment_line_str);
1925
0
  strbuf_addf(buf, _(combined_commit_msg_fmt), n);
1926
0
}
1927
1928
void add_squash_message_header(struct strbuf *buf, int n, int skip)
1929
0
{
1930
0
  strbuf_addf(buf, "%s ", comment_line_str);
1931
0
  if (n == 1)
1932
0
    strbuf_addstr(buf, skip ? _(skip_first_commit_msg_str) :
1933
0
           _(first_commit_msg_str));
1934
0
  else
1935
0
    strbuf_addf(buf, skip ? _(skip_nth_commit_msg_fmt) :
1936
0
          _(nth_commit_msg_fmt), n);
1937
0
}
1938
1939
size_t squash_subject_comment_len(const char *body, int squashing)
1940
0
{
1941
0
  if (starts_with(body, "amend!") ||
1942
0
      (squashing && (starts_with(body, "squash!") ||
1943
0
         starts_with(body, "fixup!"))))
1944
0
    return commit_subject_length(body);
1945
0
  return 0;
1946
0
}
1947
1948
static int is_fixup_flag(enum todo_command command, unsigned flag)
1949
0
{
1950
0
  return command == TODO_FIXUP && ((flag & TODO_REPLACE_FIXUP_MSG) ||
1951
0
           (flag & TODO_EDIT_FIXUP_MSG));
1952
0
}
1953
1954
/*
1955
 * Wrapper around strbuf_add_commented_lines() which avoids double
1956
 * commenting commit subjects.
1957
 */
1958
static void add_commented_lines(struct strbuf *buf, const void *str, size_t len)
1959
0
{
1960
0
  const char *s = str;
1961
0
  while (starts_with_mem(s, len, comment_line_str)) {
1962
0
    size_t count;
1963
0
    const char *n = memchr(s, '\n', len);
1964
0
    if (!n)
1965
0
      count = len;
1966
0
    else
1967
0
      count = n - s + 1;
1968
0
    strbuf_add(buf, s, count);
1969
0
    s += count;
1970
0
    len -= count;
1971
0
  }
1972
0
  strbuf_add_commented_lines(buf, s, len, comment_line_str);
1973
0
}
1974
1975
/* Does the current fixup chain contain a squash command? */
1976
static int seen_squash(struct replay_ctx *ctx)
1977
0
{
1978
0
  return starts_with(ctx->current_fixups.buf, "squash") ||
1979
0
    strstr(ctx->current_fixups.buf, "\nsquash");
1980
0
}
1981
1982
/* Does the current fixup chain contain a "fixup -c" command? */
1983
static int seen_fixup_edit_msg(struct replay_ctx *ctx)
1984
0
{
1985
0
  return starts_with(ctx->current_fixups.buf, "fixup -c") ||
1986
0
    strstr(ctx->current_fixups.buf, "\nfixup -c");
1987
0
}
1988
1989
static void update_comment_bufs(struct strbuf *buf1, struct strbuf *buf2, int n)
1990
0
{
1991
0
  strbuf_setlen(buf1, strlen(comment_line_str) + 1);
1992
0
  strbuf_addf(buf1, _(nth_commit_msg_fmt), n);
1993
0
  strbuf_addch(buf1, '\n');
1994
0
  strbuf_setlen(buf2, strlen(comment_line_str) + 1);
1995
0
  strbuf_addf(buf2, _(skip_nth_commit_msg_fmt), n);
1996
0
  strbuf_addch(buf2, '\n');
1997
0
}
1998
1999
/*
2000
 * Comment out any un-commented commit messages, updating the message comments
2001
 * to say they will be skipped but do not comment out the empty lines that
2002
 * surround commit messages and their comments.
2003
 */
2004
static void update_squash_message_for_fixup(struct strbuf *msg)
2005
0
{
2006
0
  void (*copy_lines)(struct strbuf *, const void *, size_t) = strbuf_add;
2007
0
  struct strbuf buf1 = STRBUF_INIT, buf2 = STRBUF_INIT;
2008
0
  const char *s, *start;
2009
0
  char *orig_msg;
2010
0
  size_t orig_msg_len;
2011
0
  int i = 1;
2012
2013
0
  strbuf_add_commented_lines(&buf1, _(first_commit_msg_str),
2014
0
           strlen(_(first_commit_msg_str)),
2015
0
           comment_line_str);
2016
0
  strbuf_add_commented_lines(&buf2, _(skip_first_commit_msg_str),
2017
0
           strlen(_(skip_first_commit_msg_str)),
2018
0
           comment_line_str);
2019
0
  s = start = orig_msg = strbuf_detach(msg, &orig_msg_len);
2020
0
  while (s) {
2021
0
    const char *next;
2022
0
    size_t off;
2023
0
    if (skip_prefix(s, buf1.buf, &next)) {
2024
      /*
2025
       * Copy the last message, preserving the blank line
2026
       * preceding the current line
2027
       */
2028
0
      off = (s > start + 1 && s[-2] == '\n') ? 1 : 0;
2029
0
      copy_lines(msg, start, s - start - off);
2030
0
      if (off)
2031
0
        strbuf_addch(msg, '\n');
2032
      /*
2033
       * The next message needs to be commented out but the
2034
       * message header is already commented out so just copy
2035
       * it and the blank line that follows it.
2036
       */
2037
0
      strbuf_addbuf(msg, &buf2);
2038
0
      if (*next == '\n')
2039
0
        strbuf_addch(msg, *next++);
2040
0
      start = s = next;
2041
0
      copy_lines = add_commented_lines;
2042
0
      update_comment_bufs(&buf1, &buf2, ++i);
2043
0
    } else if (skip_prefix(s, buf2.buf, &next)) {
2044
0
      off = (s > start + 1 && s[-2] == '\n') ? 1 : 0;
2045
0
      copy_lines(msg, start, s - start - off);
2046
0
      start = s - off;
2047
0
      s = next;
2048
0
      copy_lines = strbuf_add;
2049
0
      update_comment_bufs(&buf1, &buf2, ++i);
2050
0
    } else {
2051
0
      s = strchr(s, '\n');
2052
0
      if (s)
2053
0
        s++;
2054
0
    }
2055
0
  }
2056
0
  copy_lines(msg, start, orig_msg_len - (start - orig_msg));
2057
0
  free(orig_msg);
2058
0
  strbuf_release(&buf1);
2059
0
  strbuf_release(&buf2);
2060
0
}
2061
2062
static int append_squash_message(struct strbuf *buf, const char *body,
2063
       enum todo_command command, struct replay_opts *opts,
2064
       unsigned flag)
2065
0
{
2066
0
  struct replay_ctx *ctx = opts->ctx;
2067
0
  const char *fixup_msg;
2068
0
  size_t commented_len, fixup_off;
2069
2070
0
  commented_len = squash_subject_comment_len(body,
2071
0
        command == TODO_SQUASH || seen_squash(ctx));
2072
2073
0
  strbuf_addch(buf, '\n');
2074
0
  add_squash_message_header(buf, ++ctx->current_fixup_count + 1, 0);
2075
0
  strbuf_addstr(buf, "\n\n");
2076
0
  strbuf_add_commented_lines(buf, body, commented_len, comment_line_str);
2077
  /* buf->buf may be reallocated so store an offset into the buffer */
2078
0
  fixup_off = buf->len;
2079
0
  strbuf_addstr(buf, body + commented_len);
2080
2081
  /* fixup -C after squash behaves like squash */
2082
0
  if (is_fixup_flag(command, flag) && !seen_squash(ctx)) {
2083
    /*
2084
     * We're replacing the commit message so we need to
2085
     * append any trailers if the user requested
2086
     * '--signoff' or '--trailer'.
2087
     */
2088
0
    if (opts->signoff)
2089
0
      append_signoff(buf, 0, 0);
2090
2091
0
    if (opts->trailer_args.nr)
2092
0
      amend_strbuf_with_trailers(buf, &opts->trailer_args);
2093
2094
0
    if ((command == TODO_FIXUP) &&
2095
0
        (flag & TODO_REPLACE_FIXUP_MSG) &&
2096
0
        (file_exists(rebase_path_fixup_msg()) ||
2097
0
         !file_exists(rebase_path_squash_msg()))) {
2098
0
      fixup_msg = skip_blank_lines(buf->buf + fixup_off);
2099
0
      if (write_message(fixup_msg, strlen(fixup_msg),
2100
0
          rebase_path_fixup_msg(), 0) < 0)
2101
0
        return error(_("cannot write '%s'"),
2102
0
          rebase_path_fixup_msg());
2103
0
    } else {
2104
0
      unlink(rebase_path_fixup_msg());
2105
0
    }
2106
0
  } else  {
2107
0
    unlink(rebase_path_fixup_msg());
2108
0
  }
2109
2110
0
  return 0;
2111
0
}
2112
2113
static int update_squash_messages(struct repository *r,
2114
          enum todo_command command,
2115
          struct commit *commit,
2116
          struct replay_opts *opts,
2117
          unsigned flag)
2118
0
{
2119
0
  struct replay_ctx *ctx = opts->ctx;
2120
0
  struct strbuf buf = STRBUF_INIT;
2121
0
  int res = 0;
2122
0
  const char *message, *body;
2123
0
  const char *encoding = get_commit_output_encoding();
2124
2125
0
  if (!is_fixup(command))
2126
0
    BUG("not a FIXUP or SQUASH %d", command);
2127
2128
0
  if (ctx->current_fixup_count > 0) {
2129
0
    struct strbuf header = STRBUF_INIT;
2130
0
    char *eol;
2131
2132
0
    if (strbuf_read_file(&buf, rebase_path_squash_msg(), 9) <= 0)
2133
0
      return error(_("could not read '%s'"),
2134
0
        rebase_path_squash_msg());
2135
2136
0
    eol = !starts_with(buf.buf, comment_line_str) ?
2137
0
      buf.buf : strchrnul(buf.buf, '\n');
2138
2139
0
    add_squash_combination_header(&header,
2140
0
                ctx->current_fixup_count + 2);
2141
0
    strbuf_splice(&buf, 0, eol - buf.buf, header.buf, header.len);
2142
0
    strbuf_release(&header);
2143
0
    if (is_fixup_flag(command, flag) && !seen_squash(ctx))
2144
0
      update_squash_message_for_fixup(&buf);
2145
0
  } else {
2146
0
    struct object_id head;
2147
0
    struct commit *head_commit;
2148
0
    const char *head_message, *body;
2149
2150
0
    if (repo_get_oid(r, "HEAD", &head))
2151
0
      return error(_("need a HEAD to fixup"));
2152
0
    if (!(head_commit = lookup_commit_reference(r, &head)))
2153
0
      return error(_("could not read HEAD"));
2154
0
    if (!(head_message = repo_logmsg_reencode(r, head_commit, NULL,
2155
0
                encoding)))
2156
0
      return error(_("could not read HEAD's commit message"));
2157
2158
0
    find_commit_subject(head_message, &body);
2159
0
    if (command == TODO_FIXUP && !flag && write_message(body, strlen(body),
2160
0
              rebase_path_fixup_msg(), 0) < 0) {
2161
0
      repo_unuse_commit_buffer(r, head_commit, head_message);
2162
0
      return error(_("cannot write '%s'"), rebase_path_fixup_msg());
2163
0
    }
2164
0
    add_squash_combination_header(&buf, 2);
2165
0
    strbuf_addch(&buf, '\n');
2166
0
    add_squash_message_header(&buf, 1, is_fixup_flag(command, flag));
2167
0
    strbuf_addstr(&buf, "\n\n");
2168
0
    if (is_fixup_flag(command, flag))
2169
0
      strbuf_add_commented_lines(&buf, body, strlen(body),
2170
0
               comment_line_str);
2171
0
    else
2172
0
      strbuf_addstr(&buf, body);
2173
2174
0
    repo_unuse_commit_buffer(r, head_commit, head_message);
2175
0
  }
2176
2177
0
  if (!(message = repo_logmsg_reencode(r, commit, NULL, encoding)))
2178
0
    return error(_("could not read commit message of %s"),
2179
0
           oid_to_hex(&commit->object.oid));
2180
0
  find_commit_subject(message, &body);
2181
2182
0
  if (command == TODO_SQUASH || is_fixup_flag(command, flag)) {
2183
0
    res = append_squash_message(&buf, body, command, opts, flag);
2184
0
  } else if (command == TODO_FIXUP) {
2185
0
    strbuf_addch(&buf, '\n');
2186
0
    add_squash_message_header(&buf, ++ctx->current_fixup_count + 1, 1);
2187
0
    strbuf_addstr(&buf, "\n\n");
2188
0
    strbuf_add_commented_lines(&buf, body, strlen(body),
2189
0
             comment_line_str);
2190
0
  }
2191
0
  repo_unuse_commit_buffer(r, commit, message);
2192
2193
0
  if (!res)
2194
0
    res = write_message(buf.buf, buf.len, rebase_path_squash_msg(),
2195
0
            0);
2196
0
  strbuf_release(&buf);
2197
2198
0
  if (!res) {
2199
0
    const char *fixup_flag = "";
2200
2201
0
    if (is_fixup_flag(command, flag) && (flag & TODO_EDIT_FIXUP_MSG))
2202
0
      fixup_flag = " -c";
2203
2204
0
    strbuf_addf(&ctx->current_fixups, "%s%s%s %s",
2205
0
          ctx->current_fixups.len ? "\n" : "",
2206
0
          command_to_string(command), fixup_flag,
2207
0
          oid_to_hex(&commit->object.oid));
2208
0
    res = write_message(ctx->current_fixups.buf,
2209
0
            ctx->current_fixups.len,
2210
0
            rebase_path_current_fixups(), 0);
2211
0
  }
2212
2213
0
  return res;
2214
0
}
2215
2216
static void flush_rewritten_pending(void)
2217
0
{
2218
0
  struct strbuf buf = STRBUF_INIT;
2219
0
  struct object_id newoid;
2220
0
  FILE *out;
2221
2222
0
  if (strbuf_read_file(&buf, rebase_path_rewritten_pending(), (GIT_MAX_HEXSZ + 1) * 2) > 0 &&
2223
0
      !repo_get_oid(the_repository, "HEAD", &newoid) &&
2224
0
      (out = fopen_or_warn(rebase_path_rewritten_list(), "a"))) {
2225
0
    char *bol = buf.buf, *eol;
2226
2227
0
    while (*bol) {
2228
0
      eol = strchrnul(bol, '\n');
2229
0
      fprintf(out, "%.*s %s\n", (int)(eol - bol),
2230
0
          bol, oid_to_hex(&newoid));
2231
0
      if (!*eol)
2232
0
        break;
2233
0
      bol = eol + 1;
2234
0
    }
2235
0
    fclose(out);
2236
0
    unlink(rebase_path_rewritten_pending());
2237
0
  }
2238
0
  strbuf_release(&buf);
2239
0
}
2240
2241
static void record_in_rewritten(struct object_id *oid,
2242
    enum todo_command next_command)
2243
0
{
2244
0
  FILE *out = fopen_or_warn(rebase_path_rewritten_pending(), "a");
2245
2246
0
  if (!out)
2247
0
    return;
2248
2249
0
  fprintf(out, "%s\n", oid_to_hex(oid));
2250
0
  fclose(out);
2251
2252
0
  if (!is_fixup(next_command))
2253
0
    flush_rewritten_pending();
2254
0
}
2255
2256
0
static int should_edit(struct replay_opts *opts) {
2257
0
  if (opts->edit < 0)
2258
    /*
2259
     * Note that we only handle the case of non-conflicted
2260
     * commits; continue_single_pick() handles the conflicted
2261
     * commits itself instead of calling this function.
2262
     */
2263
0
    return (opts->action == REPLAY_REVERT && isatty(0)) ? 1 : 0;
2264
0
  return opts->edit;
2265
0
}
2266
2267
static void refer_to_commit(struct repository *r, struct strbuf *msgbuf,
2268
          const struct commit *commit,
2269
          bool use_commit_reference)
2270
0
{
2271
0
  if (use_commit_reference) {
2272
0
    struct pretty_print_context ctx = {
2273
0
      .abbrev = DEFAULT_ABBREV,
2274
0
      .date_mode.type = DATE_SHORT,
2275
0
    };
2276
0
    repo_format_commit_message(r, commit,
2277
0
             "%h (%s, %ad)", msgbuf, &ctx);
2278
0
  } else {
2279
0
    strbuf_add_oid_hex(msgbuf, &commit->object.oid);
2280
0
  }
2281
0
}
2282
2283
static const char *sequencer_reflog_action(struct replay_opts *opts)
2284
0
{
2285
0
  if (!opts->reflog_action) {
2286
0
    opts->reflog_action = getenv(GIT_REFLOG_ACTION);
2287
0
    opts->reflog_action =
2288
0
      xstrdup(opts->reflog_action ? opts->reflog_action
2289
0
                : action_name(opts));
2290
0
  }
2291
2292
0
  return opts->reflog_action;
2293
0
}
2294
2295
__attribute__((format (printf, 3, 4)))
2296
static const char *reflog_message(struct replay_opts *opts,
2297
  const char *sub_action, const char *fmt, ...)
2298
0
{
2299
0
  va_list ap;
2300
0
  static struct strbuf buf = STRBUF_INIT;
2301
2302
0
  va_start(ap, fmt);
2303
0
  strbuf_reset(&buf);
2304
0
  strbuf_addstr(&buf, sequencer_reflog_action(opts));
2305
0
  if (sub_action)
2306
0
    strbuf_addf(&buf, " (%s)", sub_action);
2307
0
  if (fmt) {
2308
0
    strbuf_addstr(&buf, ": ");
2309
0
    strbuf_vaddf(&buf, fmt, ap);
2310
0
  }
2311
0
  va_end(ap);
2312
2313
0
  return buf.buf;
2314
0
}
2315
2316
enum pick_result {
2317
  PICK_RESULT_ERROR = -1,
2318
  PICK_RESULT_OK,
2319
  PICK_RESULT_CONFLICTS,
2320
  PICK_RESULT_DROPPED,
2321
};
2322
2323
static enum pick_result do_pick_commit(struct repository *r,
2324
               struct todo_item *item,
2325
               struct replay_opts *opts,
2326
               int final_fixup, int *check_todo)
2327
0
{
2328
0
  struct replay_ctx *ctx = opts->ctx;
2329
0
  unsigned int flags = should_edit(opts) ? EDIT_MSG : 0;
2330
0
  const char *msg_file = should_edit(opts) ? NULL : git_path_merge_msg(r);
2331
0
  struct object_id head;
2332
0
  struct commit *base, *next, *parent;
2333
0
  const char *base_label, *next_label, *reflog_action;
2334
0
  char *author = NULL;
2335
0
  struct commit_message msg = { NULL, NULL, NULL, NULL };
2336
0
  int res, unborn = 0, reword = 0, allow, drop_commit = 0;
2337
0
  enum todo_command command = item->command;
2338
0
  struct commit *commit = item->commit;
2339
2340
0
  if (is_rebase_i(opts))
2341
0
    reflog_action = reflog_message(
2342
0
      opts, command_to_string(item->command), NULL);
2343
0
  else
2344
0
    reflog_action = sequencer_reflog_action(opts);
2345
2346
0
  if (opts->no_commit) {
2347
    /*
2348
     * We do not intend to commit immediately.  We just want to
2349
     * merge the differences in, so let's compute the tree
2350
     * that represents the "current" state for the merge machinery
2351
     * to work on.
2352
     */
2353
0
    if (write_index_as_tree(&head, r->index, r->index_file, 0, NULL))
2354
0
      return error(_("your index file is unmerged."));
2355
0
  } else {
2356
0
    unborn = repo_get_oid(r, "HEAD", &head);
2357
    /* Do we want to generate a root commit? */
2358
0
    if (is_pick_or_similar(command) && opts->have_squash_onto &&
2359
0
        oideq(&head, &opts->squash_onto)) {
2360
0
      if (is_fixup(command))
2361
0
        return error(_("cannot fixup root commit"));
2362
0
      flags |= CREATE_ROOT_COMMIT;
2363
0
      unborn = 1;
2364
0
    } else if (unborn)
2365
0
      oidcpy(&head, the_hash_algo->empty_tree);
2366
0
    if (index_differs_from(r, unborn ? empty_tree_oid_hex(the_repository->hash_algo) : "HEAD",
2367
0
               NULL, 0))
2368
0
      return error_dirty_index(r, opts);
2369
0
  }
2370
0
  discard_index(r->index);
2371
2372
0
  if (!commit->parents)
2373
0
    parent = NULL;
2374
0
  else if (commit->parents->next) {
2375
    /* Reverting or cherry-picking a merge commit */
2376
0
    int cnt;
2377
0
    struct commit_list *p;
2378
2379
0
    if (!opts->mainline)
2380
0
      return error(_("commit %s is a merge but no -m option was given."),
2381
0
        oid_to_hex(&commit->object.oid));
2382
2383
0
    for (cnt = 1, p = commit->parents;
2384
0
         cnt != opts->mainline && p;
2385
0
         cnt++)
2386
0
      p = p->next;
2387
0
    if (cnt != opts->mainline || !p)
2388
0
      return error(_("commit %s does not have parent %d"),
2389
0
        oid_to_hex(&commit->object.oid), opts->mainline);
2390
0
    parent = p->item;
2391
0
  } else if (1 < opts->mainline)
2392
    /*
2393
     *  Non-first parent explicitly specified as mainline for
2394
     *  non-merge commit
2395
     */
2396
0
    return error(_("commit %s does not have parent %d"),
2397
0
           oid_to_hex(&commit->object.oid), opts->mainline);
2398
0
  else
2399
0
    parent = commit->parents->item;
2400
2401
0
  if (get_message(commit, &msg) != 0)
2402
0
    return error(_("cannot get commit message for %s"),
2403
0
      oid_to_hex(&commit->object.oid));
2404
2405
0
  if (opts->allow_ff && !is_fixup(command) &&
2406
0
      ((parent && oideq(&parent->object.oid, &head)) ||
2407
0
       (!parent && unborn))) {
2408
0
    if (is_rebase_i(opts))
2409
0
      write_author_script(msg.message);
2410
0
    res = fast_forward_to(r, &commit->object.oid, &head, unborn,
2411
0
      opts);
2412
0
    if (res || command != TODO_REWORD)
2413
0
      goto leave;
2414
0
    reword = 1;
2415
0
    msg_file = NULL;
2416
0
    goto fast_forward_edit;
2417
0
  }
2418
0
  if (parent && repo_parse_commit(r, parent) < 0)
2419
    /* TRANSLATORS: The first %s will be a "todo" command like
2420
       "revert" or "pick", the second %s a SHA1. */
2421
0
    return error(_("%s: cannot parse parent commit %s"),
2422
0
      command_to_string(command),
2423
0
      oid_to_hex(&parent->object.oid));
2424
2425
  /*
2426
   * "commit" is an existing commit.  We would want to apply
2427
   * the difference it introduces since its first parent "prev"
2428
   * on top of the current HEAD if we are cherry-pick.  Or the
2429
   * reverse of it if we are revert.
2430
   */
2431
2432
0
  if (command == TODO_REVERT) {
2433
0
    base = commit;
2434
0
    base_label = msg.label;
2435
0
    next = parent;
2436
0
    next_label = msg.parent_label;
2437
0
    sequencer_format_revert_message(r, msg.subject, commit,
2438
0
            parent,
2439
0
            opts->commit_use_reference,
2440
0
            &ctx->message);
2441
0
  } else {
2442
0
    const char *p;
2443
2444
0
    base = parent;
2445
0
    base_label = msg.parent_label;
2446
0
    next = commit;
2447
0
    next_label = msg.label;
2448
2449
    /* Append the commit log message to ctx->message. */
2450
0
    if (find_commit_subject(msg.message, &p))
2451
0
      strbuf_addstr(&ctx->message, p);
2452
2453
0
    if (opts->record_origin) {
2454
0
      strbuf_complete_line(&ctx->message);
2455
0
      if (!has_conforming_footer(&ctx->message, NULL, 0))
2456
0
        strbuf_addch(&ctx->message, '\n');
2457
0
      strbuf_addstr(&ctx->message, cherry_picked_prefix);
2458
0
      strbuf_add_oid_hex(&ctx->message, &commit->object.oid);
2459
0
      strbuf_addstr(&ctx->message, ")\n");
2460
0
    }
2461
0
    if (!is_fixup(command))
2462
0
      author = get_author(msg.message);
2463
0
  }
2464
0
  ctx->have_message = 1;
2465
2466
0
  if (command == TODO_REWORD)
2467
0
    reword = 1;
2468
0
  else if (is_fixup(command)) {
2469
0
    if (update_squash_messages(r, command, commit,
2470
0
             opts, item->flags)) {
2471
0
      res = -1;
2472
0
      goto leave;
2473
0
    }
2474
0
    flags |= AMEND_MSG;
2475
0
    if (!final_fixup)
2476
0
      msg_file = rebase_path_squash_msg();
2477
0
    else if (file_exists(rebase_path_fixup_msg())) {
2478
0
      msg_file = rebase_path_fixup_msg();
2479
0
    } else {
2480
0
      const char *dest = git_path_squash_msg(r);
2481
0
      unlink(dest);
2482
0
      if (copy_file(r, dest, rebase_path_squash_msg(), 0666)) {
2483
0
        res = error(_("could not copy '%s' to '%s'"),
2484
0
              rebase_path_squash_msg(), dest);
2485
0
        goto leave;
2486
0
      }
2487
0
      unlink(git_path_merge_msg(r));
2488
0
      msg_file = dest;
2489
0
      flags |= EDIT_MSG;
2490
0
    }
2491
0
  }
2492
2493
0
  if (opts->signoff && !is_fixup(command))
2494
0
    append_signoff(&ctx->message, 0, 0);
2495
2496
0
  if (opts->trailer_args.nr && !is_fixup(command))
2497
0
    amend_strbuf_with_trailers(&ctx->message, &opts->trailer_args);
2498
2499
0
  if (is_rebase_i(opts) && write_author_script(msg.message) < 0)
2500
0
    res = -1;
2501
0
  else if (!opts->strategy ||
2502
0
     !strcmp(opts->strategy, "recursive") ||
2503
0
     !strcmp(opts->strategy, "ort") ||
2504
0
     command == TODO_REVERT) {
2505
0
    res = do_recursive_merge(r, base, next, base_label, next_label,
2506
0
           &head, &ctx->message, opts);
2507
0
    if (res < 0)
2508
0
      goto leave;
2509
2510
0
    res |= write_message(ctx->message.buf, ctx->message.len,
2511
0
             git_path_merge_msg(r), 0);
2512
0
  } else {
2513
0
    struct commit_list *common = NULL;
2514
0
    struct commit_list *remotes = NULL;
2515
2516
0
    if (write_message(ctx->message.buf, ctx->message.len,
2517
0
          git_path_merge_msg(r), 0)) {
2518
0
      res = -1;
2519
0
      goto leave;
2520
0
    }
2521
2522
0
    commit_list_insert(base, &common);
2523
0
    commit_list_insert(next, &remotes);
2524
0
    res = try_merge_command(r, opts->strategy,
2525
0
          opts->xopts.nr, opts->xopts.v,
2526
0
          common, oid_to_hex(&head), remotes);
2527
    /*
2528
     * If there were conflicts, try_merge_command() returns 1,
2529
     * any other no-zero return code means that either the merge
2530
     * command could not be run, or it failed to merge.
2531
     */
2532
0
    if (res && res != 1)
2533
0
      res = -1;
2534
2535
0
    commit_list_free(common);
2536
0
    commit_list_free(remotes);
2537
0
  }
2538
2539
  /*
2540
   * If the merge was clean or if it failed due to conflict, we write
2541
   * CHERRY_PICK_HEAD for the subsequent invocation of commit to use.
2542
   * However, if the merge did not even start, then we don't want to
2543
   * write it at all.
2544
   */
2545
0
  if ((command == TODO_PICK || command == TODO_REWORD ||
2546
0
       command == TODO_EDIT) && !opts->no_commit &&
2547
0
      (res == 0 || res == 1) &&
2548
0
      refs_update_ref(get_main_ref_store(the_repository), NULL, "CHERRY_PICK_HEAD", &commit->object.oid, NULL,
2549
0
          REF_NO_DEREF, UPDATE_REFS_MSG_ON_ERR))
2550
0
    res = -1;
2551
0
  if (command == TODO_REVERT && ((opts->no_commit && res == 0) || res == 1) &&
2552
0
      refs_update_ref(get_main_ref_store(the_repository), NULL, "REVERT_HEAD", &commit->object.oid, NULL,
2553
0
          REF_NO_DEREF, UPDATE_REFS_MSG_ON_ERR))
2554
0
    res = -1;
2555
2556
0
  if (res) {
2557
0
    error(command == TODO_REVERT
2558
0
          ? _("could not revert %s... %s")
2559
0
          : _("could not apply %s... %s"),
2560
0
          short_commit_name(r, commit), msg.subject);
2561
0
    print_advice(r, res == 1, opts);
2562
0
    repo_rerere(r, opts->allow_rerere_auto);
2563
0
    goto leave;
2564
0
  }
2565
2566
0
  allow = allow_empty(r, opts, commit);
2567
0
  if (allow < 0) {
2568
0
    res = allow;
2569
0
    goto leave;
2570
0
  } else if (allow == 1) {
2571
0
    flags |= ALLOW_EMPTY;
2572
0
  } else if (allow == 2) {
2573
0
    drop_commit = 1;
2574
0
    refs_delete_ref(get_main_ref_store(r), "", "CHERRY_PICK_HEAD",
2575
0
        NULL, REF_NO_DEREF);
2576
0
    unlink(git_path_merge_msg(r));
2577
0
    refs_delete_ref(get_main_ref_store(r), "", "AUTO_MERGE",
2578
0
        NULL, REF_NO_DEREF);
2579
0
    fprintf(stderr,
2580
0
      _("dropping %s %s -- patch contents already upstream\n"),
2581
0
      oid_to_hex(&commit->object.oid), msg.subject);
2582
0
  } /* else allow == 0 and there's nothing special to do */
2583
0
  if (!opts->no_commit && !drop_commit) {
2584
0
    if (author || command == TODO_REVERT || (flags & AMEND_MSG))
2585
0
      res = do_commit(r, msg_file, author, reflog_action,
2586
0
          opts, flags,
2587
0
          commit? &commit->object.oid : NULL);
2588
0
    else
2589
0
      res = error(_("unable to parse commit author"));
2590
0
    *check_todo = !!(flags & EDIT_MSG);
2591
0
    if (!res && reword) {
2592
0
fast_forward_edit:
2593
      /*
2594
       * To reword we amend the commit we just
2595
       * picked or fast-forwarded. As the commit has
2596
       * already been picked we want to use the same
2597
       * set of commit flags regardless of how we
2598
       * got here.
2599
       */
2600
0
      flags = EDIT_MSG | VERIFY_MSG | AMEND_MSG | ALLOW_EMPTY;
2601
0
      res = run_git_commit(NULL, reflog_action, opts, flags);
2602
0
      *check_todo = 1;
2603
0
    }
2604
    /*
2605
     * If "git commit" failed to run then res == -1, but we don't
2606
     * want reschedule the last command because the picking the
2607
     * commit was successful.
2608
     */
2609
0
    res = !!res;
2610
0
  }
2611
2612
2613
0
  if (!res && final_fixup) {
2614
0
    unlink(rebase_path_fixup_msg());
2615
0
    unlink(rebase_path_squash_msg());
2616
0
    unlink(rebase_path_current_fixups());
2617
0
    strbuf_reset(&ctx->current_fixups);
2618
0
    ctx->current_fixup_count = 0;
2619
0
  }
2620
2621
0
leave:
2622
0
  free_message(commit, &msg);
2623
0
  free(author);
2624
0
  update_abort_safety_file();
2625
2626
0
  if (res < 0)
2627
0
    return PICK_RESULT_ERROR;
2628
0
  else if (res > 0)
2629
0
    return PICK_RESULT_CONFLICTS;
2630
0
  else if (drop_commit)
2631
0
    return PICK_RESULT_DROPPED;
2632
0
  else
2633
0
    return PICK_RESULT_OK;
2634
0
}
2635
2636
static int prepare_revs(struct replay_opts *opts)
2637
0
{
2638
  /*
2639
   * picking (but not reverting) ranges (but not individual revisions)
2640
   * should be done in reverse
2641
   */
2642
0
  if (opts->action == REPLAY_PICK && !opts->revs->no_walk)
2643
0
    opts->revs->reverse ^= 1;
2644
2645
0
  if (prepare_revision_walk(opts->revs))
2646
0
    return error(_("revision walk setup failed"));
2647
2648
0
  return 0;
2649
0
}
2650
2651
static int read_and_refresh_cache(struct repository *r,
2652
          struct replay_opts *opts)
2653
0
{
2654
0
  struct lock_file index_lock = LOCK_INIT;
2655
0
  int index_fd = repo_hold_locked_index(r, &index_lock, 0);
2656
0
  if (repo_read_index(r) < 0) {
2657
0
    rollback_lock_file(&index_lock);
2658
0
    return error(_("git %s: failed to read the index"),
2659
0
      action_name(opts));
2660
0
  }
2661
0
  refresh_index(r->index, REFRESH_QUIET|REFRESH_UNMERGED, NULL, NULL, NULL);
2662
2663
0
  if (index_fd >= 0) {
2664
0
    if (write_locked_index(r->index, &index_lock,
2665
0
               COMMIT_LOCK | SKIP_IF_UNCHANGED)) {
2666
0
      return error(_("git %s: failed to refresh the index"),
2667
0
        action_name(opts));
2668
0
    }
2669
0
  }
2670
2671
  /*
2672
   * If we are resolving merges in any way other than "ort", then
2673
   * expand the sparse index.
2674
   */
2675
0
  if (opts->strategy && strcmp(opts->strategy, "ort"))
2676
0
    ensure_full_index(r->index);
2677
0
  return 0;
2678
0
}
2679
2680
void todo_list_release(struct todo_list *todo_list)
2681
0
{
2682
0
  strbuf_release(&todo_list->buf);
2683
0
  FREE_AND_NULL(todo_list->items);
2684
0
  todo_list->nr = todo_list->alloc = 0;
2685
0
}
2686
2687
static struct todo_item *append_new_todo(struct todo_list *todo_list)
2688
0
{
2689
0
  ALLOC_GROW(todo_list->items, todo_list->nr + 1, todo_list->alloc);
2690
0
  return todo_list->items + todo_list->nr++;
2691
0
}
2692
2693
const char *todo_item_get_arg(struct todo_list *todo_list,
2694
            struct todo_item *item)
2695
0
{
2696
0
  return todo_list->buf.buf + item->arg_offset;
2697
0
}
2698
2699
static int is_command(enum todo_command command, const char **bol)
2700
0
{
2701
0
  const char *str = todo_command_info[command].str;
2702
0
  const char nick = todo_command_info[command].c;
2703
0
  const char *p = *bol;
2704
2705
0
  if ((skip_prefix(p, str, &p) || (nick && *p++ == nick)) &&
2706
0
      (*p == ' ' || *p == '\t' || *p == '\n' || *p == '\r' || !*p)) {
2707
0
    *bol = p;
2708
0
    return 1;
2709
0
  }
2710
0
  return 0;
2711
0
}
2712
2713
bool sequencer_parse_todo_command(const char **p, enum todo_command *cmd)
2714
0
{
2715
0
  const char *s = *p;
2716
2717
0
  for (int i = 0; i < TODO_COMMENT; i++)
2718
0
    if (is_command(i, p)) {
2719
0
      *cmd = i;
2720
0
      return true;
2721
0
    }
2722
2723
0
  if (starts_with(s, comment_line_str)) {
2724
0
    *cmd = TODO_COMMENT;
2725
0
    return true;
2726
0
  } else if (s[0] == '\n' || (s[0] == '\r' && s[1] == '\n') || !s[0]) {
2727
0
    *cmd = TODO_COMMENT;
2728
0
    return true;
2729
0
  }
2730
2731
0
  return false;
2732
0
}
2733
2734
static int check_label_or_ref_arg(enum todo_command command, const char *arg)
2735
0
{
2736
0
  switch (command) {
2737
0
  case TODO_LABEL:
2738
    /*
2739
     * '#' is not a valid label as the merge command uses it to
2740
     * separate merge parents from the commit subject.
2741
     */
2742
0
    if (!strcmp(arg, "#") ||
2743
0
        check_refname_format(arg, REFNAME_ALLOW_ONELEVEL))
2744
0
      return error(_("'%s' is not a valid label"), arg);
2745
0
    break;
2746
2747
0
  case TODO_UPDATE_REF:
2748
0
    if (check_refname_format(arg, REFNAME_ALLOW_ONELEVEL))
2749
0
      return error(_("'%s' is not a valid refname"), arg);
2750
0
    if (check_refname_format(arg, 0))
2751
0
      return error(_("update-ref requires a fully qualified "
2752
0
               "refname e.g. refs/heads/%s"), arg);
2753
0
    break;
2754
2755
0
  default:
2756
0
    BUG("unexpected todo_command");
2757
0
  }
2758
2759
0
  return 0;
2760
0
}
2761
2762
static int check_merge_commit_insn(enum todo_command command)
2763
0
{
2764
0
  switch(command) {
2765
0
  case TODO_PICK:
2766
0
    error(_("'%s' does not accept merge commits"),
2767
0
          todo_command_info[command].str);
2768
0
    advise_if_enabled(ADVICE_REBASE_TODO_ERROR, _(
2769
      /*
2770
       * TRANSLATORS: 'pick' and 'merge -C' should not be
2771
       * translated.
2772
       */
2773
0
      "'pick' does not take a merge commit. If you wanted to\n"
2774
0
      "replay the merge, use 'merge -C' on the commit."));
2775
0
    return -1;
2776
2777
0
  case TODO_REWORD:
2778
0
    error(_("'%s' does not accept merge commits"),
2779
0
          todo_command_info[command].str);
2780
0
    advise_if_enabled(ADVICE_REBASE_TODO_ERROR, _(
2781
      /*
2782
       * TRANSLATORS: 'reword' and 'merge -c' should not be
2783
       * translated.
2784
       */
2785
0
      "'reword' does not take a merge commit. If you wanted to\n"
2786
0
      "replay the merge and reword the commit message, use\n"
2787
0
      "'merge -c' on the commit"));
2788
0
    return -1;
2789
2790
0
  case TODO_EDIT:
2791
0
    error(_("'%s' does not accept merge commits"),
2792
0
          todo_command_info[command].str);
2793
0
    advise_if_enabled(ADVICE_REBASE_TODO_ERROR, _(
2794
      /*
2795
       * TRANSLATORS: 'edit', 'merge -C' and 'break' should
2796
       * not be translated.
2797
       */
2798
0
      "'edit' does not take a merge commit. If you wanted to\n"
2799
0
      "replay the merge, use 'merge -C' on the commit, and then\n"
2800
0
      "'break' to give the control back to you so that you can\n"
2801
0
      "do 'git commit --amend && git rebase --continue'."));
2802
0
    return -1;
2803
2804
0
  case TODO_FIXUP:
2805
0
  case TODO_SQUASH:
2806
0
    return error(_("cannot squash merge commit into another commit"));
2807
2808
0
  case TODO_MERGE:
2809
0
  case TODO_DROP:
2810
0
    return 0;
2811
2812
0
  default:
2813
0
    BUG("unexpected todo_command");
2814
0
  }
2815
0
}
2816
2817
static int parse_insn_line(struct repository *r, struct replay_opts *opts,
2818
         struct todo_item *item, const char *buf,
2819
         const char *bol, char *eol)
2820
0
{
2821
0
  struct object_id commit_oid;
2822
0
  char *end_of_object_name;
2823
0
  int saved, status, padding;
2824
2825
0
  item->flags = 0;
2826
2827
  /* left-trim */
2828
0
  bol += strspn(bol, " \t");
2829
2830
0
  if (!sequencer_parse_todo_command(&bol, &item->command))
2831
0
    return error(_("invalid command '%.*s'"),
2832
0
           (int)strcspn(bol, " \t\r\n"), bol);
2833
2834
0
  if (item->command == TODO_COMMENT) {
2835
0
    item->commit = NULL;
2836
0
    item->arg_offset = bol - buf;
2837
0
    item->arg_len = eol - bol;
2838
0
    return 0;
2839
0
  }
2840
2841
  /* Eat up extra spaces/ tabs before object name */
2842
0
  padding = strspn(bol, " \t");
2843
0
  bol += padding;
2844
2845
0
  if (item->command == TODO_NOOP || item->command == TODO_BREAK) {
2846
0
    if (bol != eol)
2847
0
      return error(_("%s does not accept arguments: '%s'"),
2848
0
             command_to_string(item->command), bol);
2849
0
    item->commit = NULL;
2850
0
    item->arg_offset = bol - buf;
2851
0
    item->arg_len = eol - bol;
2852
0
    return 0;
2853
0
  }
2854
2855
0
  if (!padding)
2856
0
    return error(_("missing arguments for %s"),
2857
0
           command_to_string(item->command));
2858
2859
0
  if (item->command == TODO_EXEC || item->command == TODO_LABEL ||
2860
0
      item->command == TODO_RESET || item->command == TODO_UPDATE_REF) {
2861
0
    int ret = 0;
2862
2863
0
    item->commit = NULL;
2864
0
    item->arg_offset = bol - buf;
2865
0
    item->arg_len = (int)(eol - bol);
2866
0
    if (item->command == TODO_LABEL ||
2867
0
        item->command == TODO_UPDATE_REF) {
2868
0
      saved = *eol;
2869
0
      *eol = '\0';
2870
0
      ret = check_label_or_ref_arg(item->command, bol);
2871
0
      *eol = saved;
2872
0
    }
2873
0
    return ret;
2874
0
  }
2875
2876
0
  if (item->command == TODO_FIXUP) {
2877
0
    if (skip_prefix(bol, "-C", &bol)) {
2878
0
      bol += strspn(bol, " \t");
2879
0
      item->flags |= TODO_REPLACE_FIXUP_MSG;
2880
0
    } else if (skip_prefix(bol, "-c", &bol)) {
2881
0
      bol += strspn(bol, " \t");
2882
0
      item->flags |= TODO_EDIT_FIXUP_MSG;
2883
0
    }
2884
0
  }
2885
2886
0
  if (item->command == TODO_MERGE) {
2887
0
    if (skip_prefix(bol, "-C", &bol))
2888
0
      bol += strspn(bol, " \t");
2889
0
    else if (skip_prefix(bol, "-c", &bol)) {
2890
0
      bol += strspn(bol, " \t");
2891
0
      item->flags |= TODO_EDIT_MERGE_MSG;
2892
0
    } else {
2893
0
      item->flags |= TODO_EDIT_MERGE_MSG;
2894
0
      item->commit = NULL;
2895
0
      item->arg_offset = bol - buf;
2896
0
      item->arg_len = (int)(eol - bol);
2897
0
      return 0;
2898
0
    }
2899
0
  }
2900
2901
0
  end_of_object_name = (char *) bol + strcspn(bol, " \t\n");
2902
0
  saved = *end_of_object_name;
2903
0
  *end_of_object_name = '\0';
2904
0
  status = repo_get_oid(r, bol, &commit_oid);
2905
0
  if (status < 0)
2906
0
    error(_("could not parse '%s'"), bol); /* return later */
2907
0
  *end_of_object_name = saved;
2908
2909
0
  bol = end_of_object_name + strspn(end_of_object_name, " \t");
2910
0
  item->arg_offset = bol - buf;
2911
0
  item->arg_len = (int)(eol - bol);
2912
2913
0
  if (status < 0)
2914
0
    return status;
2915
2916
0
  item->commit = lookup_commit_reference(r, &commit_oid);
2917
0
  if (!item->commit)
2918
0
    return -1;
2919
0
  if (is_rebase_i(opts) &&
2920
0
      item->commit->parents && item->commit->parents->next)
2921
0
    return check_merge_commit_insn(item->command);
2922
0
  return 0;
2923
0
}
2924
2925
int sequencer_get_last_command(struct repository *r UNUSED, enum replay_action *action)
2926
0
{
2927
0
  const char *todo_file, *bol;
2928
0
  struct strbuf buf = STRBUF_INIT;
2929
0
  int ret = 0;
2930
2931
0
  todo_file = git_path_todo_file();
2932
0
  if (strbuf_read_file(&buf, todo_file, 0) < 0) {
2933
0
    if (errno == ENOENT || errno == ENOTDIR)
2934
0
      return -1;
2935
0
    else
2936
0
      return error_errno("unable to open '%s'", todo_file);
2937
0
  }
2938
0
  bol = buf.buf + strspn(buf.buf, " \t\r\n");
2939
0
  if (is_command(TODO_PICK, &bol) && (*bol == ' ' || *bol == '\t'))
2940
0
    *action = REPLAY_PICK;
2941
0
  else if (is_command(TODO_REVERT, &bol) &&
2942
0
     (*bol == ' ' || *bol == '\t'))
2943
0
    *action = REPLAY_REVERT;
2944
0
  else
2945
0
    ret = -1;
2946
2947
0
  strbuf_release(&buf);
2948
2949
0
  return ret;
2950
0
}
2951
2952
int todo_list_parse_insn_buffer(struct repository *r, struct replay_opts *opts,
2953
        char *buf, struct todo_list *todo_list)
2954
0
{
2955
0
  struct todo_item *item;
2956
0
  char *p = buf, *next_p;
2957
0
  int i, res = 0, fixup_okay = file_exists(rebase_path_done());
2958
2959
0
  todo_list->current = todo_list->nr = todo_list->total_nr = 0;
2960
2961
0
  for (i = 1; *p; i++, p = next_p) {
2962
0
    char *eol = strchrnul(p, '\n');
2963
2964
0
    next_p = *eol ? eol + 1 /* skip LF */ : eol;
2965
2966
0
    if (p != eol && eol[-1] == '\r')
2967
0
      eol--; /* strip Carriage Return */
2968
2969
0
    item = append_new_todo(todo_list);
2970
0
    item->offset_in_buf = p - todo_list->buf.buf;
2971
0
    if (parse_insn_line(r, opts, item, buf, p, eol)) {
2972
0
      res = error(_("invalid line %d: %.*s"),
2973
0
        i, (int)(eol - p), p);
2974
0
      item->command = TODO_COMMENT + 1;
2975
0
      item->arg_offset = p - buf;
2976
0
      item->arg_len = (int)(eol - p);
2977
0
      item->commit = NULL;
2978
0
    }
2979
2980
0
    if (item->command != TODO_COMMENT)
2981
0
      todo_list->total_nr++;
2982
2983
0
    if (fixup_okay)
2984
0
      ; /* do nothing */
2985
0
    else if (is_fixup(item->command))
2986
0
      res = error(_("cannot '%s' without a previous commit"),
2987
0
        command_to_string(item->command));
2988
0
    else if (!is_noop(item->command))
2989
0
      fixup_okay = 1;
2990
0
  }
2991
2992
0
  return res;
2993
0
}
2994
2995
static int count_commands(struct todo_list *todo_list)
2996
0
{
2997
0
  int count = 0, i;
2998
2999
0
  for (i = 0; i < todo_list->nr; i++)
3000
0
    if (todo_list->items[i].command != TODO_COMMENT)
3001
0
      count++;
3002
3003
0
  return count;
3004
0
}
3005
3006
static int get_item_line_offset(struct todo_list *todo_list, int index)
3007
0
{
3008
0
  return index < todo_list->nr ?
3009
0
    todo_list->items[index].offset_in_buf : todo_list->buf.len;
3010
0
}
3011
3012
static const char *get_item_line(struct todo_list *todo_list, int index)
3013
0
{
3014
0
  return todo_list->buf.buf + get_item_line_offset(todo_list, index);
3015
0
}
3016
3017
static int get_item_line_length(struct todo_list *todo_list, int index)
3018
0
{
3019
0
  return get_item_line_offset(todo_list, index + 1)
3020
0
    -  get_item_line_offset(todo_list, index);
3021
0
}
3022
3023
static ssize_t strbuf_read_file_or_whine(struct strbuf *sb, const char *path)
3024
0
{
3025
0
  int fd;
3026
0
  ssize_t len;
3027
3028
0
  fd = open(path, O_RDONLY);
3029
0
  if (fd < 0)
3030
0
    return error_errno(_("could not open '%s'"), path);
3031
0
  len = strbuf_read(sb, fd, 0);
3032
0
  close(fd);
3033
0
  if (len < 0)
3034
0
    return error(_("could not read '%s'."), path);
3035
0
  return len;
3036
0
}
3037
3038
static int have_finished_the_last_pick(void)
3039
0
{
3040
0
  struct strbuf buf = STRBUF_INIT;
3041
0
  const char *eol;
3042
0
  const char *todo_path = git_path_todo_file();
3043
0
  int ret = 0;
3044
3045
0
  if (strbuf_read_file(&buf, todo_path, 0) < 0) {
3046
0
    if (errno == ENOENT) {
3047
0
      return 0;
3048
0
    } else {
3049
0
      error_errno("unable to open '%s'", todo_path);
3050
0
      return 0;
3051
0
    }
3052
0
  }
3053
  /* If there is only one line then we are done */
3054
0
  eol = strchr(buf.buf, '\n');
3055
0
  if (!eol || !eol[1])
3056
0
    ret = 1;
3057
3058
0
  strbuf_release(&buf);
3059
3060
0
  return ret;
3061
0
}
3062
3063
void sequencer_post_commit_cleanup(struct repository *r, int verbose)
3064
0
{
3065
0
  struct replay_opts opts = REPLAY_OPTS_INIT;
3066
0
  int need_cleanup = 0;
3067
3068
0
  if (refs_ref_exists(get_main_ref_store(r), "CHERRY_PICK_HEAD")) {
3069
0
    if (!refs_delete_ref(get_main_ref_store(r), "",
3070
0
             "CHERRY_PICK_HEAD", NULL, REF_NO_DEREF) &&
3071
0
        verbose)
3072
0
      warning(_("cancelling a cherry picking in progress"));
3073
0
    opts.action = REPLAY_PICK;
3074
0
    need_cleanup = 1;
3075
0
  }
3076
3077
0
  if (refs_ref_exists(get_main_ref_store(r), "REVERT_HEAD")) {
3078
0
    if (!refs_delete_ref(get_main_ref_store(r), "", "REVERT_HEAD",
3079
0
             NULL, REF_NO_DEREF) &&
3080
0
        verbose)
3081
0
      warning(_("cancelling a revert in progress"));
3082
0
    opts.action = REPLAY_REVERT;
3083
0
    need_cleanup = 1;
3084
0
  }
3085
3086
0
  refs_delete_ref(get_main_ref_store(r), "", "AUTO_MERGE",
3087
0
      NULL, REF_NO_DEREF);
3088
3089
0
  if (!need_cleanup)
3090
0
    goto out;
3091
3092
0
  if (!have_finished_the_last_pick())
3093
0
    goto out;
3094
3095
0
  sequencer_remove_state(&opts);
3096
0
out:
3097
0
  replay_opts_release(&opts);
3098
0
}
3099
3100
static void todo_list_write_total_nr(struct todo_list *todo_list)
3101
0
{
3102
0
  FILE *f = fopen_or_warn(rebase_path_msgtotal(), "w");
3103
3104
0
  if (f) {
3105
0
    fprintf(f, "%d\n", todo_list->total_nr);
3106
0
    fclose(f);
3107
0
  }
3108
0
}
3109
3110
static int read_populate_todo(struct repository *r,
3111
            struct todo_list *todo_list,
3112
            struct replay_opts *opts)
3113
0
{
3114
0
  const char *todo_file = get_todo_path(opts);
3115
0
  int res;
3116
3117
0
  strbuf_reset(&todo_list->buf);
3118
0
  if (strbuf_read_file_or_whine(&todo_list->buf, todo_file) < 0)
3119
0
    return -1;
3120
3121
0
  res = todo_list_parse_insn_buffer(r, opts, todo_list->buf.buf, todo_list);
3122
0
  if (res) {
3123
0
    if (is_rebase_i(opts))
3124
0
      return error(_("please fix this using "
3125
0
               "'git rebase --edit-todo'."));
3126
0
    return error(_("unusable instruction sheet: '%s'"), todo_file);
3127
0
  }
3128
3129
0
  if (!todo_list->nr &&
3130
0
      (!is_rebase_i(opts) || !file_exists(rebase_path_done())))
3131
0
    return error(_("no commits parsed."));
3132
3133
0
  if (!is_rebase_i(opts)) {
3134
0
    enum todo_command valid =
3135
0
      opts->action == REPLAY_PICK ? TODO_PICK : TODO_REVERT;
3136
0
    int i;
3137
3138
0
    for (i = 0; i < todo_list->nr; i++)
3139
0
      if (valid == todo_list->items[i].command)
3140
0
        continue;
3141
0
      else if (valid == TODO_PICK)
3142
0
        return error(_("cannot cherry-pick during a revert."));
3143
0
      else
3144
0
        return error(_("cannot revert during a cherry-pick."));
3145
0
  }
3146
3147
0
  if (is_rebase_i(opts)) {
3148
0
    struct todo_list done = TODO_LIST_INIT;
3149
3150
0
    if (strbuf_read_file(&done.buf, rebase_path_done(), 0) > 0 &&
3151
0
        !todo_list_parse_insn_buffer(r, opts, done.buf.buf, &done))
3152
0
      todo_list->done_nr = count_commands(&done);
3153
0
    else
3154
0
      todo_list->done_nr = 0;
3155
3156
0
    todo_list->total_nr = todo_list->done_nr
3157
0
      + count_commands(todo_list);
3158
0
    todo_list_release(&done);
3159
3160
0
    todo_list_write_total_nr(todo_list);
3161
0
  }
3162
3163
0
  return 0;
3164
0
}
3165
3166
static int git_config_string_dup(char **dest,
3167
         const char *var, const char *value)
3168
0
{
3169
0
  if (!value)
3170
0
    return config_error_nonbool(var);
3171
0
  free(*dest);
3172
0
  *dest = xstrdup(value);
3173
0
  return 0;
3174
0
}
3175
3176
static int populate_opts_cb(const char *key, const char *value,
3177
          const struct config_context *ctx,
3178
          void *data)
3179
0
{
3180
0
  struct replay_opts *opts = data;
3181
0
  int error_flag = 1;
3182
3183
0
  if (!value)
3184
0
    error_flag = 0;
3185
0
  else if (!strcmp(key, "options.no-commit"))
3186
0
    opts->no_commit = git_config_bool_or_int(key, value, ctx->kvi, &error_flag);
3187
0
  else if (!strcmp(key, "options.edit"))
3188
0
    opts->edit = git_config_bool_or_int(key, value, ctx->kvi, &error_flag);
3189
0
  else if (!strcmp(key, "options.allow-empty"))
3190
0
    opts->allow_empty =
3191
0
      git_config_bool_or_int(key, value, ctx->kvi, &error_flag);
3192
0
  else if (!strcmp(key, "options.allow-empty-message"))
3193
0
    opts->allow_empty_message =
3194
0
      git_config_bool_or_int(key, value, ctx->kvi, &error_flag);
3195
0
  else if (!strcmp(key, "options.drop-redundant-commits"))
3196
0
    opts->drop_redundant_commits =
3197
0
      git_config_bool_or_int(key, value, ctx->kvi, &error_flag);
3198
0
  else if (!strcmp(key, "options.keep-redundant-commits"))
3199
0
    opts->keep_redundant_commits =
3200
0
      git_config_bool_or_int(key, value, ctx->kvi, &error_flag);
3201
0
  else if (!strcmp(key, "options.signoff"))
3202
0
    opts->signoff = git_config_bool_or_int(key, value, ctx->kvi, &error_flag);
3203
0
  else if (!strcmp(key, "options.record-origin"))
3204
0
    opts->record_origin = git_config_bool_or_int(key, value, ctx->kvi, &error_flag);
3205
0
  else if (!strcmp(key, "options.allow-ff"))
3206
0
    opts->allow_ff = git_config_bool_or_int(key, value, ctx->kvi, &error_flag);
3207
0
  else if (!strcmp(key, "options.mainline"))
3208
0
    opts->mainline = git_config_int(key, value, ctx->kvi);
3209
0
  else if (!strcmp(key, "options.strategy"))
3210
0
    git_config_string_dup(&opts->strategy, key, value);
3211
0
  else if (!strcmp(key, "options.gpg-sign"))
3212
0
    git_config_string_dup(&opts->gpg_sign, key, value);
3213
0
  else if (!strcmp(key, "options.strategy-option")) {
3214
0
    strvec_push(&opts->xopts, value);
3215
0
  } else if (!strcmp(key, "options.allow-rerere-auto"))
3216
0
    opts->allow_rerere_auto =
3217
0
      git_config_bool_or_int(key, value, ctx->kvi, &error_flag) ?
3218
0
        RERERE_AUTOUPDATE : RERERE_NOAUTOUPDATE;
3219
0
  else if (!strcmp(key, "options.default-msg-cleanup")) {
3220
0
    opts->explicit_cleanup = 1;
3221
0
    opts->default_msg_cleanup = get_cleanup_mode(value, 1);
3222
0
  } else
3223
0
    return error(_("invalid key: %s"), key);
3224
3225
0
  if (!error_flag)
3226
0
    return error(_("invalid value for '%s': '%s'"), key, value);
3227
3228
0
  return 0;
3229
0
}
3230
3231
static void parse_strategy_opts(struct replay_opts *opts, char *raw_opts)
3232
0
{
3233
0
  int i;
3234
0
  int count;
3235
0
  const char **argv;
3236
0
  char *strategy_opts_string = raw_opts;
3237
3238
0
  if (*strategy_opts_string == ' ')
3239
0
    strategy_opts_string++;
3240
3241
0
  count = split_cmdline(strategy_opts_string, &argv);
3242
0
  if (count < 0)
3243
0
    BUG("could not split '%s': %s", strategy_opts_string,
3244
0
          split_cmdline_strerror(count));
3245
0
  for (i = 0; i < count; i++) {
3246
0
    const char *arg = argv[i];
3247
3248
0
    skip_prefix(arg, "--", &arg);
3249
0
    strvec_push(&opts->xopts, arg);
3250
0
  }
3251
0
  free(argv);
3252
0
}
3253
3254
static void read_strategy_opts(struct replay_opts *opts, struct strbuf *buf)
3255
0
{
3256
0
  strbuf_reset(buf);
3257
0
  if (!read_oneliner(buf, rebase_path_strategy(), 0))
3258
0
    return;
3259
0
  opts->strategy = strbuf_detach(buf, NULL);
3260
0
  if (!read_oneliner(buf, rebase_path_strategy_opts(), 0))
3261
0
    return;
3262
3263
0
  parse_strategy_opts(opts, buf->buf);
3264
0
}
3265
3266
static int read_trailers(struct replay_opts *opts, struct strbuf *buf)
3267
0
{
3268
0
  ssize_t len;
3269
3270
0
  strbuf_reset(buf);
3271
0
  len = strbuf_read_file(buf, rebase_path_trailer(), 0);
3272
0
  if (len > 0) {
3273
0
    char *p = buf->buf, *nl;
3274
3275
0
    trailer_config_init();
3276
3277
0
    while ((nl = strchr(p, '\n'))) {
3278
0
      *nl = '\0';
3279
0
      if (!*p)
3280
0
        return error(_("trailers file contains empty line"));
3281
0
      strvec_push(&opts->trailer_args, p);
3282
0
      p = nl + 1;
3283
0
    }
3284
0
  } else if (!len) {
3285
0
    return error(_("trailers file is empty"));
3286
0
  } else if (errno != ENOENT) {
3287
0
    return error(_("cannot read trailers files"));
3288
0
  }
3289
3290
0
  return 0;
3291
0
}
3292
3293
static int read_populate_opts(struct replay_opts *opts)
3294
0
{
3295
0
  struct replay_ctx *ctx = opts->ctx;
3296
3297
0
  if (is_rebase_i(opts)) {
3298
0
    struct strbuf buf = STRBUF_INIT;
3299
0
    int ret = 0;
3300
3301
0
    if (read_oneliner(&buf, rebase_path_gpg_sign_opt(),
3302
0
          READ_ONELINER_SKIP_IF_EMPTY)) {
3303
0
      if (!starts_with(buf.buf, "-S"))
3304
0
        strbuf_reset(&buf);
3305
0
      else {
3306
0
        free(opts->gpg_sign);
3307
0
        opts->gpg_sign = xstrdup(buf.buf + 2);
3308
0
      }
3309
0
      strbuf_reset(&buf);
3310
0
    }
3311
3312
0
    if (read_oneliner(&buf, rebase_path_allow_rerere_autoupdate(),
3313
0
          READ_ONELINER_SKIP_IF_EMPTY)) {
3314
0
      if (!strcmp(buf.buf, "--rerere-autoupdate"))
3315
0
        opts->allow_rerere_auto = RERERE_AUTOUPDATE;
3316
0
      else if (!strcmp(buf.buf, "--no-rerere-autoupdate"))
3317
0
        opts->allow_rerere_auto = RERERE_NOAUTOUPDATE;
3318
0
      strbuf_reset(&buf);
3319
0
    }
3320
3321
0
    if (file_exists(rebase_path_verbose()))
3322
0
      opts->verbose = 1;
3323
3324
0
    if (file_exists(rebase_path_quiet()))
3325
0
      opts->quiet = 1;
3326
3327
0
    if (file_exists(rebase_path_signoff())) {
3328
0
      opts->allow_ff = 0;
3329
0
      opts->signoff = 1;
3330
0
    }
3331
3332
0
    if (file_exists(rebase_path_cdate_is_adate())) {
3333
0
      opts->allow_ff = 0;
3334
0
      opts->committer_date_is_author_date = 1;
3335
0
    }
3336
3337
0
    if (file_exists(rebase_path_ignore_date())) {
3338
0
      opts->allow_ff = 0;
3339
0
      opts->ignore_date = 1;
3340
0
    }
3341
3342
0
    if (file_exists(rebase_path_reschedule_failed_exec()))
3343
0
      opts->reschedule_failed_exec = 1;
3344
0
    else if (file_exists(rebase_path_no_reschedule_failed_exec()))
3345
0
      opts->reschedule_failed_exec = 0;
3346
3347
0
    if (file_exists(rebase_path_drop_redundant_commits()))
3348
0
      opts->drop_redundant_commits = 1;
3349
3350
0
    if (file_exists(rebase_path_keep_redundant_commits()))
3351
0
      opts->keep_redundant_commits = 1;
3352
3353
0
    read_strategy_opts(opts, &buf);
3354
3355
0
    if (read_trailers(opts, &buf)) {
3356
0
      ret = -1;
3357
0
      goto done_rebase_i;
3358
0
    }
3359
0
    strbuf_reset(&buf);
3360
3361
0
    if (read_oneliner(&ctx->current_fixups,
3362
0
          rebase_path_current_fixups(),
3363
0
          READ_ONELINER_SKIP_IF_EMPTY)) {
3364
0
      const char *p = ctx->current_fixups.buf;
3365
0
      ctx->current_fixup_count = 1;
3366
0
      while ((p = strchr(p, '\n'))) {
3367
        /*
3368
         * Older versions of git accidentally
3369
         * inserted blank lines when a fixup
3370
         * was skipped.
3371
         */
3372
0
        if (p[1] && p[1] != '\n')
3373
0
          ctx->current_fixup_count++;
3374
0
        p++;
3375
0
      }
3376
0
    }
3377
3378
0
    if (read_oneliner(&buf, rebase_path_squash_onto(), 0)) {
3379
0
      if (repo_get_oid_committish(the_repository, buf.buf, &opts->squash_onto) < 0) {
3380
0
        ret = error(_("unusable squash-onto"));
3381
0
        goto done_rebase_i;
3382
0
      }
3383
0
      opts->have_squash_onto = 1;
3384
0
    }
3385
3386
0
done_rebase_i:
3387
0
    strbuf_release(&buf);
3388
0
    return ret;
3389
0
  }
3390
3391
0
  if (!file_exists(git_path_opts_file()))
3392
0
    return 0;
3393
  /*
3394
   * The function git_parse_source(), called from git_config_from_file(),
3395
   * may die() in case of a syntactically incorrect file. We do not care
3396
   * about this case, though, because we wrote that file ourselves, so we
3397
   * are pretty certain that it is syntactically correct.
3398
   */
3399
0
  if (git_config_from_file(populate_opts_cb, git_path_opts_file(), opts) < 0)
3400
0
    return error(_("malformed options sheet: '%s'"),
3401
0
      git_path_opts_file());
3402
0
  return 0;
3403
0
}
3404
3405
static void write_strategy_opts(struct replay_opts *opts)
3406
0
{
3407
0
  struct strbuf buf = STRBUF_INIT;
3408
3409
  /*
3410
   * Quote strategy options so that they can be read correctly
3411
   * by split_cmdline().
3412
   */
3413
0
  quote_cmdline(&buf, opts->xopts.v);
3414
0
  write_file(rebase_path_strategy_opts(), "%s\n", buf.buf);
3415
0
  strbuf_release(&buf);
3416
0
}
3417
3418
int write_basic_state(struct replay_opts *opts, const char *head_name,
3419
          struct commit *onto, const struct object_id *orig_head)
3420
0
{
3421
0
  if (head_name)
3422
0
    write_file(rebase_path_head_name(), "%s\n", head_name);
3423
0
  if (onto)
3424
0
    write_file(rebase_path_onto(), "%s\n",
3425
0
         oid_to_hex(&onto->object.oid));
3426
0
  if (orig_head)
3427
0
    write_file(rebase_path_orig_head(), "%s\n",
3428
0
         oid_to_hex(orig_head));
3429
3430
0
  if (opts->quiet)
3431
0
    write_file(rebase_path_quiet(), "%s", "");
3432
0
  if (opts->verbose)
3433
0
    write_file(rebase_path_verbose(), "%s", "");
3434
0
  if (opts->strategy)
3435
0
    write_file(rebase_path_strategy(), "%s\n", opts->strategy);
3436
0
  if (opts->xopts.nr > 0)
3437
0
    write_strategy_opts(opts);
3438
3439
0
  if (opts->allow_rerere_auto == RERERE_AUTOUPDATE)
3440
0
    write_file(rebase_path_allow_rerere_autoupdate(), "--rerere-autoupdate\n");
3441
0
  else if (opts->allow_rerere_auto == RERERE_NOAUTOUPDATE)
3442
0
    write_file(rebase_path_allow_rerere_autoupdate(), "--no-rerere-autoupdate\n");
3443
3444
0
  if (opts->gpg_sign)
3445
0
    write_file(rebase_path_gpg_sign_opt(), "-S%s\n", opts->gpg_sign);
3446
0
  if (opts->signoff)
3447
0
    write_file(rebase_path_signoff(), "--signoff\n");
3448
0
  if (opts->drop_redundant_commits)
3449
0
    write_file(rebase_path_drop_redundant_commits(), "%s", "");
3450
0
  if (opts->keep_redundant_commits)
3451
0
    write_file(rebase_path_keep_redundant_commits(), "%s", "");
3452
0
  if (opts->committer_date_is_author_date)
3453
0
    write_file(rebase_path_cdate_is_adate(), "%s", "");
3454
0
  if (opts->ignore_date)
3455
0
    write_file(rebase_path_ignore_date(), "%s", "");
3456
0
  if (opts->reschedule_failed_exec)
3457
0
    write_file(rebase_path_reschedule_failed_exec(), "%s", "");
3458
0
  else
3459
0
    write_file(rebase_path_no_reschedule_failed_exec(), "%s", "");
3460
0
  if (opts->trailer_args.nr) {
3461
0
    struct strbuf buf = STRBUF_INIT;
3462
3463
0
    for (size_t i = 0; i < opts->trailer_args.nr; i++)
3464
0
      strbuf_addf(&buf, "%s\n", opts->trailer_args.v[i]);
3465
0
    write_file(rebase_path_trailer(), "%s", buf.buf);
3466
0
    strbuf_release(&buf);
3467
0
  }
3468
3469
0
  return 0;
3470
0
}
3471
3472
static int walk_revs_populate_todo(struct todo_list *todo_list,
3473
        struct replay_opts *opts)
3474
0
{
3475
0
  enum todo_command command = opts->action == REPLAY_PICK ?
3476
0
    TODO_PICK : TODO_REVERT;
3477
0
  const char *command_string = todo_command_info[command].str;
3478
0
  const char *encoding;
3479
0
  struct commit *commit;
3480
3481
0
  if (prepare_revs(opts))
3482
0
    return -1;
3483
3484
0
  encoding = get_log_output_encoding();
3485
3486
0
  while ((commit = get_revision(opts->revs))) {
3487
0
    struct todo_item *item = append_new_todo(todo_list);
3488
0
    const char *commit_buffer = repo_logmsg_reencode(the_repository,
3489
0
                 commit, NULL,
3490
0
                 encoding);
3491
0
    const char *subject;
3492
0
    int subject_len;
3493
3494
0
    item->command = command;
3495
0
    item->commit = commit;
3496
0
    item->arg_offset = 0;
3497
0
    item->arg_len = 0;
3498
0
    item->offset_in_buf = todo_list->buf.len;
3499
0
    subject_len = find_commit_subject(commit_buffer, &subject);
3500
0
    strbuf_addf(&todo_list->buf, "%s %s %.*s\n", command_string,
3501
0
      short_commit_name(the_repository, commit),
3502
0
      subject_len, subject);
3503
0
    repo_unuse_commit_buffer(the_repository, commit,
3504
0
           commit_buffer);
3505
0
  }
3506
3507
0
  if (!todo_list->nr)
3508
0
    return error(_("empty commit set passed"));
3509
3510
0
  return 0;
3511
0
}
3512
3513
static int create_seq_dir(struct repository *r)
3514
0
{
3515
0
  enum replay_action action;
3516
0
  const char *in_progress_error = NULL;
3517
0
  const char *in_progress_advice = NULL;
3518
0
  unsigned int advise_skip =
3519
0
    refs_ref_exists(get_main_ref_store(r), "REVERT_HEAD") ||
3520
0
    refs_ref_exists(get_main_ref_store(r), "CHERRY_PICK_HEAD");
3521
3522
0
  if (!sequencer_get_last_command(r, &action)) {
3523
0
    switch (action) {
3524
0
    case REPLAY_REVERT:
3525
0
      in_progress_error = _("revert is already in progress");
3526
0
      in_progress_advice =
3527
0
      _("try \"git revert (--continue | %s--abort | --quit)\"");
3528
0
      break;
3529
0
    case REPLAY_PICK:
3530
0
      in_progress_error = _("cherry-pick is already in progress");
3531
0
      in_progress_advice =
3532
0
      _("try \"git cherry-pick (--continue | %s--abort | --quit)\"");
3533
0
      break;
3534
0
    default:
3535
0
      BUG("unexpected action in create_seq_dir");
3536
0
    }
3537
0
  }
3538
0
  if (in_progress_error) {
3539
0
    error("%s", in_progress_error);
3540
0
    if (advice_enabled(ADVICE_SEQUENCER_IN_USE))
3541
0
      advise(in_progress_advice,
3542
0
        advise_skip ? "--skip | " : "");
3543
0
    return -1;
3544
0
  }
3545
0
  if (mkdir(git_path_seq_dir(), 0777) < 0)
3546
0
    return error_errno(_("could not create sequencer directory '%s'"),
3547
0
           git_path_seq_dir());
3548
3549
0
  return 0;
3550
0
}
3551
3552
static int save_head(const char *head)
3553
0
{
3554
0
  return write_message(head, strlen(head), git_path_head_file(), 1);
3555
0
}
3556
3557
static int rollback_is_safe(void)
3558
0
{
3559
0
  struct strbuf sb = STRBUF_INIT;
3560
0
  struct object_id expected_head, actual_head;
3561
3562
0
  if (strbuf_read_file(&sb, git_path_abort_safety_file(), 0) >= 0) {
3563
0
    strbuf_trim(&sb);
3564
0
    if (get_oid_hex(sb.buf, &expected_head)) {
3565
0
      strbuf_release(&sb);
3566
0
      die(_("could not parse %s"), git_path_abort_safety_file());
3567
0
    }
3568
0
    strbuf_release(&sb);
3569
0
  }
3570
0
  else if (errno == ENOENT)
3571
0
    oidclr(&expected_head, the_repository->hash_algo);
3572
0
  else
3573
0
    die_errno(_("could not read '%s'"), git_path_abort_safety_file());
3574
3575
0
  if (repo_get_oid(the_repository, "HEAD", &actual_head))
3576
0
    oidclr(&actual_head, the_repository->hash_algo);
3577
3578
0
  return oideq(&actual_head, &expected_head);
3579
0
}
3580
3581
static int reset_merge(const struct object_id *oid)
3582
0
{
3583
0
  struct child_process cmd = CHILD_PROCESS_INIT;
3584
3585
0
  cmd.git_cmd = 1;
3586
0
  strvec_pushl(&cmd.args, "reset", "--merge", NULL);
3587
3588
0
  if (!is_null_oid(oid))
3589
0
    strvec_push(&cmd.args, oid_to_hex(oid));
3590
3591
0
  return run_command(&cmd);
3592
0
}
3593
3594
static int rollback_single_pick(struct repository *r)
3595
0
{
3596
0
  struct object_id head_oid;
3597
3598
0
  if (!refs_ref_exists(get_main_ref_store(r), "CHERRY_PICK_HEAD") &&
3599
0
      !refs_ref_exists(get_main_ref_store(r), "REVERT_HEAD"))
3600
0
    return error(_("no cherry-pick or revert in progress"));
3601
0
  if (refs_read_ref_full(get_main_ref_store(the_repository), "HEAD", 0, &head_oid, NULL))
3602
0
    return error(_("cannot resolve HEAD"));
3603
0
  if (is_null_oid(&head_oid))
3604
0
    return error(_("cannot abort from a branch yet to be born"));
3605
0
  return reset_merge(&head_oid);
3606
0
}
3607
3608
static int skip_single_pick(void)
3609
0
{
3610
0
  struct object_id head;
3611
3612
0
  if (refs_read_ref_full(get_main_ref_store(the_repository), "HEAD", 0, &head, NULL))
3613
0
    return error(_("cannot resolve HEAD"));
3614
0
  return reset_merge(&head);
3615
0
}
3616
3617
int sequencer_rollback(struct repository *r, struct replay_opts *opts)
3618
0
{
3619
0
  FILE *f;
3620
0
  struct object_id oid;
3621
0
  struct strbuf buf = STRBUF_INIT;
3622
0
  const char *p;
3623
3624
0
  f = fopen(git_path_head_file(), "r");
3625
0
  if (!f && errno == ENOENT) {
3626
    /*
3627
     * There is no multiple-cherry-pick in progress.
3628
     * If CHERRY_PICK_HEAD or REVERT_HEAD indicates
3629
     * a single-cherry-pick in progress, abort that.
3630
     */
3631
0
    return rollback_single_pick(r);
3632
0
  }
3633
0
  if (!f)
3634
0
    return error_errno(_("cannot open '%s'"), git_path_head_file());
3635
0
  if (strbuf_getline_lf(&buf, f)) {
3636
0
    error(_("cannot read '%s': %s"), git_path_head_file(),
3637
0
          ferror(f) ?  strerror(errno) : _("unexpected end of file"));
3638
0
    fclose(f);
3639
0
    goto fail;
3640
0
  }
3641
0
  fclose(f);
3642
0
  if (parse_oid_hex(buf.buf, &oid, &p) || *p != '\0') {
3643
0
    error(_("stored pre-cherry-pick HEAD file '%s' is corrupt"),
3644
0
      git_path_head_file());
3645
0
    goto fail;
3646
0
  }
3647
0
  if (is_null_oid(&oid)) {
3648
0
    error(_("cannot abort from a branch yet to be born"));
3649
0
    goto fail;
3650
0
  }
3651
3652
0
  if (!rollback_is_safe()) {
3653
    /* Do not error, just do not rollback */
3654
0
    warning(_("You seem to have moved HEAD. "
3655
0
        "Not rewinding, check your HEAD!"));
3656
0
  } else
3657
0
  if (reset_merge(&oid))
3658
0
    goto fail;
3659
0
  strbuf_release(&buf);
3660
0
  return sequencer_remove_state(opts);
3661
0
fail:
3662
0
  strbuf_release(&buf);
3663
0
  return -1;
3664
0
}
3665
3666
int sequencer_skip(struct repository *r, struct replay_opts *opts)
3667
0
{
3668
0
  enum replay_action action = -1;
3669
0
  sequencer_get_last_command(r, &action);
3670
3671
  /*
3672
   * Check whether the subcommand requested to skip the commit is actually
3673
   * in progress and that it's safe to skip the commit.
3674
   *
3675
   * opts->action tells us which subcommand requested to skip the commit.
3676
   * If the corresponding .git/<ACTION>_HEAD exists, we know that the
3677
   * action is in progress and we can skip the commit.
3678
   *
3679
   * Otherwise we check that the last instruction was related to the
3680
   * particular subcommand we're trying to execute and barf if that's not
3681
   * the case.
3682
   *
3683
   * Finally we check that the rollback is "safe", i.e., has the HEAD
3684
   * moved? In this case, it doesn't make sense to "reset the merge" and
3685
   * "skip the commit" as the user already handled this by committing. But
3686
   * we'd not want to barf here, instead give advice on how to proceed. We
3687
   * only need to check that when .git/<ACTION>_HEAD doesn't exist because
3688
   * it gets removed when the user commits, so if it still exists we're
3689
   * sure the user can't have committed before.
3690
   */
3691
0
  switch (opts->action) {
3692
0
  case REPLAY_REVERT:
3693
0
    if (!refs_ref_exists(get_main_ref_store(r), "REVERT_HEAD")) {
3694
0
      if (action != REPLAY_REVERT)
3695
0
        return error(_("no revert in progress"));
3696
0
      if (!rollback_is_safe())
3697
0
        goto give_advice;
3698
0
    }
3699
0
    break;
3700
0
  case REPLAY_PICK:
3701
0
    if (!refs_ref_exists(get_main_ref_store(r),
3702
0
             "CHERRY_PICK_HEAD")) {
3703
0
      if (action != REPLAY_PICK)
3704
0
        return error(_("no cherry-pick in progress"));
3705
0
      if (!rollback_is_safe())
3706
0
        goto give_advice;
3707
0
    }
3708
0
    break;
3709
0
  default:
3710
0
    BUG("unexpected action in sequencer_skip");
3711
0
  }
3712
3713
0
  if (skip_single_pick())
3714
0
    return error(_("failed to skip the commit"));
3715
0
  if (!is_directory(git_path_seq_dir()))
3716
0
    return 0;
3717
3718
0
  return sequencer_continue(r, opts);
3719
3720
0
give_advice:
3721
0
  error(_("there is nothing to skip"));
3722
3723
0
  if (advice_enabled(ADVICE_RESOLVE_CONFLICT)) {
3724
0
    advise(_("have you committed already?\n"
3725
0
       "try \"git %s --continue\""),
3726
0
       action == REPLAY_REVERT ? "revert" : "cherry-pick");
3727
0
  }
3728
0
  return -1;
3729
0
}
3730
3731
static int save_todo(struct todo_list *todo_list, struct replay_opts *opts,
3732
         int reschedule)
3733
0
{
3734
0
  struct lock_file todo_lock = LOCK_INIT;
3735
0
  const char *todo_path = get_todo_path(opts);
3736
0
  int next = todo_list->current, offset, fd;
3737
3738
  /*
3739
   * rebase -i writes "git-rebase-todo" without the currently executing
3740
   * command, appending it to "done" instead.
3741
   */
3742
0
  if (is_rebase_i(opts) && !reschedule)
3743
0
    next++;
3744
3745
0
  fd = hold_lock_file_for_update(&todo_lock, todo_path, 0);
3746
0
  if (fd < 0)
3747
0
    return error_errno(_("could not lock '%s'"), todo_path);
3748
0
  offset = get_item_line_offset(todo_list, next);
3749
0
  if (write_in_full(fd, todo_list->buf.buf + offset,
3750
0
      todo_list->buf.len - offset) < 0)
3751
0
    return error_errno(_("could not write to '%s'"), todo_path);
3752
0
  if (commit_lock_file(&todo_lock) < 0)
3753
0
    return error(_("failed to finalize '%s'"), todo_path);
3754
3755
0
  if (is_rebase_i(opts) && !reschedule && next > 0) {
3756
0
    const char *done = rebase_path_done();
3757
0
    int fd = open(done, O_CREAT | O_WRONLY | O_APPEND, 0666);
3758
0
    int ret = 0;
3759
3760
0
    if (fd < 0)
3761
0
      return 0;
3762
0
    if (write_in_full(fd, get_item_line(todo_list, next - 1),
3763
0
          get_item_line_length(todo_list, next - 1))
3764
0
        < 0)
3765
0
      ret = error_errno(_("could not write to '%s'"), done);
3766
0
    if (close(fd) < 0)
3767
0
      ret = error_errno(_("failed to finalize '%s'"), done);
3768
0
    return ret;
3769
0
  }
3770
0
  return 0;
3771
0
}
3772
3773
static int save_opts(struct replay_opts *opts)
3774
0
{
3775
0
  const char *opts_file = git_path_opts_file();
3776
0
  int res = 0;
3777
3778
0
  if (opts->no_commit)
3779
0
    res |= repo_config_set_in_file_gently(the_repository, opts_file,
3780
0
          "options.no-commit", NULL, "true");
3781
0
  if (opts->edit >= 0)
3782
0
    res |= repo_config_set_in_file_gently(the_repository, opts_file, "options.edit", NULL,
3783
0
                 opts->edit ? "true" : "false");
3784
0
  if (opts->allow_empty)
3785
0
    res |= repo_config_set_in_file_gently(the_repository, opts_file,
3786
0
          "options.allow-empty", NULL, "true");
3787
0
  if (opts->allow_empty_message)
3788
0
    res |= repo_config_set_in_file_gently(the_repository, opts_file,
3789
0
        "options.allow-empty-message", NULL, "true");
3790
0
  if (opts->drop_redundant_commits)
3791
0
    res |= repo_config_set_in_file_gently(the_repository, opts_file,
3792
0
        "options.drop-redundant-commits", NULL, "true");
3793
0
  if (opts->keep_redundant_commits)
3794
0
    res |= repo_config_set_in_file_gently(the_repository, opts_file,
3795
0
        "options.keep-redundant-commits", NULL, "true");
3796
0
  if (opts->signoff)
3797
0
    res |= repo_config_set_in_file_gently(the_repository, opts_file,
3798
0
          "options.signoff", NULL, "true");
3799
0
  if (opts->record_origin)
3800
0
    res |= repo_config_set_in_file_gently(the_repository, opts_file,
3801
0
          "options.record-origin", NULL, "true");
3802
0
  if (opts->allow_ff)
3803
0
    res |= repo_config_set_in_file_gently(the_repository, opts_file,
3804
0
          "options.allow-ff", NULL, "true");
3805
0
  if (opts->mainline) {
3806
0
    struct strbuf buf = STRBUF_INIT;
3807
0
    strbuf_addf(&buf, "%d", opts->mainline);
3808
0
    res |= repo_config_set_in_file_gently(the_repository, opts_file,
3809
0
          "options.mainline", NULL, buf.buf);
3810
0
    strbuf_release(&buf);
3811
0
  }
3812
0
  if (opts->strategy)
3813
0
    res |= repo_config_set_in_file_gently(the_repository, opts_file,
3814
0
          "options.strategy", NULL, opts->strategy);
3815
0
  if (opts->gpg_sign)
3816
0
    res |= repo_config_set_in_file_gently(the_repository, opts_file,
3817
0
          "options.gpg-sign", NULL, opts->gpg_sign);
3818
0
  for (size_t i = 0; i < opts->xopts.nr; i++)
3819
0
    res |= repo_config_set_multivar_in_file_gently(the_repository, opts_file,
3820
0
        "options.strategy-option",
3821
0
        opts->xopts.v[i], "^$", NULL, 0);
3822
0
  if (opts->allow_rerere_auto)
3823
0
    res |= repo_config_set_in_file_gently(the_repository, opts_file,
3824
0
        "options.allow-rerere-auto", NULL,
3825
0
        opts->allow_rerere_auto == RERERE_AUTOUPDATE ?
3826
0
        "true" : "false");
3827
3828
0
  if (opts->explicit_cleanup)
3829
0
    res |= repo_config_set_in_file_gently(the_repository, opts_file,
3830
0
        "options.default-msg-cleanup", NULL,
3831
0
        describe_cleanup_mode(opts->default_msg_cleanup));
3832
0
  return res;
3833
0
}
3834
3835
static int make_patch(struct repository *r,
3836
          struct commit *commit,
3837
          struct replay_opts *opts)
3838
0
{
3839
0
  struct rev_info log_tree_opt;
3840
0
  const char *subject;
3841
0
  char hex[GIT_MAX_HEXSZ + 1];
3842
0
  int res = 0;
3843
3844
0
  if (!is_rebase_i(opts))
3845
0
    BUG("make_patch should only be called when rebasing");
3846
3847
0
  oid_to_hex_r(hex, &commit->object.oid);
3848
0
  if (write_message(hex, strlen(hex), rebase_path_stopped_sha(), 1) < 0)
3849
0
    return -1;
3850
0
  res |= write_rebase_head(&commit->object.oid);
3851
3852
0
  memset(&log_tree_opt, 0, sizeof(log_tree_opt));
3853
0
  repo_init_revisions(r, &log_tree_opt, NULL);
3854
0
  log_tree_opt.abbrev = 0;
3855
0
  log_tree_opt.diff = 1;
3856
0
  log_tree_opt.diffopt.output_format = DIFF_FORMAT_PATCH;
3857
0
  log_tree_opt.disable_stdin = 1;
3858
0
  log_tree_opt.no_commit_id = 1;
3859
0
  log_tree_opt.diffopt.file = fopen(rebase_path_patch(), "w");
3860
0
  log_tree_opt.diffopt.use_color = GIT_COLOR_NEVER;
3861
0
  if (!log_tree_opt.diffopt.file)
3862
0
    res |= error_errno(_("could not open '%s'"),
3863
0
           rebase_path_patch());
3864
0
  else {
3865
0
    res |= log_tree_commit(&log_tree_opt, commit);
3866
0
    fclose(log_tree_opt.diffopt.file);
3867
0
  }
3868
3869
0
  if (!file_exists(rebase_path_message())) {
3870
0
    const char *encoding = get_commit_output_encoding();
3871
0
    const char *commit_buffer = repo_logmsg_reencode(r,
3872
0
                 commit, NULL,
3873
0
                 encoding);
3874
0
    find_commit_subject(commit_buffer, &subject);
3875
0
    res |= write_message(subject, strlen(subject), rebase_path_message(), 1);
3876
0
    repo_unuse_commit_buffer(r, commit,
3877
0
           commit_buffer);
3878
0
  }
3879
0
  release_revisions(&log_tree_opt);
3880
3881
0
  return res;
3882
0
}
3883
3884
static int intend_to_amend(void)
3885
0
{
3886
0
  struct object_id head;
3887
0
  char *p;
3888
3889
0
  if (repo_get_oid(the_repository, "HEAD", &head))
3890
0
    return error(_("cannot read HEAD"));
3891
3892
0
  p = oid_to_hex(&head);
3893
0
  return write_message(p, strlen(p), rebase_path_amend(), 1);
3894
0
}
3895
3896
static int error_with_patch(struct repository *r,
3897
          struct commit *commit,
3898
          const char *subject, int subject_len,
3899
          struct replay_opts *opts,
3900
          int exit_code, int to_amend)
3901
0
{
3902
0
  struct replay_ctx *ctx = opts->ctx;
3903
3904
  /*
3905
   * Write the commit message to be used by "git rebase
3906
   * --continue". If a "fixup" or "squash" command has conflicts
3907
   * then we will have already written rebase_path_message() in
3908
   * error_failed_squash(). If an "edit" command was
3909
   * fast-forwarded then we don't have a message in ctx->message
3910
   * and rely on make_patch() to write rebase_path_message()
3911
   * instead.
3912
   */
3913
0
  if (ctx->have_message && !file_exists(rebase_path_message()) &&
3914
0
      write_message(ctx->message.buf, ctx->message.len,
3915
0
        rebase_path_message(), 0))
3916
0
    return error(_("could not write commit message file"));
3917
3918
0
  if (commit && make_patch(r, commit, opts))
3919
0
      return -1;
3920
3921
0
  if (to_amend) {
3922
0
    if (intend_to_amend())
3923
0
      return -1;
3924
3925
0
    fprintf(stderr,
3926
0
      _("You can amend the commit now, with\n"
3927
0
        "\n"
3928
0
        "  git commit --amend %s\n"
3929
0
        "\n"
3930
0
        "Once you are satisfied with your changes, run\n"
3931
0
        "\n"
3932
0
        "  git rebase --continue\n"),
3933
0
      gpg_sign_opt_quoted(opts));
3934
0
  } else if (exit_code) {
3935
0
    if (commit)
3936
0
      fprintf_ln(stderr, _("Could not apply %s... %.*s"),
3937
0
           short_commit_name(r, commit), subject_len, subject);
3938
0
    else
3939
      /*
3940
       * We don't have the hash of the parent so
3941
       * just print the line from the todo file.
3942
       */
3943
0
      fprintf_ln(stderr, _("Could not merge %.*s"),
3944
0
           subject_len, subject);
3945
0
  }
3946
3947
0
  return exit_code;
3948
0
}
3949
3950
static int error_failed_squash(struct repository *r,
3951
             struct commit *commit,
3952
             struct replay_opts *opts,
3953
             int subject_len,
3954
             const char *subject)
3955
0
{
3956
0
  if (copy_file(r, rebase_path_message(), rebase_path_squash_msg(), 0666))
3957
0
    return error(_("could not copy '%s' to '%s'"),
3958
0
      rebase_path_squash_msg(), rebase_path_message());
3959
0
  unlink(git_path_merge_msg(r));
3960
0
  if (copy_file(r, git_path_merge_msg(r), rebase_path_message(), 0666))
3961
0
    return error(_("could not copy '%s' to '%s'"),
3962
0
           rebase_path_message(),
3963
0
           git_path_merge_msg(r));
3964
0
  return error_with_patch(r, commit, subject, subject_len, opts, 1, 1);
3965
0
}
3966
3967
static int do_exec(struct repository *r, const char *command_line,
3968
       struct replay_opts *opts)
3969
0
{
3970
0
  struct child_process cmd = CHILD_PROCESS_INIT;
3971
0
  int dirty, status;
3972
3973
0
  if (!opts->quiet)
3974
0
    fprintf(stderr, _("Executing: %s\n"), command_line);
3975
0
  cmd.use_shell = 1;
3976
0
  strvec_push(&cmd.args, command_line);
3977
0
  strvec_push(&cmd.env, "GIT_CHERRY_PICK_HELP");
3978
0
  disable_auto_maintenance(opts, &cmd);
3979
0
  status = run_command(&cmd);
3980
3981
  /* force re-reading of the cache */
3982
0
  discard_index(r->index);
3983
0
  if (repo_read_index(r) < 0)
3984
0
    return error(_("could not read index"));
3985
3986
0
  dirty = require_clean_work_tree(r, "rebase", NULL, 1, 1);
3987
3988
0
  if (status) {
3989
0
    warning(_("execution failed: %s\n%s"
3990
0
        "You can fix the problem, and then run\n"
3991
0
        "\n"
3992
0
        "  git rebase --continue\n"
3993
0
        "\n"),
3994
0
      command_line,
3995
0
      dirty ? _("and made changes to the index and/or the "
3996
0
        "working tree.\n") : "");
3997
0
    if (status == 127)
3998
      /* command not found */
3999
0
      status = 1;
4000
0
  } else if (dirty) {
4001
0
    warning(_("execution succeeded: %s\nbut "
4002
0
        "left changes to the index and/or the working tree.\n"
4003
0
        "Commit or stash your changes, and then run\n"
4004
0
        "\n"
4005
0
        "  git rebase --continue\n"
4006
0
        "\n"), command_line);
4007
0
    status = 1;
4008
0
  }
4009
4010
0
  return status;
4011
0
}
4012
4013
__attribute__((format (printf, 2, 3)))
4014
static int safe_append(const char *filename, const char *fmt, ...)
4015
0
{
4016
0
  va_list ap;
4017
0
  struct lock_file lock = LOCK_INIT;
4018
0
  int fd = hold_lock_file_for_update(&lock, filename,
4019
0
             LOCK_REPORT_ON_ERROR);
4020
0
  struct strbuf buf = STRBUF_INIT;
4021
4022
0
  if (fd < 0)
4023
0
    return -1;
4024
4025
0
  if (strbuf_read_file(&buf, filename, 0) < 0 && errno != ENOENT) {
4026
0
    error_errno(_("could not read '%s'"), filename);
4027
0
    rollback_lock_file(&lock);
4028
0
    return -1;
4029
0
  }
4030
0
  strbuf_complete(&buf, '\n');
4031
0
  va_start(ap, fmt);
4032
0
  strbuf_vaddf(&buf, fmt, ap);
4033
0
  va_end(ap);
4034
4035
0
  if (write_in_full(fd, buf.buf, buf.len) < 0) {
4036
0
    error_errno(_("could not write to '%s'"), filename);
4037
0
    strbuf_release(&buf);
4038
0
    rollback_lock_file(&lock);
4039
0
    return -1;
4040
0
  }
4041
0
  if (commit_lock_file(&lock) < 0) {
4042
0
    strbuf_release(&buf);
4043
0
    return error(_("failed to finalize '%s'"), filename);
4044
0
  }
4045
4046
0
  strbuf_release(&buf);
4047
0
  return 0;
4048
0
}
4049
4050
static int do_label(struct repository *r, const char *name, int len)
4051
0
{
4052
0
  struct ref_store *refs = get_main_ref_store(r);
4053
0
  struct ref_transaction *transaction;
4054
0
  struct strbuf ref_name = STRBUF_INIT, err = STRBUF_INIT;
4055
0
  struct strbuf msg = STRBUF_INIT;
4056
0
  int ret = 0;
4057
0
  struct object_id head_oid;
4058
4059
0
  if (len == 1 && *name == '#')
4060
0
    return error(_("illegal label name: '%.*s'"), len, name);
4061
4062
0
  strbuf_addf(&ref_name, "refs/rewritten/%.*s", len, name);
4063
0
  strbuf_addf(&msg, "rebase (label) '%.*s'", len, name);
4064
4065
0
  transaction = ref_store_transaction_begin(refs, 0, &err);
4066
0
  if (!transaction) {
4067
0
    error("%s", err.buf);
4068
0
    ret = -1;
4069
0
  } else if (repo_get_oid(r, "HEAD", &head_oid)) {
4070
0
    error(_("could not read HEAD"));
4071
0
    ret = -1;
4072
0
  } else if (ref_transaction_update(transaction, ref_name.buf,
4073
0
            &head_oid, NULL, NULL, NULL,
4074
0
            0, msg.buf, &err) < 0 ||
4075
0
       ref_transaction_commit(transaction, &err)) {
4076
0
    error("%s", err.buf);
4077
0
    ret = -1;
4078
0
  }
4079
0
  ref_transaction_free(transaction);
4080
0
  strbuf_release(&err);
4081
0
  strbuf_release(&msg);
4082
4083
0
  if (!ret)
4084
0
    ret = safe_append(rebase_path_refs_to_delete(),
4085
0
          "%s\n", ref_name.buf);
4086
0
  strbuf_release(&ref_name);
4087
4088
0
  return ret;
4089
0
}
4090
4091
static struct commit *lookup_label(struct repository *r, const char *label,
4092
           int len, struct strbuf *buf)
4093
0
{
4094
0
  struct commit *commit;
4095
0
  struct object_id oid;
4096
4097
0
  strbuf_reset(buf);
4098
0
  strbuf_addf(buf, "refs/rewritten/%.*s", len, label);
4099
0
  if (!refs_read_ref(get_main_ref_store(the_repository), buf->buf, &oid)) {
4100
0
    commit = lookup_commit_object(r, &oid);
4101
0
  } else {
4102
    /* fall back to non-rewritten ref or commit */
4103
0
    strbuf_splice(buf, 0, strlen("refs/rewritten/"), "", 0);
4104
0
    commit = lookup_commit_reference_by_name(buf->buf);
4105
0
  }
4106
4107
0
  if (!commit)
4108
0
    error(_("could not resolve '%s'"), buf->buf);
4109
4110
0
  return commit;
4111
0
}
4112
4113
static int do_reset(struct repository *r,
4114
        const char *name, int len,
4115
        struct replay_opts *opts)
4116
0
{
4117
0
  struct strbuf ref_name = STRBUF_INIT;
4118
0
  struct object_id oid;
4119
0
  struct lock_file lock = LOCK_INIT;
4120
0
  struct tree_desc desc = { 0 };
4121
0
  struct tree *tree;
4122
0
  struct unpack_trees_options unpack_tree_opts = { 0 };
4123
0
  int ret = 0;
4124
4125
0
  if (repo_hold_locked_index(r, &lock, LOCK_REPORT_ON_ERROR) < 0)
4126
0
    return -1;
4127
4128
0
  if (len == 10 && !strncmp("[new root]", name, len)) {
4129
0
    if (!opts->have_squash_onto) {
4130
0
      const char *hex;
4131
0
      if (commit_tree("", 0, the_hash_algo->empty_tree,
4132
0
          NULL, &opts->squash_onto,
4133
0
          NULL, NULL))
4134
0
        return error(_("writing fake root commit"));
4135
0
      opts->have_squash_onto = 1;
4136
0
      hex = oid_to_hex(&opts->squash_onto);
4137
0
      if (write_message(hex, strlen(hex),
4138
0
            rebase_path_squash_onto(), 0))
4139
0
        return error(_("writing squash-onto"));
4140
0
    }
4141
0
    oidcpy(&oid, &opts->squash_onto);
4142
0
  } else {
4143
0
    int i;
4144
0
    struct commit *commit;
4145
4146
    /* Determine the length of the label */
4147
0
    for (i = 0; i < len; i++)
4148
0
      if (isspace(name[i]))
4149
0
        break;
4150
0
    len = i;
4151
4152
0
    commit = lookup_label(r, name, len, &ref_name);
4153
0
    if (!commit) {
4154
0
      ret = -1;
4155
0
      goto cleanup;
4156
0
    }
4157
0
    oid = commit->object.oid;
4158
0
  }
4159
4160
0
  setup_unpack_trees_porcelain(&unpack_tree_opts, "reset");
4161
0
  unpack_tree_opts.head_idx = 1;
4162
0
  unpack_tree_opts.src_index = r->index;
4163
0
  unpack_tree_opts.dst_index = r->index;
4164
0
  unpack_tree_opts.fn = oneway_merge;
4165
0
  unpack_tree_opts.merge = 1;
4166
0
  unpack_tree_opts.update = 1;
4167
0
  unpack_tree_opts.preserve_ignored = 0; /* FIXME: !overwrite_ignore */
4168
0
  unpack_tree_opts.skip_cache_tree_update = 1;
4169
0
  init_checkout_metadata(&unpack_tree_opts.meta, name, &oid, NULL);
4170
4171
0
  if (repo_read_index_unmerged(r)) {
4172
0
    ret = error_resolve_conflict(action_name(opts));
4173
0
    goto cleanup;
4174
0
  }
4175
4176
0
  if (!fill_tree_descriptor(r, &desc, &oid)) {
4177
0
    ret = error(_("failed to find tree of %s"), oid_to_hex(&oid));
4178
0
    goto cleanup;
4179
0
  }
4180
4181
0
  if (unpack_trees(1, &desc, &unpack_tree_opts)) {
4182
0
    ret = -1;
4183
0
    goto cleanup;
4184
0
  }
4185
4186
0
  tree = repo_parse_tree_indirect(the_repository, &oid);
4187
0
  if (!tree)
4188
0
    return error(_("unable to read tree (%s)"), oid_to_hex(&oid));
4189
0
  prime_cache_tree(r, r->index, tree);
4190
4191
0
  if (write_locked_index(r->index, &lock, COMMIT_LOCK) < 0)
4192
0
    ret = error(_("could not write index"));
4193
4194
0
  if (!ret)
4195
0
    ret = refs_update_ref(get_main_ref_store(the_repository), reflog_message(opts, "reset", "'%.*s'",
4196
0
                       len, name),
4197
0
              "HEAD", &oid,
4198
0
              NULL, 0, UPDATE_REFS_MSG_ON_ERR);
4199
0
cleanup:
4200
0
  free((void *)desc.buffer);
4201
0
  if (ret < 0)
4202
0
    rollback_lock_file(&lock);
4203
0
  strbuf_release(&ref_name);
4204
0
  clear_unpack_trees_porcelain(&unpack_tree_opts);
4205
0
  return ret;
4206
0
}
4207
4208
static int do_merge(struct repository *r,
4209
        struct commit *commit,
4210
        const char *arg, int arg_len,
4211
        int flags, int *check_todo, struct replay_opts *opts)
4212
0
{
4213
0
  struct replay_ctx *ctx = opts->ctx;
4214
0
  int run_commit_flags = 0;
4215
0
  struct strbuf ref_name = STRBUF_INIT;
4216
0
  struct commit *head_commit, *merge_commit, *i;
4217
0
  struct commit_list *bases = NULL, *j;
4218
0
  struct commit_list *to_merge = NULL, **tail = &to_merge;
4219
0
  const char *strategy = !opts->xopts.nr &&
4220
0
    (!opts->strategy ||
4221
0
     !strcmp(opts->strategy, "recursive") ||
4222
0
     !strcmp(opts->strategy, "ort")) ?
4223
0
    NULL : opts->strategy;
4224
0
  struct merge_options o;
4225
0
  int merge_arg_len, oneline_offset, can_fast_forward, ret, k;
4226
0
  static struct lock_file lock;
4227
0
  const char *p;
4228
0
  const char *reflog_action = reflog_message(opts, "merge", NULL);
4229
4230
0
  if (repo_hold_locked_index(r, &lock, LOCK_REPORT_ON_ERROR) < 0) {
4231
0
    ret = -1;
4232
0
    goto leave_merge;
4233
0
  }
4234
4235
0
  head_commit = lookup_commit_reference_by_name("HEAD");
4236
0
  if (!head_commit) {
4237
0
    ret = error(_("cannot merge without a current revision"));
4238
0
    goto leave_merge;
4239
0
  }
4240
4241
  /*
4242
   * For octopus merges, the arg starts with the list of revisions to be
4243
   * merged. The list is optionally followed by '#' and the oneline.
4244
   */
4245
0
  merge_arg_len = oneline_offset = arg_len;
4246
0
  for (p = arg; p - arg < arg_len; p += strspn(p, " \t\n")) {
4247
0
    if (!*p)
4248
0
      break;
4249
0
    if (*p == '#' && (!p[1] || isspace(p[1]))) {
4250
0
      p += 1 + strspn(p + 1, " \t\n");
4251
0
      oneline_offset = p - arg;
4252
0
      break;
4253
0
    }
4254
0
    k = strcspn(p, " \t\n");
4255
0
    if (!k)
4256
0
      continue;
4257
0
    merge_commit = lookup_label(r, p, k, &ref_name);
4258
0
    if (!merge_commit) {
4259
0
      ret = error(_("unable to parse '%.*s'"), k, p);
4260
0
      goto leave_merge;
4261
0
    }
4262
0
    tail = &commit_list_insert(merge_commit, tail)->next;
4263
0
    p += k;
4264
0
    merge_arg_len = p - arg;
4265
0
  }
4266
4267
0
  if (!to_merge) {
4268
0
    ret = error(_("nothing to merge: '%.*s'"), arg_len, arg);
4269
0
    goto leave_merge;
4270
0
  }
4271
4272
0
  if (opts->have_squash_onto &&
4273
0
      oideq(&head_commit->object.oid, &opts->squash_onto)) {
4274
    /*
4275
     * When the user tells us to "merge" something into a
4276
     * "[new root]", let's simply fast-forward to the merge head.
4277
     */
4278
0
    rollback_lock_file(&lock);
4279
0
    if (to_merge->next)
4280
0
      ret = error(_("octopus merge cannot be executed on "
4281
0
              "top of a [new root]"));
4282
0
    else
4283
0
      ret = fast_forward_to(r, &to_merge->item->object.oid,
4284
0
                &head_commit->object.oid, 0,
4285
0
                opts);
4286
0
    goto leave_merge;
4287
0
  }
4288
4289
  /*
4290
   * If HEAD is not identical to the first parent of the original merge
4291
   * commit, we cannot fast-forward.
4292
   */
4293
0
  can_fast_forward = opts->allow_ff && commit && commit->parents &&
4294
0
    oideq(&commit->parents->item->object.oid,
4295
0
          &head_commit->object.oid);
4296
4297
  /*
4298
   * If any merge head is different from the original one, we cannot
4299
   * fast-forward.
4300
   */
4301
0
  if (can_fast_forward) {
4302
0
    struct commit_list *p = commit->parents->next;
4303
4304
0
    for (j = to_merge; j && p; j = j->next, p = p->next)
4305
0
      if (!oideq(&j->item->object.oid,
4306
0
           &p->item->object.oid)) {
4307
0
        can_fast_forward = 0;
4308
0
        break;
4309
0
      }
4310
    /*
4311
     * If the number of merge heads differs from the original merge
4312
     * commit, we cannot fast-forward.
4313
     */
4314
0
    if (j || p)
4315
0
      can_fast_forward = 0;
4316
0
  }
4317
4318
0
  if (can_fast_forward) {
4319
0
    rollback_lock_file(&lock);
4320
0
    ret = fast_forward_to(r, &commit->object.oid,
4321
0
              &head_commit->object.oid, 0, opts);
4322
0
    if (flags & TODO_EDIT_MERGE_MSG)
4323
0
      goto fast_forward_edit;
4324
4325
0
    goto leave_merge;
4326
0
  }
4327
4328
0
  if (commit) {
4329
0
    const char *encoding = get_commit_output_encoding();
4330
0
    const char *message = repo_logmsg_reencode(r, commit, NULL,
4331
0
                 encoding);
4332
0
    const char *body;
4333
0
    int len;
4334
4335
0
    if (!message) {
4336
0
      ret = error(_("could not get commit message of '%s'"),
4337
0
            oid_to_hex(&commit->object.oid));
4338
0
      goto leave_merge;
4339
0
    }
4340
0
    write_author_script(message);
4341
0
    find_commit_subject(message, &body);
4342
0
    len = strlen(body);
4343
0
    strbuf_add(&ctx->message, body, len);
4344
0
    repo_unuse_commit_buffer(r, commit, message);
4345
0
  } else {
4346
0
    struct strbuf buf = STRBUF_INIT;
4347
4348
0
    strbuf_addf(&buf, "author %s", git_author_info(0));
4349
0
    write_author_script(buf.buf);
4350
0
    strbuf_release(&buf);
4351
4352
0
    if (oneline_offset < arg_len) {
4353
0
      strbuf_add(&ctx->message, arg + oneline_offset,
4354
0
           arg_len - oneline_offset);
4355
0
    } else {
4356
0
      strbuf_addf(&ctx->message, "Merge %s '%.*s'",
4357
0
            to_merge->next ? "branches" : "branch",
4358
0
            merge_arg_len, arg);
4359
0
    }
4360
0
  }
4361
0
  ctx->have_message = 1;
4362
0
  if (write_message(ctx->message.buf, ctx->message.len,
4363
0
        git_path_merge_msg(r), 0)) {
4364
0
        ret = error_errno(_("could not write '%s'"),
4365
0
              git_path_merge_msg(r));
4366
0
        goto leave_merge;
4367
0
  }
4368
4369
0
  if (strategy || to_merge->next) {
4370
    /* Octopus merge */
4371
0
    struct child_process cmd = CHILD_PROCESS_INIT;
4372
4373
0
    if (read_env_script(&cmd.env)) {
4374
0
      const char *gpg_opt = gpg_sign_opt_quoted(opts);
4375
4376
0
      ret = error(_(staged_changes_advice), gpg_opt, gpg_opt);
4377
0
      goto leave_merge;
4378
0
    }
4379
4380
0
    if (opts->committer_date_is_author_date)
4381
0
      strvec_pushf(&cmd.env, "GIT_COMMITTER_DATE=%s",
4382
0
             opts->ignore_date ?
4383
0
             "" :
4384
0
             author_date_from_env(&cmd.env));
4385
0
    if (opts->ignore_date)
4386
0
      strvec_push(&cmd.env, "GIT_AUTHOR_DATE=");
4387
0
    disable_auto_maintenance(opts, &cmd);
4388
4389
0
    cmd.git_cmd = 1;
4390
0
    strvec_push(&cmd.args, "merge");
4391
0
    strvec_push(&cmd.args, "-s");
4392
0
    if (!strategy)
4393
0
      strvec_push(&cmd.args, "octopus");
4394
0
    else {
4395
0
      strvec_push(&cmd.args, strategy);
4396
0
      for (k = 0; k < opts->xopts.nr; k++)
4397
0
        strvec_pushf(&cmd.args,
4398
0
               "-X%s", opts->xopts.v[k]);
4399
0
    }
4400
0
    if (!(flags & TODO_EDIT_MERGE_MSG))
4401
0
      strvec_push(&cmd.args, "--no-edit");
4402
0
    else
4403
0
      strvec_push(&cmd.args, "--edit");
4404
0
    strvec_push(&cmd.args, "--no-ff");
4405
0
    strvec_push(&cmd.args, "--no-log");
4406
0
    strvec_push(&cmd.args, "--no-stat");
4407
0
    strvec_push(&cmd.args, "-F");
4408
0
    strvec_push(&cmd.args, git_path_merge_msg(r));
4409
0
    if (opts->gpg_sign)
4410
0
      strvec_pushf(&cmd.args, "-S%s", opts->gpg_sign);
4411
0
    else
4412
0
      strvec_push(&cmd.args, "--no-gpg-sign");
4413
4414
    /* Add the tips to be merged */
4415
0
    for (j = to_merge; j; j = j->next)
4416
0
      strvec_push(&cmd.args,
4417
0
            oid_to_hex(&j->item->object.oid));
4418
4419
0
    strbuf_release(&ref_name);
4420
0
    refs_delete_ref(get_main_ref_store(r), "", "CHERRY_PICK_HEAD",
4421
0
        NULL, REF_NO_DEREF);
4422
0
    rollback_lock_file(&lock);
4423
4424
0
    ret = run_command(&cmd);
4425
4426
    /* force re-reading of the cache */
4427
0
    if (!ret) {
4428
0
      discard_index(r->index);
4429
0
      if (repo_read_index(r) < 0)
4430
0
        ret = error(_("could not read index"));
4431
0
    }
4432
0
    goto leave_merge;
4433
0
  }
4434
4435
0
  merge_commit = to_merge->item;
4436
0
  if (repo_get_merge_bases(r, head_commit, merge_commit, &bases) < 0) {
4437
0
    ret = -1;
4438
0
    goto leave_merge;
4439
0
  }
4440
4441
0
  if (bases && oideq(&merge_commit->object.oid,
4442
0
         &bases->item->object.oid)) {
4443
0
    ret = 0;
4444
    /* skip merging an ancestor of HEAD */
4445
0
    goto leave_merge;
4446
0
  }
4447
4448
0
  write_message(oid_to_hex(&merge_commit->object.oid), the_hash_algo->hexsz,
4449
0
          git_path_merge_head(r), 0);
4450
0
  write_message("no-ff", 5, git_path_merge_mode(r), 0);
4451
4452
0
  bases = commit_list_reverse(bases);
4453
4454
0
  repo_read_index(r);
4455
0
  init_ui_merge_options(&o, r);
4456
0
  o.branch1 = "HEAD";
4457
0
  o.branch2 = ref_name.buf;
4458
0
  o.buffer_output = 2;
4459
4460
  /*
4461
   * TODO: Should use merge_incore_recursive() and
4462
   * merge_switch_to_result(), skipping the call to
4463
   * merge_switch_to_result() when we don't actually need to
4464
   * update the index and working copy immediately.
4465
   */
4466
0
  ret = merge_ort_recursive(&o, head_commit, merge_commit, bases, &i);
4467
0
  if (ret <= 0)
4468
0
    fputs(o.obuf.buf, stdout);
4469
0
  strbuf_release(&o.obuf);
4470
0
  if (ret < 0) {
4471
0
    error(_("could not even attempt to merge '%.*s'"),
4472
0
          merge_arg_len, arg);
4473
0
    unlink(git_path_merge_msg(r));
4474
0
    goto leave_merge;
4475
0
  }
4476
  /*
4477
   * The return value of merge_ort_recursive() is 1 on clean, and 0 on
4478
   * unclean merge.
4479
   *
4480
   * Let's reverse that, so that do_merge() returns 0 upon success and
4481
   * 1 upon failed merge (keeping the return value -1 for the cases where
4482
   * we will want to reschedule the `merge` command).
4483
   */
4484
0
  ret = !ret;
4485
4486
0
  if (r->index->cache_changed &&
4487
0
      write_locked_index(r->index, &lock, COMMIT_LOCK)) {
4488
0
    ret = error(_("merge: Unable to write new index file"));
4489
0
    goto leave_merge;
4490
0
  }
4491
4492
0
  rollback_lock_file(&lock);
4493
0
  if (ret)
4494
0
    repo_rerere(r, opts->allow_rerere_auto);
4495
0
  else
4496
    /*
4497
     * In case of problems, we now want to return a positive
4498
     * value (a negative one would indicate that the `merge`
4499
     * command needs to be rescheduled).
4500
     */
4501
0
    ret = !!run_git_commit(git_path_merge_msg(r), reflog_action,
4502
0
               opts, run_commit_flags);
4503
4504
0
  if (!ret && flags & TODO_EDIT_MERGE_MSG) {
4505
0
  fast_forward_edit:
4506
0
    *check_todo = 1;
4507
0
    run_commit_flags |= AMEND_MSG | EDIT_MSG | VERIFY_MSG;
4508
0
    ret = !!run_git_commit(NULL, reflog_action, opts,
4509
0
               run_commit_flags);
4510
0
  }
4511
4512
4513
0
leave_merge:
4514
0
  strbuf_release(&ref_name);
4515
0
  rollback_lock_file(&lock);
4516
0
  commit_list_free(to_merge);
4517
0
  commit_list_free(bases);
4518
0
  return ret;
4519
0
}
4520
4521
static int write_update_refs_state(struct string_list *refs_to_oids)
4522
0
{
4523
0
  int result = 0;
4524
0
  struct lock_file lock = LOCK_INIT;
4525
0
  FILE *fp = NULL;
4526
0
  struct string_list_item *item;
4527
0
  char *path;
4528
4529
0
  path = rebase_path_update_refs(the_repository->gitdir);
4530
4531
0
  if (!refs_to_oids->nr) {
4532
0
    if (unlink(path) && errno != ENOENT)
4533
0
      result = error_errno(_("could not unlink: %s"), path);
4534
0
    goto cleanup;
4535
0
  }
4536
4537
0
  if (safe_create_leading_directories(the_repository, path)) {
4538
0
    result = error(_("unable to create leading directories of %s"),
4539
0
             path);
4540
0
    goto cleanup;
4541
0
  }
4542
4543
0
  if (hold_lock_file_for_update(&lock, path, 0) < 0) {
4544
0
    result = error(_("another 'rebase' process appears to be running; "
4545
0
         "'%s.lock' already exists"),
4546
0
             path);
4547
0
    goto cleanup;
4548
0
  }
4549
4550
0
  fp = fdopen_lock_file(&lock, "w");
4551
0
  if (!fp) {
4552
0
    result = error_errno(_("could not open '%s' for writing"), path);
4553
0
    rollback_lock_file(&lock);
4554
0
    goto cleanup;
4555
0
  }
4556
4557
0
  for_each_string_list_item(item, refs_to_oids) {
4558
0
    struct update_ref_record *rec = item->util;
4559
0
    fprintf(fp, "%s\n%s\n%s\n", item->string,
4560
0
      oid_to_hex(&rec->before), oid_to_hex(&rec->after));
4561
0
  }
4562
4563
0
  result = commit_lock_file(&lock);
4564
4565
0
cleanup:
4566
0
  free(path);
4567
0
  return result;
4568
0
}
4569
4570
/*
4571
 * Parse the update-refs file for the current rebase, then remove the
4572
 * refs that do not appear in the todo_list (and have not had updated
4573
 * values stored) and add refs that are in the todo_list but not
4574
 * represented in the update-refs file.
4575
 *
4576
 * If there are changes to the update-refs list, then write the new state
4577
 * to disk.
4578
 */
4579
void todo_list_filter_update_refs(struct repository *r,
4580
          struct todo_list *todo_list)
4581
0
{
4582
0
  int i;
4583
0
  int updated = 0;
4584
0
  struct string_list update_refs = STRING_LIST_INIT_DUP;
4585
4586
0
  sequencer_get_update_refs_state(r->gitdir, &update_refs);
4587
4588
  /*
4589
   * For each item in the update_refs list, if it has no updated
4590
   * value and does not appear in the todo_list, then remove it
4591
   * from the update_refs list.
4592
   */
4593
0
  for (i = 0; i < update_refs.nr; i++) {
4594
0
    int j;
4595
0
    int found = 0;
4596
0
    const char *ref = update_refs.items[i].string;
4597
0
    size_t reflen = strlen(ref);
4598
0
    struct update_ref_record *rec = update_refs.items[i].util;
4599
4600
    /* OID already stored as updated. */
4601
0
    if (!is_null_oid(&rec->after))
4602
0
      continue;
4603
4604
0
    for (j = 0; !found && j < todo_list->nr; j++) {
4605
0
      struct todo_item *item = &todo_list->items[j];
4606
0
      const char *arg = todo_list->buf.buf + item->arg_offset;
4607
4608
0
      if (item->command != TODO_UPDATE_REF)
4609
0
        continue;
4610
4611
0
      if (item->arg_len != reflen ||
4612
0
          strncmp(arg, ref, reflen))
4613
0
        continue;
4614
4615
0
      found = 1;
4616
0
    }
4617
4618
0
    if (!found) {
4619
0
      free(update_refs.items[i].string);
4620
0
      free(update_refs.items[i].util);
4621
4622
0
      update_refs.nr--;
4623
0
      MOVE_ARRAY(update_refs.items + i, update_refs.items + i + 1, update_refs.nr - i);
4624
4625
0
      updated = 1;
4626
0
      i--;
4627
0
    }
4628
0
  }
4629
4630
  /*
4631
   * For each todo_item, check if its ref is in the update_refs list.
4632
   * If not, then add it as an un-updated ref.
4633
   */
4634
0
  for (i = 0; i < todo_list->nr; i++) {
4635
0
    struct todo_item *item = &todo_list->items[i];
4636
0
    const char *arg = todo_list->buf.buf + item->arg_offset;
4637
0
    int j, found = 0;
4638
4639
0
    if (item->command != TODO_UPDATE_REF)
4640
0
      continue;
4641
4642
0
    for (j = 0; !found && j < update_refs.nr; j++) {
4643
0
      const char *ref = update_refs.items[j].string;
4644
4645
0
      found = strlen(ref) == item->arg_len &&
4646
0
        !strncmp(ref, arg, item->arg_len);
4647
0
    }
4648
4649
0
    if (!found) {
4650
0
      struct string_list_item *inserted;
4651
0
      struct strbuf argref = STRBUF_INIT;
4652
4653
0
      strbuf_add(&argref, arg, item->arg_len);
4654
0
      inserted = string_list_insert(&update_refs, argref.buf);
4655
0
      inserted->util = init_update_ref_record(argref.buf);
4656
0
      strbuf_release(&argref);
4657
0
      updated = 1;
4658
0
    }
4659
0
  }
4660
4661
0
  if (updated)
4662
0
    write_update_refs_state(&update_refs);
4663
0
  string_list_clear(&update_refs, 1);
4664
0
}
4665
4666
static int do_update_ref(struct repository *r, const char *refname)
4667
0
{
4668
0
  struct string_list_item *item;
4669
0
  struct string_list list = STRING_LIST_INIT_DUP;
4670
4671
0
  if (sequencer_get_update_refs_state(r->gitdir, &list))
4672
0
    return -1;
4673
4674
0
  for_each_string_list_item(item, &list) {
4675
0
    if (!strcmp(item->string, refname)) {
4676
0
      struct update_ref_record *rec = item->util;
4677
0
      if (refs_read_ref(get_main_ref_store(the_repository), "HEAD", &rec->after))
4678
0
        return -1;
4679
0
      break;
4680
0
    }
4681
0
  }
4682
4683
0
  write_update_refs_state(&list);
4684
0
  string_list_clear(&list, 1);
4685
0
  return 0;
4686
0
}
4687
4688
static int do_update_refs(struct repository *r, int quiet)
4689
0
{
4690
0
  int res = 0;
4691
0
  struct string_list_item *item;
4692
0
  struct string_list refs_to_oids = STRING_LIST_INIT_DUP;
4693
0
  struct ref_store *refs = get_main_ref_store(r);
4694
0
  struct strbuf update_msg = STRBUF_INIT;
4695
0
  struct strbuf error_msg = STRBUF_INIT;
4696
4697
0
  if ((res = sequencer_get_update_refs_state(r->gitdir, &refs_to_oids)))
4698
0
    return res;
4699
4700
0
  for_each_string_list_item(item, &refs_to_oids) {
4701
0
    struct update_ref_record *rec = item->util;
4702
0
    int loop_res;
4703
4704
0
    loop_res = refs_update_ref(refs, "rewritten during rebase",
4705
0
             item->string,
4706
0
             &rec->after, &rec->before,
4707
0
             0, UPDATE_REFS_MSG_ON_ERR);
4708
0
    res |= loop_res;
4709
4710
0
    if (quiet)
4711
0
      continue;
4712
4713
0
    if (loop_res)
4714
0
      strbuf_addf(&error_msg, "\t%s\n", item->string);
4715
0
    else
4716
0
      strbuf_addf(&update_msg, "\t%s\n", item->string);
4717
0
  }
4718
4719
0
  if (!quiet &&
4720
0
      (update_msg.len || error_msg.len)) {
4721
0
    fprintf(stderr,
4722
0
      _("Updated the following refs with %s:\n%s"),
4723
0
      "--update-refs",
4724
0
      update_msg.buf);
4725
4726
0
    if (res)
4727
0
      fprintf(stderr,
4728
0
        _("Failed to update the following refs with %s:\n%s"),
4729
0
        "--update-refs",
4730
0
        error_msg.buf);
4731
0
  }
4732
4733
0
  string_list_clear(&refs_to_oids, 1);
4734
0
  strbuf_release(&update_msg);
4735
0
  strbuf_release(&error_msg);
4736
0
  return res;
4737
0
}
4738
4739
static int is_final_fixup(struct todo_list *todo_list)
4740
0
{
4741
0
  int i = todo_list->current;
4742
4743
0
  if (!is_fixup(todo_list->items[i].command))
4744
0
    return 0;
4745
4746
0
  while (++i < todo_list->nr)
4747
0
    if (is_fixup(todo_list->items[i].command))
4748
0
      return 0;
4749
0
    else if (!is_noop(todo_list->items[i].command))
4750
0
      break;
4751
0
  return 1;
4752
0
}
4753
4754
static enum todo_command peek_command(struct todo_list *todo_list, int offset)
4755
0
{
4756
0
  int i;
4757
4758
0
  for (i = todo_list->current + offset; i < todo_list->nr; i++)
4759
0
    if (!is_noop(todo_list->items[i].command))
4760
0
      return todo_list->items[i].command;
4761
4762
0
  return -1;
4763
0
}
4764
4765
static void create_autostash_internal(struct repository *r,
4766
              const char *path,
4767
              const char *refname,
4768
              const char *message,
4769
              bool silent)
4770
0
{
4771
0
  struct strbuf buf = STRBUF_INIT;
4772
0
  struct lock_file lock_file = LOCK_INIT;
4773
0
  int fd;
4774
4775
0
  if (path && refname)
4776
0
    BUG("can only pass path or refname");
4777
4778
0
  fd = repo_hold_locked_index(r, &lock_file, 0);
4779
0
  refresh_index(r->index, REFRESH_QUIET, NULL, NULL, NULL);
4780
0
  if (0 <= fd)
4781
0
    repo_update_index_if_able(r, &lock_file);
4782
0
  rollback_lock_file(&lock_file);
4783
4784
0
  if (has_unstaged_changes(r, 1) ||
4785
0
      has_uncommitted_changes(r, 1)) {
4786
0
    struct child_process stash = CHILD_PROCESS_INIT;
4787
0
    struct reset_working_tree_options ropts = {
4788
0
      .flags = RESET_WORKING_TREE_HARD |
4789
0
         RESET_WORKING_TREE_UPDATE_HEAD,
4790
0
    };
4791
0
    struct object_id oid;
4792
4793
0
    strvec_pushl(&stash.args,
4794
0
           "stash", "create",
4795
0
           message ? message : "autostash", NULL);
4796
0
    stash.git_cmd = 1;
4797
0
    stash.no_stdin = 1;
4798
0
    strbuf_reset(&buf);
4799
0
    if (capture_command(&stash, &buf, GIT_MAX_HEXSZ))
4800
0
      die(_("Cannot autostash"));
4801
0
    strbuf_trim_trailing_newline(&buf);
4802
0
    if (repo_get_oid(r, buf.buf, &oid))
4803
0
      die(_("Unexpected stash response: '%s'"),
4804
0
          buf.buf);
4805
0
    strbuf_reset(&buf);
4806
0
    strbuf_add_unique_abbrev(&buf, &oid, DEFAULT_ABBREV);
4807
4808
0
    if (path) {
4809
0
      if (safe_create_leading_directories_const(the_repository, path))
4810
0
        die(_("Could not create directory for '%s'"),
4811
0
            path);
4812
0
      write_file(path, "%s", oid_to_hex(&oid));
4813
0
    } else {
4814
0
      refs_update_ref(get_main_ref_store(r), "", refname,
4815
0
          &oid, null_oid(the_hash_algo), 0, UPDATE_REFS_DIE_ON_ERR);
4816
0
    }
4817
4818
0
    if (!silent)
4819
0
      printf(_("Created autostash: %s\n"), buf.buf);
4820
0
    if (reset_working_tree(r, &ropts) < 0)
4821
0
      die(_("could not reset --hard"));
4822
0
    discard_index(r->index);
4823
0
    if (repo_read_index(r) < 0)
4824
0
      die(_("could not read index"));
4825
0
  }
4826
0
  strbuf_release(&buf);
4827
0
}
4828
4829
void create_autostash(struct repository *r, const char *path)
4830
0
{
4831
0
  create_autostash_internal(r, path, NULL, NULL, false);
4832
0
}
4833
4834
void create_autostash_ref(struct repository *r, const char *refname,
4835
        const char *message, bool silent)
4836
0
{
4837
0
  create_autostash_internal(r, NULL, refname, message, silent);
4838
0
}
4839
4840
static enum stash_apply_result do_stash_apply(const char *stash_oid,
4841
                const char *label_ours,
4842
                const char *label_theirs,
4843
                const char *label_base)
4844
0
{
4845
0
  struct child_process child = CHILD_PROCESS_INIT;
4846
4847
0
  child.git_cmd = 1;
4848
0
  child.no_stdout = 1;
4849
0
  child.no_stderr = 1;
4850
0
  strvec_push(&child.args, "stash");
4851
0
  strvec_push(&child.args, "apply");
4852
0
  if (label_ours)
4853
0
    strvec_pushf(&child.args, "--label-ours=%s", label_ours);
4854
0
  if (label_theirs)
4855
0
    strvec_pushf(&child.args, "--label-theirs=%s", label_theirs);
4856
0
  if (label_base)
4857
0
    strvec_pushf(&child.args, "--label-base=%s", label_base);
4858
0
  strvec_push(&child.args, stash_oid);
4859
4860
0
  switch (run_command(&child)) {
4861
0
  case 0:
4862
0
    return STASH_APPLY_CLEAN;
4863
0
  case STASH_APPLY_CONFLICT:
4864
0
    return STASH_APPLY_CONFLICT;
4865
0
  default:
4866
0
    return STASH_APPLY_ERROR;
4867
0
  }
4868
0
}
4869
4870
static enum stash_apply_result apply_save_autostash_oid(const char *stash_oid,
4871
              int attempt_apply,
4872
              const char *label_ours,
4873
              const char *label_theirs,
4874
              const char *label_base,
4875
              const char *stash_msg)
4876
0
{
4877
0
  enum stash_apply_result ret = STASH_APPLY_CLEAN;
4878
4879
0
  if (attempt_apply)
4880
0
    ret = do_stash_apply(stash_oid, label_ours, label_theirs,
4881
0
             label_base);
4882
4883
0
  if (attempt_apply && ret == STASH_APPLY_CLEAN)
4884
0
    fprintf(stderr, _("Applied autostash.\n"));
4885
0
  else {
4886
0
    struct child_process store = CHILD_PROCESS_INIT;
4887
4888
0
    store.git_cmd = 1;
4889
0
    strvec_push(&store.args, "stash");
4890
0
    strvec_push(&store.args, "store");
4891
0
    strvec_push(&store.args, "-m");
4892
0
    strvec_push(&store.args, stash_msg ? stash_msg : "autostash");
4893
0
    strvec_push(&store.args, "-q");
4894
0
    strvec_push(&store.args, stash_oid);
4895
0
    if (run_command(&store))
4896
0
      ret = error(_("cannot store %s"), stash_oid);
4897
0
    else if (attempt_apply && ret == STASH_APPLY_CONFLICT)
4898
0
      fprintf(stderr,
4899
0
        _("Your local changes are stashed, however applying them\n"
4900
0
          "resulted in conflicts.  You can either resolve the conflicts\n"
4901
0
          "and then discard the stash with \"git stash drop\", or, if you\n"
4902
0
          "do not want to resolve them now, run \"git reset --hard\" and\n"
4903
0
          "apply the local changes later by running \"git stash pop\".\n"));
4904
0
    else if (attempt_apply)
4905
0
      ret = error(_("could not apply autostash; "
4906
0
              "your changes are safe in the stash"));
4907
0
    else
4908
0
      fprintf(stderr,
4909
0
        _("Autostash exists; creating a new stash entry.\n"
4910
0
          "Your changes are safe in the stash.\n"
4911
0
          "You can run \"git stash pop\" or"
4912
0
          " \"git stash drop\" at any time.\n"));
4913
0
  }
4914
4915
0
  return ret;
4916
0
}
4917
4918
static enum stash_apply_result apply_save_autostash(const char *path,
4919
                int attempt_apply)
4920
0
{
4921
0
  struct strbuf stash_oid = STRBUF_INIT;
4922
0
  enum stash_apply_result ret = STASH_APPLY_CLEAN;
4923
4924
0
  if (!read_oneliner(&stash_oid, path,
4925
0
         READ_ONELINER_SKIP_IF_EMPTY)) {
4926
0
    strbuf_release(&stash_oid);
4927
0
    return STASH_APPLY_CLEAN;
4928
0
  }
4929
0
  strbuf_trim(&stash_oid);
4930
4931
0
  ret = apply_save_autostash_oid(stash_oid.buf, attempt_apply,
4932
0
              NULL, NULL, NULL, NULL);
4933
4934
0
  unlink(path);
4935
0
  strbuf_release(&stash_oid);
4936
0
  return ret;
4937
0
}
4938
4939
enum stash_apply_result save_autostash(const char *path)
4940
0
{
4941
0
  return apply_save_autostash(path, 0);
4942
0
}
4943
4944
enum stash_apply_result apply_autostash(const char *path)
4945
0
{
4946
0
  return apply_save_autostash(path, 1);
4947
0
}
4948
4949
enum stash_apply_result apply_autostash_oid(const char *stash_oid)
4950
0
{
4951
0
  return apply_save_autostash_oid(stash_oid, 1, NULL, NULL, NULL, NULL);
4952
0
}
4953
4954
static enum stash_apply_result apply_save_autostash_ref(struct repository *r,
4955
              const char *refname,
4956
              int attempt_apply,
4957
              const char *label_ours,
4958
              const char *label_theirs,
4959
              const char *label_base,
4960
              const char *stash_msg)
4961
0
{
4962
0
  struct object_id stash_oid;
4963
0
  char stash_oid_hex[GIT_MAX_HEXSZ + 1];
4964
0
  int flag;
4965
0
  enum stash_apply_result ret;
4966
4967
0
  if (!refs_ref_exists(get_main_ref_store(r), refname))
4968
0
    return STASH_APPLY_CLEAN;
4969
4970
0
  if (!refs_resolve_ref_unsafe(get_main_ref_store(r), refname,
4971
0
             RESOLVE_REF_READING, &stash_oid, &flag))
4972
0
    return STASH_APPLY_ERROR;
4973
0
  if (flag & REF_ISSYMREF)
4974
0
    return error(_("autostash reference is a symref"));
4975
4976
0
  oid_to_hex_r(stash_oid_hex, &stash_oid);
4977
0
  ret = apply_save_autostash_oid(stash_oid_hex, attempt_apply,
4978
0
               label_ours, label_theirs, label_base,
4979
0
               stash_msg);
4980
4981
0
  refs_delete_ref(get_main_ref_store(r), "", refname,
4982
0
      &stash_oid, REF_NO_DEREF);
4983
4984
0
  return ret;
4985
0
}
4986
4987
enum stash_apply_result save_autostash_ref(struct repository *r,
4988
             const char *refname)
4989
0
{
4990
0
  return apply_save_autostash_ref(r, refname, 0,
4991
0
          NULL, NULL, NULL, NULL);
4992
0
}
4993
4994
enum stash_apply_result apply_autostash_ref(struct repository *r,
4995
              const char *refname,
4996
              const char *label_ours,
4997
              const char *label_theirs,
4998
              const char *label_base,
4999
              const char *stash_msg)
5000
0
{
5001
0
  return apply_save_autostash_ref(r, refname, 1,
5002
0
          label_ours, label_theirs, label_base,
5003
0
          stash_msg);
5004
0
}
5005
5006
static int checkout_onto(struct repository *r, struct replay_opts *opts,
5007
       const char *onto_name, const struct object_id *onto,
5008
       const struct object_id *orig_head)
5009
0
{
5010
0
  struct reset_working_tree_options ropts = {
5011
0
    .oid = onto,
5012
0
    .orig_head = orig_head,
5013
0
    .flags = RESET_WORKING_TREE_DETACH |
5014
0
       RESET_WORKING_TREE_UPDATE_HEAD |
5015
0
       RESET_WORKING_TREE_UPDATE_ORIG_HEAD |
5016
0
       RESET_WORKING_TREE_RUN_POST_CHECKOUT_HOOK,
5017
0
    .head_msg = reflog_message(opts, "start", "checkout %s",
5018
0
             onto_name),
5019
0
    .default_reflog_action = sequencer_reflog_action(opts)
5020
0
  };
5021
0
  if (reset_working_tree(r, &ropts)) {
5022
0
    apply_autostash(rebase_path_autostash());
5023
0
    sequencer_remove_state(opts);
5024
0
    return error(_("could not detach HEAD"));
5025
0
  }
5026
5027
0
  return 0;
5028
0
}
5029
5030
static int stopped_at_head(struct repository *r)
5031
0
{
5032
0
  struct object_id head;
5033
0
  struct commit *commit;
5034
0
  struct commit_message message;
5035
5036
0
  if (repo_get_oid(r, "HEAD", &head) ||
5037
0
      !(commit = lookup_commit(r, &head)) ||
5038
0
      repo_parse_commit(r, commit) || get_message(commit, &message))
5039
0
    fprintf(stderr, _("Stopped at HEAD\n"));
5040
0
  else {
5041
0
    fprintf(stderr, _("Stopped at %s\n"), message.label);
5042
0
    free_message(commit, &message);
5043
0
  }
5044
0
  return 0;
5045
5046
0
}
5047
5048
static int reread_todo_if_changed(struct repository *r,
5049
          struct todo_list *todo_list,
5050
          struct replay_opts *opts)
5051
0
{
5052
0
  int offset;
5053
0
  struct strbuf buf = STRBUF_INIT;
5054
5055
0
  if (strbuf_read_file_or_whine(&buf, get_todo_path(opts)) < 0)
5056
0
    return -1;
5057
0
  offset = get_item_line_offset(todo_list, todo_list->current + 1);
5058
0
  if (buf.len != todo_list->buf.len - offset ||
5059
0
      memcmp(buf.buf, todo_list->buf.buf + offset, buf.len)) {
5060
    /* Reread the todo file if it has changed. */
5061
0
    todo_list_release(todo_list);
5062
0
    if (read_populate_todo(r, todo_list, opts))
5063
0
      return -1; /* message was printed */
5064
    /* `current` will be incremented on return */
5065
0
    todo_list->current = -1;
5066
0
  }
5067
0
  strbuf_release(&buf);
5068
5069
0
  return 0;
5070
0
}
5071
5072
static const char rescheduled_advice[] =
5073
N_("Could not execute the todo command\n"
5074
"\n"
5075
"    %.*s"
5076
"\n"
5077
"It has been rescheduled; To edit the command before continuing, please\n"
5078
"edit the todo list first:\n"
5079
"\n"
5080
"    git rebase --edit-todo\n"
5081
"    git rebase --continue\n");
5082
5083
static int pick_one_commit(struct repository *r,
5084
         struct todo_list *todo_list,
5085
         struct replay_opts *opts,
5086
         int *check_todo, int* reschedule)
5087
0
{
5088
0
  enum pick_result pick_res;
5089
0
  struct todo_item *item = todo_list->items + todo_list->current;
5090
0
  const char *arg = todo_item_get_arg(todo_list, item);
5091
5092
0
  pick_res = do_pick_commit(r, item, opts, is_final_fixup(todo_list),
5093
0
          check_todo);
5094
0
  if (!is_rebase_i(opts))
5095
0
    switch (pick_res) {
5096
0
    case PICK_RESULT_ERROR:
5097
0
      return -1;
5098
0
    case PICK_RESULT_CONFLICTS:
5099
0
      return 1;
5100
0
    default:
5101
0
      return 0;
5102
0
    }
5103
5104
0
  if (pick_res == PICK_RESULT_ERROR) {
5105
    /* Reschedule */
5106
0
    *reschedule = 1;
5107
0
    return -1;
5108
0
  } else if (item->command == TODO_EDIT) {
5109
0
    struct commit *commit = item->commit;
5110
0
    int res = pick_res == PICK_RESULT_CONFLICTS;
5111
0
    int to_amend = pick_res != PICK_RESULT_CONFLICTS &&
5112
0
        pick_res != PICK_RESULT_DROPPED;
5113
5114
    /*
5115
     * NEEDSWORK: Do not record the commit as rewritten when
5116
     * continuing if it was dropped. Does it even make sense
5117
     * to stop if the commit was dropped?
5118
     */
5119
0
    if (pick_res == PICK_RESULT_OK ||
5120
0
        pick_res == PICK_RESULT_DROPPED) {
5121
0
      if (!opts->verbose)
5122
0
        term_clear_line();
5123
0
      fprintf(stderr, _("Stopped at %s...  %.*s\n"),
5124
0
        short_commit_name(r, commit), item->arg_len, arg);
5125
0
    }
5126
0
    return error_with_patch(r, commit, arg, item->arg_len, opts,
5127
0
          res, to_amend);
5128
0
  } else if (pick_res == PICK_RESULT_OK) {
5129
0
    record_in_rewritten(&item->commit->object.oid,
5130
0
            peek_command(todo_list, 1));
5131
0
    return 0;
5132
0
  } else if (pick_res == PICK_RESULT_DROPPED) {
5133
0
    if (is_final_fixup(todo_list))
5134
0
      flush_rewritten_pending();
5135
0
    return 0;
5136
0
  } else if (pick_res == PICK_RESULT_CONFLICTS &&
5137
0
       is_fixup(item->command)) {
5138
0
    return error_failed_squash(r, item->commit, opts,
5139
0
             item->arg_len, arg);
5140
0
  } else if (pick_res == PICK_RESULT_CONFLICTS) {
5141
0
    int to_amend = 0;
5142
0
    struct object_id oid;
5143
5144
    /*
5145
     * If we are rewording and have either
5146
     * fast-forwarded already, or are about to
5147
     * create a new root commit, we want to amend,
5148
     * otherwise we do not.
5149
     */
5150
0
    if (item->command == TODO_REWORD &&
5151
0
        !repo_get_oid(r, "HEAD", &oid) &&
5152
0
        (oideq(&item->commit->object.oid, &oid) ||
5153
0
         (opts->have_squash_onto &&
5154
0
          oideq(&opts->squash_onto, &oid))))
5155
0
      to_amend = 1;
5156
5157
0
    return error_with_patch(r, item->commit, arg, item->arg_len,
5158
0
          opts, 1, to_amend);
5159
0
  }
5160
5161
0
  BUG("Unhandled return value from do_pick_commit()");
5162
0
}
5163
5164
static int pick_commits(struct repository *r,
5165
      struct todo_list *todo_list,
5166
      struct replay_opts *opts)
5167
0
{
5168
0
  struct replay_ctx *ctx = opts->ctx;
5169
0
  int res = 0, reschedule = 0;
5170
5171
0
  if (opts->allow_ff)
5172
0
    ASSERT(!(opts->signoff || opts->no_commit ||
5173
0
       opts->record_origin || should_edit(opts) ||
5174
0
       opts->committer_date_is_author_date ||
5175
0
       opts->ignore_date));
5176
0
  if (read_and_refresh_cache(r, opts))
5177
0
    return -1;
5178
5179
0
  unlink(rebase_path_message());
5180
0
  unlink(rebase_path_stopped_sha());
5181
0
  unlink(rebase_path_amend());
5182
0
  unlink(rebase_path_patch());
5183
0
  unlink(git_path_merge_labels(r));
5184
0
  refs_delete_ref(get_main_ref_store(r), "", "AUTO_MERGE", NULL,
5185
0
      REF_NO_DEREF);
5186
0
  refs_delete_ref(get_main_ref_store(r), "", "REBASE_HEAD", NULL,
5187
0
      REF_NO_DEREF);
5188
5189
0
  while (todo_list->current < todo_list->nr) {
5190
0
    struct todo_item *item = todo_list->items + todo_list->current;
5191
0
    const char *arg = todo_item_get_arg(todo_list, item);
5192
0
    int check_todo = 0;
5193
5194
0
    if (save_todo(todo_list, opts, reschedule))
5195
0
      return -1;
5196
0
    if (is_rebase_i(opts)) {
5197
0
      if (item->command != TODO_COMMENT) {
5198
0
        FILE *f = fopen(rebase_path_msgnum(), "w");
5199
5200
0
        todo_list->done_nr++;
5201
5202
0
        if (f) {
5203
0
          fprintf(f, "%d\n", todo_list->done_nr);
5204
0
          fclose(f);
5205
0
        }
5206
0
        if (!opts->quiet)
5207
0
          fprintf(stderr, _("Rebasing (%d/%d)%s"),
5208
0
            todo_list->done_nr,
5209
0
            todo_list->total_nr,
5210
0
            opts->verbose ? "\n" : "\r");
5211
0
      }
5212
0
      unlink(rebase_path_author_script());
5213
0
      unlink(git_path_merge_head(r));
5214
5215
0
      if (item->command == TODO_BREAK) {
5216
0
        if (!opts->verbose)
5217
0
          term_clear_line();
5218
0
        return stopped_at_head(r);
5219
0
      }
5220
0
    }
5221
0
    strbuf_reset(&ctx->message);
5222
0
    ctx->have_message = 0;
5223
0
    if (item->command <= TODO_SQUASH) {
5224
0
      res = pick_one_commit(r, todo_list, opts, &check_todo,
5225
0
                &reschedule);
5226
0
      if (!res && item->command == TODO_EDIT)
5227
0
        return 0;
5228
0
    } else if (item->command == TODO_EXEC) {
5229
0
      char *end_of_arg = (char *)(arg + item->arg_len);
5230
0
      int saved = *end_of_arg;
5231
5232
0
      if (!opts->verbose)
5233
0
        term_clear_line();
5234
0
      *end_of_arg = '\0';
5235
0
      res = do_exec(r, arg, opts);
5236
0
      *end_of_arg = saved;
5237
5238
0
      if (res) {
5239
0
        if (opts->reschedule_failed_exec)
5240
0
          reschedule = 1;
5241
0
      }
5242
0
      check_todo = 1;
5243
0
    } else if (item->command == TODO_LABEL) {
5244
0
      if ((res = do_label(r, arg, item->arg_len)))
5245
0
        reschedule = 1;
5246
0
    } else if (item->command == TODO_RESET) {
5247
0
      if ((res = do_reset(r, arg, item->arg_len, opts)))
5248
0
        reschedule = 1;
5249
0
    } else if (item->command == TODO_MERGE) {
5250
0
      if ((res = do_merge(r, item->commit, arg, item->arg_len,
5251
0
              item->flags, &check_todo, opts)) < 0)
5252
0
        reschedule = 1;
5253
0
      else if (item->commit)
5254
0
        record_in_rewritten(&item->commit->object.oid,
5255
0
                peek_command(todo_list, 1));
5256
0
      if (res > 0)
5257
        /* failed with merge conflicts */
5258
0
        return error_with_patch(r, item->commit,
5259
0
              arg, item->arg_len,
5260
0
              opts, res, 0);
5261
0
    } else if (item->command == TODO_UPDATE_REF) {
5262
0
      struct strbuf ref = STRBUF_INIT;
5263
0
      strbuf_add(&ref, arg, item->arg_len);
5264
0
      if ((res = do_update_ref(r, ref.buf)))
5265
0
        reschedule = 1;
5266
0
      strbuf_release(&ref);
5267
0
    } else if (!is_noop(item->command))
5268
0
      return error(_("unknown command %d"), item->command);
5269
5270
0
    if (reschedule) {
5271
0
      advise(_(rescheduled_advice),
5272
0
             get_item_line_length(todo_list,
5273
0
                todo_list->current),
5274
0
             get_item_line(todo_list, todo_list->current));
5275
0
      if (save_todo(todo_list, opts, reschedule))
5276
0
        return -1;
5277
0
      if (item->commit)
5278
0
        write_rebase_head(&item->commit->object.oid);
5279
0
    } else if (is_rebase_i(opts) && check_todo && !res &&
5280
0
         reread_todo_if_changed(r, todo_list, opts)) {
5281
0
      return -1;
5282
0
    }
5283
5284
0
    if (res)
5285
0
      return res;
5286
5287
0
    todo_list->current++;
5288
0
  }
5289
5290
0
  if (is_rebase_i(opts)) {
5291
0
    struct strbuf head_ref = STRBUF_INIT, buf = STRBUF_INIT;
5292
0
    struct stat st;
5293
5294
0
    if (read_oneliner(&head_ref, rebase_path_head_name(), 0) &&
5295
0
        starts_with(head_ref.buf, "refs/")) {
5296
0
      const char *msg;
5297
0
      struct object_id head, orig;
5298
0
      int res;
5299
5300
0
      if (repo_get_oid(r, "HEAD", &head)) {
5301
0
        res = error(_("cannot read HEAD"));
5302
0
cleanup_head_ref:
5303
0
        strbuf_release(&head_ref);
5304
0
        strbuf_release(&buf);
5305
0
        return res;
5306
0
      }
5307
0
      if (!read_oneliner(&buf, rebase_path_orig_head(), 0) ||
5308
0
          get_oid_hex(buf.buf, &orig)) {
5309
0
        res = error(_("could not read orig-head"));
5310
0
        goto cleanup_head_ref;
5311
0
      }
5312
0
      strbuf_reset(&buf);
5313
0
      if (!read_oneliner(&buf, rebase_path_onto(), 0)) {
5314
0
        res = error(_("could not read 'onto'"));
5315
0
        goto cleanup_head_ref;
5316
0
      }
5317
0
      msg = reflog_message(opts, "finish", "%s onto %s",
5318
0
        head_ref.buf, buf.buf);
5319
0
      if (refs_update_ref(get_main_ref_store(the_repository), msg, head_ref.buf, &head, &orig,
5320
0
              REF_NO_DEREF, UPDATE_REFS_MSG_ON_ERR)) {
5321
0
        res = error(_("could not update %s"),
5322
0
          head_ref.buf);
5323
0
        goto cleanup_head_ref;
5324
0
      }
5325
0
      msg = reflog_message(opts, "finish", "returning to %s",
5326
0
        head_ref.buf);
5327
0
      if (refs_update_symref(get_main_ref_store(the_repository), "HEAD", head_ref.buf, msg)) {
5328
0
        res = error(_("could not update HEAD to %s"),
5329
0
          head_ref.buf);
5330
0
        goto cleanup_head_ref;
5331
0
      }
5332
0
      strbuf_reset(&buf);
5333
0
    }
5334
5335
0
    if (opts->verbose) {
5336
0
      struct rev_info log_tree_opt;
5337
0
      struct object_id orig, head;
5338
5339
0
      memset(&log_tree_opt, 0, sizeof(log_tree_opt));
5340
0
      repo_init_revisions(r, &log_tree_opt, NULL);
5341
0
      log_tree_opt.diff = 1;
5342
0
      log_tree_opt.diffopt.output_format =
5343
0
        DIFF_FORMAT_DIFFSTAT;
5344
0
      log_tree_opt.disable_stdin = 1;
5345
5346
0
      if (read_oneliner(&buf, rebase_path_orig_head(), 0) &&
5347
0
          !repo_get_oid(r, buf.buf, &orig) &&
5348
0
          !repo_get_oid(r, "HEAD", &head)) {
5349
0
        diff_tree_oid(&orig, &head, "",
5350
0
                &log_tree_opt.diffopt);
5351
0
        log_tree_diff_flush(&log_tree_opt);
5352
0
      }
5353
0
      release_revisions(&log_tree_opt);
5354
0
    }
5355
0
    flush_rewritten_pending();
5356
0
    if (!stat(rebase_path_rewritten_list(), &st) &&
5357
0
        st.st_size > 0) {
5358
0
      struct child_process child = CHILD_PROCESS_INIT;
5359
0
      struct run_hooks_opt hook_opt = RUN_HOOKS_OPT_INIT;
5360
5361
0
      child.in = open(rebase_path_rewritten_list(), O_RDONLY);
5362
0
      child.git_cmd = 1;
5363
0
      strvec_push(&child.args, "notes");
5364
0
      strvec_push(&child.args, "copy");
5365
0
      strvec_push(&child.args, "--for-rewrite=rebase");
5366
      /* we don't care if this copying failed */
5367
0
      run_command(&child);
5368
5369
0
      hook_opt.path_to_stdin = rebase_path_rewritten_list();
5370
0
      strvec_push(&hook_opt.args, "rebase");
5371
0
      run_hooks_opt(r, "post-rewrite", &hook_opt);
5372
0
    }
5373
0
    apply_autostash(rebase_path_autostash());
5374
5375
0
    if (!opts->quiet) {
5376
0
      if (!opts->verbose)
5377
0
        term_clear_line();
5378
0
      fprintf(stderr,
5379
0
        _("Successfully rebased and updated %s.\n"),
5380
0
        head_ref.buf);
5381
0
    }
5382
5383
0
    strbuf_release(&buf);
5384
0
    strbuf_release(&head_ref);
5385
5386
0
    if (do_update_refs(r, opts->quiet))
5387
0
      return -1;
5388
0
  }
5389
5390
  /*
5391
   * Sequence of picks finished successfully; cleanup by
5392
   * removing the .git/sequencer directory
5393
   */
5394
0
  return sequencer_remove_state(opts);
5395
0
}
5396
5397
static int continue_single_pick(struct repository *r, struct replay_opts *opts)
5398
0
{
5399
0
  struct child_process cmd = CHILD_PROCESS_INIT;
5400
5401
0
  if (!refs_ref_exists(get_main_ref_store(r), "CHERRY_PICK_HEAD") &&
5402
0
      !refs_ref_exists(get_main_ref_store(r), "REVERT_HEAD"))
5403
0
    return error(_("no cherry-pick or revert in progress"));
5404
5405
0
  cmd.git_cmd = 1;
5406
0
  disable_auto_maintenance(opts, &cmd);
5407
0
  strvec_push(&cmd.args, "commit");
5408
5409
  /*
5410
   * continue_single_pick() handles the case of recovering from a
5411
   * conflict.  should_edit() doesn't handle that case; for a conflict,
5412
   * we want to edit if the user asked for it, or if they didn't specify
5413
   * and stdin is a tty.
5414
   */
5415
0
  if (!opts->edit || (opts->edit < 0 && !isatty(0)))
5416
    /*
5417
     * Include --cleanup=strip as well because we don't want the
5418
     * "# Conflicts:" messages.
5419
     */
5420
0
    strvec_pushl(&cmd.args, "--no-edit", "--cleanup=strip", NULL);
5421
5422
0
  return run_command(&cmd);
5423
0
}
5424
5425
static int commit_staged_changes(struct repository *r,
5426
         struct replay_opts *opts,
5427
         struct todo_list *todo_list)
5428
0
{
5429
0
  struct replay_ctx *ctx = opts->ctx;
5430
0
  unsigned int flags = ALLOW_EMPTY | EDIT_MSG;
5431
0
  unsigned int final_fixup = 0, is_clean;
5432
0
  struct strbuf rev = STRBUF_INIT;
5433
0
  const char *reflog_action = reflog_message(opts, "continue", NULL);
5434
0
  int ret;
5435
5436
0
  if (has_unstaged_changes(r, 1)) {
5437
0
    ret = error(_("cannot rebase: You have unstaged changes."));
5438
0
    goto out;
5439
0
  }
5440
5441
0
  is_clean = !has_uncommitted_changes(r, 0);
5442
5443
0
  if (!is_clean && !file_exists(rebase_path_message())) {
5444
0
    const char *gpg_opt = gpg_sign_opt_quoted(opts);
5445
0
    ret = error(_(staged_changes_advice), gpg_opt, gpg_opt);
5446
0
    goto out;
5447
0
  }
5448
5449
0
  if (file_exists(rebase_path_amend())) {
5450
0
    struct object_id head, to_amend;
5451
5452
0
    if (repo_get_oid(r, "HEAD", &head)) {
5453
0
      ret = error(_("cannot amend non-existing commit"));
5454
0
      goto out;
5455
0
    }
5456
5457
0
    if (!read_oneliner(&rev, rebase_path_amend(), 0)) {
5458
0
      ret = error(_("invalid file: '%s'"), rebase_path_amend());
5459
0
      goto out;
5460
0
    }
5461
5462
0
    if (get_oid_hex(rev.buf, &to_amend)) {
5463
0
      ret = error(_("invalid contents: '%s'"),
5464
0
            rebase_path_amend());
5465
0
      goto out;
5466
0
    }
5467
0
    if (!is_clean && !oideq(&head, &to_amend)) {
5468
0
      ret = error(_("\nYou have uncommitted changes in your "
5469
0
              "working tree. Please, commit them\n"
5470
0
              "first and then run 'git rebase "
5471
0
              "--continue' again."));
5472
0
      goto out;
5473
0
    }
5474
    /*
5475
     * When skipping a failed fixup/squash, we need to edit the
5476
     * commit message, the current fixup list and count, and if it
5477
     * was the last fixup/squash in the chain, we need to clean up
5478
     * the commit message and if there was a squash, let the user
5479
     * edit it.
5480
     */
5481
0
    if (!is_clean || !ctx->current_fixup_count)
5482
0
      ; /* this is not the final fixup */
5483
0
    else if (!oideq(&head, &to_amend) ||
5484
0
       !file_exists(rebase_path_stopped_sha())) {
5485
      /* was a final fixup or squash done manually? */
5486
0
      if (!is_fixup(peek_command(todo_list, 0))) {
5487
0
        unlink(rebase_path_fixup_msg());
5488
0
        unlink(rebase_path_squash_msg());
5489
0
        unlink(rebase_path_current_fixups());
5490
0
        strbuf_reset(&ctx->current_fixups);
5491
0
        ctx->current_fixup_count = 0;
5492
0
      }
5493
0
    } else {
5494
      /* we are in a fixup/squash chain */
5495
0
      const char *p = ctx->current_fixups.buf;
5496
0
      int len = ctx->current_fixups.len;
5497
5498
0
      ctx->current_fixup_count--;
5499
0
      if (!len)
5500
0
        BUG("Incorrect current_fixups:\n%s", p);
5501
0
      while (len && p[len - 1] != '\n')
5502
0
        len--;
5503
      /* Remove trailing newline */
5504
0
      if (len)
5505
0
        len--;
5506
0
      strbuf_setlen(&ctx->current_fixups, len);
5507
0
      if (write_message(p, len, rebase_path_current_fixups(),
5508
0
            0) < 0) {
5509
0
        ret = error(_("could not write file: '%s'"),
5510
0
              rebase_path_current_fixups());
5511
0
        goto out;
5512
0
      }
5513
5514
      /*
5515
       * If a fixup/squash in a fixup/squash chain failed, the
5516
       * commit message is already correct, no need to commit
5517
       * it again.
5518
       *
5519
       * Only if it is the final command in the fixup/squash
5520
       * chain, and only if the chain is longer than a single
5521
       * fixup/squash command (which was just skipped), do we
5522
       * actually need to re-commit with a cleaned up commit
5523
       * message.
5524
       */
5525
0
      if (ctx->current_fixup_count > 0 &&
5526
0
          !is_fixup(peek_command(todo_list, 0))) {
5527
0
        final_fixup = 1;
5528
        /*
5529
         * If there was not a single "squash" in the
5530
         * chain, we only need to clean up the commit
5531
         * message, no need to bother the user with
5532
         * opening the commit message in the editor.
5533
         */
5534
0
        if (!seen_squash(ctx) &&
5535
0
            !seen_fixup_edit_msg(ctx))
5536
0
          flags = (flags & ~EDIT_MSG) | CLEANUP_MSG;
5537
0
      } else if (is_fixup(peek_command(todo_list, 0))) {
5538
        /*
5539
         * We need to update the squash message to skip
5540
         * the latest commit message.
5541
         */
5542
0
        struct commit *commit;
5543
0
        const char *msg;
5544
0
        const char *path = rebase_path_squash_msg();
5545
0
        const char *encoding = get_commit_output_encoding();
5546
5547
0
        if (parse_head(r, &commit)) {
5548
0
          ret = error(_("could not parse HEAD"));
5549
0
          goto out;
5550
0
        }
5551
5552
0
        p = repo_logmsg_reencode(r, commit, NULL, encoding);
5553
0
        if (!p)  {
5554
0
          ret = error(_("could not parse commit %s"),
5555
0
                oid_to_hex(&commit->object.oid));
5556
0
          goto unuse_commit_buffer;
5557
0
        }
5558
0
        find_commit_subject(p, &msg);
5559
0
        if (write_message(msg, strlen(msg), path, 0)) {
5560
0
          ret = error(_("could not write file: "
5561
0
                   "'%s'"), path);
5562
0
          goto unuse_commit_buffer;
5563
0
        }
5564
5565
0
        ret = 0;
5566
5567
0
      unuse_commit_buffer:
5568
0
        repo_unuse_commit_buffer(r, commit, p);
5569
0
        if (ret)
5570
0
          goto out;
5571
0
      }
5572
0
    }
5573
5574
0
    flags |= AMEND_MSG;
5575
0
  }
5576
5577
0
  if (is_clean) {
5578
0
    if (refs_ref_exists(get_main_ref_store(r),
5579
0
            "CHERRY_PICK_HEAD") &&
5580
0
        refs_delete_ref(get_main_ref_store(r), "",
5581
0
            "CHERRY_PICK_HEAD", NULL, REF_NO_DEREF)) {
5582
0
      ret = error(_("could not remove CHERRY_PICK_HEAD"));
5583
0
      goto out;
5584
0
    }
5585
5586
0
    if (unlink(git_path_merge_msg(r)) && errno != ENOENT) {
5587
0
      ret = error_errno(_("could not remove '%s'"),
5588
0
            git_path_merge_msg(r));
5589
0
      goto out;
5590
0
    }
5591
5592
0
    if (!final_fixup) {
5593
0
      ret = 0;
5594
0
      goto out;
5595
0
    }
5596
0
  }
5597
5598
0
  if (run_git_commit(final_fixup ? NULL : rebase_path_message(),
5599
0
         reflog_action, opts, flags)) {
5600
0
    ret = error(_("could not commit staged changes."));
5601
0
    goto out;
5602
0
  }
5603
5604
0
  unlink(rebase_path_amend());
5605
0
  unlink(git_path_merge_head(r));
5606
0
  refs_delete_ref(get_main_ref_store(r), "", "AUTO_MERGE",
5607
0
      NULL, REF_NO_DEREF);
5608
0
  if (final_fixup) {
5609
0
    unlink(rebase_path_fixup_msg());
5610
0
    unlink(rebase_path_squash_msg());
5611
0
  }
5612
0
  if (ctx->current_fixup_count > 0) {
5613
    /*
5614
     * Whether final fixup or not, we just cleaned up the commit
5615
     * message...
5616
     */
5617
0
    unlink(rebase_path_current_fixups());
5618
0
    strbuf_reset(&ctx->current_fixups);
5619
0
    ctx->current_fixup_count = 0;
5620
0
  }
5621
5622
0
  ret = 0;
5623
5624
0
out:
5625
0
  strbuf_release(&rev);
5626
0
  return ret;
5627
0
}
5628
5629
int sequencer_continue(struct repository *r, struct replay_opts *opts)
5630
0
{
5631
0
  struct todo_list todo_list = TODO_LIST_INIT;
5632
0
  int res;
5633
5634
0
  if (read_and_refresh_cache(r, opts))
5635
0
    return -1;
5636
5637
0
  if (read_populate_opts(opts))
5638
0
    return -1;
5639
0
  if (is_rebase_i(opts)) {
5640
0
    if ((res = read_populate_todo(r, &todo_list, opts)))
5641
0
      goto release_todo_list;
5642
5643
0
    if (file_exists(rebase_path_dropped())) {
5644
0
      if ((res = todo_list_check_against_backup(r, opts,
5645
0
                  &todo_list)))
5646
0
        goto release_todo_list;
5647
5648
0
      unlink(rebase_path_dropped());
5649
0
    }
5650
5651
0
    if (commit_staged_changes(r, opts, &todo_list)) {
5652
0
      res = -1;
5653
0
      goto release_todo_list;
5654
0
    }
5655
0
  } else if (!file_exists(get_todo_path(opts)))
5656
0
    return continue_single_pick(r, opts);
5657
0
  else if ((res = read_populate_todo(r, &todo_list, opts)))
5658
0
    goto release_todo_list;
5659
5660
0
  if (!is_rebase_i(opts)) {
5661
    /* Verify that the conflict has been resolved */
5662
0
    if (refs_ref_exists(get_main_ref_store(r),
5663
0
            "CHERRY_PICK_HEAD") ||
5664
0
        refs_ref_exists(get_main_ref_store(r), "REVERT_HEAD")) {
5665
0
      res = continue_single_pick(r, opts);
5666
0
      if (res)
5667
0
        goto release_todo_list;
5668
0
    }
5669
0
    if (index_differs_from(r, "HEAD", NULL, 0)) {
5670
0
      res = error_dirty_index(r, opts);
5671
0
      goto release_todo_list;
5672
0
    }
5673
0
    todo_list.current++;
5674
0
  } else if (file_exists(rebase_path_stopped_sha())) {
5675
0
    struct strbuf buf = STRBUF_INIT;
5676
0
    struct object_id oid;
5677
5678
0
    if (read_oneliner(&buf, rebase_path_stopped_sha(),
5679
0
          READ_ONELINER_SKIP_IF_EMPTY) &&
5680
0
        !get_oid_hex(buf.buf, &oid))
5681
0
      record_in_rewritten(&oid, peek_command(&todo_list, 0));
5682
0
    strbuf_release(&buf);
5683
0
  }
5684
5685
0
  res = pick_commits(r, &todo_list, opts);
5686
0
release_todo_list:
5687
0
  todo_list_release(&todo_list);
5688
0
  return res;
5689
0
}
5690
5691
static int single_pick(struct repository *r,
5692
           struct commit *cmit,
5693
           struct replay_opts *opts)
5694
0
{
5695
0
  int check_todo;
5696
0
  struct todo_item item;
5697
5698
0
  item.command = opts->action == REPLAY_PICK ?
5699
0
      TODO_PICK : TODO_REVERT;
5700
0
  item.commit = cmit;
5701
5702
0
  switch (do_pick_commit(r, &item, opts, 0, &check_todo)) {
5703
0
  case PICK_RESULT_ERROR:
5704
0
    return -1;
5705
0
  case PICK_RESULT_CONFLICTS:
5706
0
    return 1;
5707
0
  default:
5708
0
    return 0;
5709
0
  }
5710
5711
0
}
5712
5713
int sequencer_pick_revisions(struct repository *r,
5714
           struct replay_opts *opts)
5715
0
{
5716
0
  struct todo_list todo_list = TODO_LIST_INIT;
5717
0
  struct object_id oid;
5718
0
  int i, res;
5719
5720
0
  assert(opts->revs);
5721
0
  if (read_and_refresh_cache(r, opts)) {
5722
0
    res = -1;
5723
0
    goto out;
5724
0
  }
5725
5726
0
  for (i = 0; i < opts->revs->pending.nr; i++) {
5727
0
    struct object_id oid;
5728
0
    const char *name = opts->revs->pending.objects[i].name;
5729
5730
    /* This happens when using --stdin. */
5731
0
    if (!strlen(name))
5732
0
      continue;
5733
5734
0
    if (!repo_get_oid(r, name, &oid)) {
5735
0
      if (!lookup_commit_reference_gently(r, &oid, 1)) {
5736
0
        enum object_type type = odb_read_object_info(r->objects,
5737
0
                       &oid, NULL);
5738
0
        res = error(_("%s: can't cherry-pick a %s"),
5739
0
              name, type_name(type));
5740
0
        goto out;
5741
0
      }
5742
0
    } else {
5743
0
      res = error(_("%s: bad revision"), name);
5744
0
      goto out;
5745
0
    }
5746
0
  }
5747
5748
  /*
5749
   * If we were called as "git cherry-pick <commit>", just
5750
   * cherry-pick/revert it, set CHERRY_PICK_HEAD /
5751
   * REVERT_HEAD, and don't touch the sequencer state.
5752
   * This means it is possible to cherry-pick in the middle
5753
   * of a cherry-pick sequence.
5754
   */
5755
0
  if (opts->revs->cmdline.nr == 1 &&
5756
0
      opts->revs->cmdline.rev->whence == REV_CMD_REV &&
5757
0
      opts->revs->no_walk &&
5758
0
      !opts->revs->cmdline.rev->flags) {
5759
0
    struct commit *cmit;
5760
5761
0
    if (prepare_revision_walk(opts->revs)) {
5762
0
      res = error(_("revision walk setup failed"));
5763
0
      goto out;
5764
0
    }
5765
5766
0
    cmit = get_revision(opts->revs);
5767
0
    if (!cmit) {
5768
0
      res = error(_("empty commit set passed"));
5769
0
      goto out;
5770
0
    }
5771
5772
0
    if (get_revision(opts->revs))
5773
0
      BUG("unexpected extra commit from walk");
5774
5775
0
    res = single_pick(r, cmit, opts);
5776
0
    goto out;
5777
0
  }
5778
5779
  /*
5780
   * Start a new cherry-pick/ revert sequence; but
5781
   * first, make sure that an existing one isn't in
5782
   * progress
5783
   */
5784
5785
0
  if (walk_revs_populate_todo(&todo_list, opts) ||
5786
0
      create_seq_dir(r) < 0) {
5787
0
    res = -1;
5788
0
    goto out;
5789
0
  }
5790
5791
0
  if (repo_get_oid(r, "HEAD", &oid) && (opts->action == REPLAY_REVERT)) {
5792
0
    res = error(_("can't revert as initial commit"));
5793
0
    goto out;
5794
0
  }
5795
5796
0
  if (save_head(oid_to_hex(&oid))) {
5797
0
    res = -1;
5798
0
    goto out;
5799
0
  }
5800
5801
0
  if (save_opts(opts)) {
5802
0
    res = -1;
5803
0
    goto out;
5804
0
  }
5805
5806
0
  update_abort_safety_file();
5807
0
  res = pick_commits(r, &todo_list, opts);
5808
5809
0
out:
5810
0
  todo_list_release(&todo_list);
5811
0
  return res;
5812
0
}
5813
5814
void sequencer_format_revert_message(struct repository *r,
5815
             const char *subject,
5816
             const struct commit *commit,
5817
             const struct commit *parent,
5818
             bool use_commit_reference,
5819
             struct strbuf *message)
5820
0
{
5821
0
  const char *orig_subject;
5822
5823
0
  if (use_commit_reference) {
5824
0
    strbuf_commented_addf(message, comment_line_str,
5825
0
              "*** SAY WHY WE ARE REVERTING ON THE TITLE LINE ***");
5826
0
  } else if (skip_prefix(subject, "Revert \"", &orig_subject) &&
5827
       /*
5828
        * We don't touch pre-existing repeated reverts, because
5829
        * theoretically these can be nested arbitrarily deeply,
5830
        * thus requiring excessive complexity to deal with.
5831
        */
5832
0
       !starts_with(orig_subject, "Revert \"")) {
5833
0
    strbuf_addstr(message, "Reapply \"");
5834
0
    strbuf_addstr(message, orig_subject);
5835
0
    strbuf_addstr(message, "\n");
5836
0
  } else {
5837
0
    strbuf_addstr(message, "Revert \"");
5838
0
    strbuf_addstr(message, subject);
5839
0
    strbuf_addstr(message, "\"\n");
5840
0
  }
5841
0
  strbuf_addstr(message, "\nThis reverts commit ");
5842
0
  refer_to_commit(r, message, commit, use_commit_reference);
5843
5844
0
  if (commit->parents && commit->parents->next) {
5845
0
    strbuf_addstr(message, ", reversing\nchanges made to ");
5846
0
    refer_to_commit(r, message, parent, use_commit_reference);
5847
0
  }
5848
0
  strbuf_addstr(message, ".\n");
5849
0
}
5850
5851
void append_signoff(struct strbuf *msgbuf, size_t ignore_footer, unsigned flag)
5852
0
{
5853
0
  unsigned no_dup_sob = flag & APPEND_SIGNOFF_DEDUP;
5854
0
  struct strbuf sob = STRBUF_INIT;
5855
0
  int has_footer;
5856
5857
0
  strbuf_addstr(&sob, sign_off_header);
5858
0
  strbuf_addstr(&sob, fmt_name(WANT_COMMITTER_IDENT));
5859
0
  strbuf_addch(&sob, '\n');
5860
5861
0
  if (!ignore_footer)
5862
0
    strbuf_complete_line(msgbuf);
5863
5864
  /*
5865
   * If the whole message buffer is equal to the sob, pretend that we
5866
   * found a conforming footer with a matching sob
5867
   */
5868
0
  if (msgbuf->len - ignore_footer == sob.len &&
5869
0
      !strncmp(msgbuf->buf, sob.buf, sob.len))
5870
0
    has_footer = 3;
5871
0
  else
5872
0
    has_footer = has_conforming_footer(msgbuf, &sob, ignore_footer);
5873
5874
0
  if (!has_footer) {
5875
0
    const char *append_newlines = NULL;
5876
0
    size_t len = msgbuf->len - ignore_footer;
5877
5878
0
    if (!len) {
5879
      /*
5880
       * The buffer is completely empty.  Leave foom for
5881
       * the title and body to be filled in by the user.
5882
       */
5883
0
      append_newlines = "\n\n";
5884
0
    } else if (len == 1) {
5885
      /*
5886
       * Buffer contains a single newline.  Add another
5887
       * so that we leave room for the title and body.
5888
       */
5889
0
      append_newlines = "\n";
5890
0
    } else if (msgbuf->buf[len - 2] != '\n') {
5891
      /*
5892
       * Buffer ends with a single newline.  Add another
5893
       * so that there is an empty line between the message
5894
       * body and the sob.
5895
       */
5896
0
      append_newlines = "\n";
5897
0
    } /* else, the buffer already ends with two newlines. */
5898
5899
0
    if (append_newlines)
5900
0
      strbuf_splice(msgbuf, msgbuf->len - ignore_footer, 0,
5901
0
        append_newlines, strlen(append_newlines));
5902
0
  }
5903
5904
0
  if (has_footer != 3 && (!no_dup_sob || has_footer != 2))
5905
0
    strbuf_splice(msgbuf, msgbuf->len - ignore_footer, 0,
5906
0
        sob.buf, sob.len);
5907
5908
0
  strbuf_release(&sob);
5909
0
}
5910
5911
struct labels_entry {
5912
  struct hashmap_entry entry;
5913
  char label[FLEX_ARRAY];
5914
};
5915
5916
static int labels_cmp(const void *fndata UNUSED,
5917
          const struct hashmap_entry *eptr,
5918
          const struct hashmap_entry *entry_or_key, const void *key)
5919
0
{
5920
0
  const struct labels_entry *a, *b;
5921
5922
0
  a = container_of(eptr, const struct labels_entry, entry);
5923
0
  b = container_of(entry_or_key, const struct labels_entry, entry);
5924
5925
0
  return key ? strcmp(a->label, key) : strcmp(a->label, b->label);
5926
0
}
5927
5928
struct string_entry {
5929
  struct oidmap_entry entry;
5930
  char string[FLEX_ARRAY];
5931
};
5932
5933
struct label_state {
5934
  struct oidmap commit2label;
5935
  struct hashmap labels;
5936
  struct strbuf buf;
5937
  int max_label_length;
5938
};
5939
5940
static const char *label_oid(struct object_id *oid, const char *label,
5941
           struct label_state *state)
5942
0
{
5943
0
  struct labels_entry *labels_entry;
5944
0
  struct string_entry *string_entry;
5945
0
  struct object_id dummy;
5946
0
  int i;
5947
5948
0
  string_entry = oidmap_get(&state->commit2label, oid);
5949
0
  if (string_entry)
5950
0
    return string_entry->string;
5951
5952
  /*
5953
   * For "uninteresting" commits, i.e. commits that are not to be
5954
   * rebased, and which can therefore not be labeled, we use a unique
5955
   * abbreviation of the commit name. This is slightly more complicated
5956
   * than calling repo_find_unique_abbrev() because we also need to make
5957
   * sure that the abbreviation does not conflict with any other
5958
   * label.
5959
   *
5960
   * We disallow "interesting" commits to be labeled by a string that
5961
   * is a valid full-length hash, to ensure that we always can find an
5962
   * abbreviation for any uninteresting commit's names that does not
5963
   * clash with any other label.
5964
   */
5965
0
  strbuf_reset(&state->buf);
5966
0
  if (!label) {
5967
0
    char *p;
5968
5969
0
    strbuf_grow(&state->buf, GIT_MAX_HEXSZ);
5970
0
    label = p = state->buf.buf;
5971
5972
0
    repo_find_unique_abbrev_r(the_repository, p, oid,
5973
0
            default_abbrev);
5974
5975
    /*
5976
     * We may need to extend the abbreviated hash so that there is
5977
     * no conflicting label.
5978
     */
5979
0
    if (hashmap_get_from_hash(&state->labels, strihash(p), p)) {
5980
0
      size_t i = strlen(p) + 1;
5981
5982
0
      oid_to_hex_r(p, oid);
5983
0
      for (; i < the_hash_algo->hexsz; i++) {
5984
0
        char save = p[i];
5985
0
        p[i] = '\0';
5986
0
        if (!hashmap_get_from_hash(&state->labels,
5987
0
                 strihash(p), p))
5988
0
          break;
5989
0
        p[i] = save;
5990
0
      }
5991
0
    }
5992
0
  } else {
5993
0
    struct strbuf *buf = &state->buf;
5994
0
    int label_is_utf8 = 1; /* start with this assumption */
5995
0
    size_t max_len = buf->len + state->max_label_length;
5996
5997
    /*
5998
     * Sanitize labels by replacing non-alpha-numeric characters
5999
     * (including white-space ones) by dashes, as they might be
6000
     * illegal in file names (and hence in ref names).
6001
     *
6002
     * Note that we retain non-ASCII UTF-8 characters (identified
6003
     * via the most significant bit). They should be all acceptable
6004
     * in file names.
6005
     *
6006
     * As we will use the labels as names of (loose) refs, it is
6007
     * vital that the name not be longer than the maximum component
6008
     * size of the file system (`NAME_MAX`). We are careful to
6009
     * truncate the label accordingly, allowing for the `.lock`
6010
     * suffix and for the label to be UTF-8 encoded (i.e. we avoid
6011
     * truncating in the middle of a character).
6012
     */
6013
0
    for (; *label && buf->len + 1 < max_len; label++)
6014
0
      if (isalnum(*label) ||
6015
0
          (!label_is_utf8 && (*label & 0x80)))
6016
0
        strbuf_addch(buf, *label);
6017
0
      else if (*label & 0x80) {
6018
0
        const char *p = label;
6019
6020
0
        utf8_width(&p, NULL);
6021
0
        if (p) {
6022
0
          if (buf->len + (p - label) > max_len)
6023
0
            break;
6024
0
          strbuf_add(buf, label, p - label);
6025
0
          label = p - 1;
6026
0
        } else {
6027
0
          label_is_utf8 = 0;
6028
0
          strbuf_addch(buf, *label);
6029
0
        }
6030
      /* avoid leading dash and double-dashes */
6031
0
      } else if (buf->len && buf->buf[buf->len - 1] != '-')
6032
0
        strbuf_addch(buf, '-');
6033
0
    if (!buf->len) {
6034
0
      strbuf_addstr(buf, "rev-");
6035
0
      strbuf_add_unique_abbrev(buf, oid, default_abbrev);
6036
0
    }
6037
0
    label = buf->buf;
6038
6039
0
    if ((buf->len == the_hash_algo->hexsz &&
6040
0
         !get_oid_hex(label, &dummy)) ||
6041
0
        (buf->len == 1 && *label == '#') ||
6042
0
        hashmap_get_from_hash(&state->labels,
6043
0
            strihash(label), label)) {
6044
      /*
6045
       * If the label already exists, or if the label is a
6046
       * valid full OID, or the label is a '#' (which we use
6047
       * as a separator between merge heads and oneline), we
6048
       * append a dash and a number to make it unique.
6049
       */
6050
0
      size_t len = buf->len;
6051
6052
0
      for (i = 2; ; i++) {
6053
0
        strbuf_setlen(buf, len);
6054
0
        strbuf_addf(buf, "-%d", i);
6055
0
        if (!hashmap_get_from_hash(&state->labels,
6056
0
                 strihash(buf->buf),
6057
0
                 buf->buf))
6058
0
          break;
6059
0
      }
6060
6061
0
      label = buf->buf;
6062
0
    }
6063
0
  }
6064
6065
0
  FLEX_ALLOC_STR(labels_entry, label, label);
6066
0
  hashmap_entry_init(&labels_entry->entry, strihash(label));
6067
0
  hashmap_add(&state->labels, &labels_entry->entry);
6068
6069
0
  FLEX_ALLOC_STR(string_entry, string, label);
6070
0
  oidcpy(&string_entry->entry.oid, oid);
6071
0
  oidmap_put(&state->commit2label, string_entry);
6072
6073
0
  return string_entry->string;
6074
0
}
6075
6076
static int make_script_with_merges(struct pretty_print_context *pp,
6077
           struct rev_info *revs, struct strbuf *out,
6078
           unsigned flags)
6079
0
{
6080
0
  int keep_empty = flags & TODO_LIST_KEEP_EMPTY;
6081
0
  int rebase_cousins = flags & TODO_LIST_REBASE_COUSINS;
6082
0
  int root_with_onto = flags & TODO_LIST_ROOT_WITH_ONTO;
6083
0
  int skipped_commit = 0;
6084
0
  struct strbuf buf = STRBUF_INIT, oneline = STRBUF_INIT;
6085
0
  struct strbuf label_from_message = STRBUF_INIT;
6086
0
  struct commit_list *commits = NULL, **tail = &commits, *iter;
6087
0
  struct commit_list *tips = NULL, **tips_tail = &tips;
6088
0
  struct commit *commit;
6089
0
  struct oidmap commit2todo = OIDMAP_INIT;
6090
0
  struct string_entry *entry;
6091
0
  struct oidset interesting = OIDSET_INIT, child_seen = OIDSET_INIT,
6092
0
    shown = OIDSET_INIT;
6093
0
  struct label_state state =
6094
0
    { OIDMAP_INIT, { NULL }, STRBUF_INIT, GIT_MAX_LABEL_LENGTH };
6095
6096
0
  int abbr = flags & TODO_LIST_ABBREVIATE_CMDS;
6097
0
  const char *cmd_pick = abbr ? "p" : "pick",
6098
0
    *cmd_label = abbr ? "l" : "label",
6099
0
    *cmd_reset = abbr ? "t" : "reset",
6100
0
    *cmd_merge = abbr ? "m" : "merge";
6101
6102
0
  repo_config_get_int(the_repository, "rebase.maxlabellength", &state.max_label_length);
6103
6104
0
  oidmap_init(&commit2todo, 0);
6105
0
  oidmap_init(&state.commit2label, 0);
6106
0
  hashmap_init(&state.labels, labels_cmp, NULL, 0);
6107
0
  strbuf_init(&state.buf, 32);
6108
0
  load_branch_decorations();
6109
6110
0
  if (revs->cmdline.nr && (revs->cmdline.rev[0].flags & BOTTOM)) {
6111
0
    struct labels_entry *onto_label_entry;
6112
0
    struct object_id *oid = &revs->cmdline.rev[0].item->oid;
6113
0
    FLEX_ALLOC_STR(entry, string, "onto");
6114
0
    oidcpy(&entry->entry.oid, oid);
6115
0
    oidmap_put(&state.commit2label, entry);
6116
6117
0
    FLEX_ALLOC_STR(onto_label_entry, label, "onto");
6118
0
    hashmap_entry_init(&onto_label_entry->entry, strihash("onto"));
6119
0
    hashmap_add(&state.labels, &onto_label_entry->entry);
6120
0
  }
6121
6122
  /*
6123
   * First phase:
6124
   * - get onelines for all commits
6125
   * - gather all branch tips (i.e. 2nd or later parents of merges)
6126
   * - label all branch tips
6127
   */
6128
0
  while ((commit = get_revision(revs))) {
6129
0
    struct commit_list *to_merge;
6130
0
    const char *p1, *p2;
6131
0
    struct object_id *oid;
6132
0
    int is_empty;
6133
6134
0
    tail = &commit_list_insert(commit, tail)->next;
6135
0
    oidset_insert(&interesting, &commit->object.oid);
6136
6137
0
    is_empty = is_original_commit_empty(commit);
6138
0
    if (!is_empty && (commit->object.flags & PATCHSAME)) {
6139
0
      if (flags & TODO_LIST_WARN_SKIPPED_CHERRY_PICKS)
6140
0
        warning(_("skipped previously applied commit %s"),
6141
0
          short_commit_name(the_repository, commit));
6142
0
      skipped_commit = 1;
6143
0
      continue;
6144
0
    }
6145
0
    if (is_empty && !keep_empty)
6146
0
      continue;
6147
6148
0
    strbuf_reset(&oneline);
6149
0
    pretty_print_commit(pp, commit, &oneline);
6150
6151
0
    to_merge = commit->parents ? commit->parents->next : NULL;
6152
0
    if (!to_merge) {
6153
      /* non-merge commit: easy case */
6154
0
      strbuf_reset(&buf);
6155
0
      strbuf_addf(&buf, "%s %s %s", cmd_pick,
6156
0
            oid_to_hex(&commit->object.oid),
6157
0
            oneline.buf);
6158
0
      if (is_empty)
6159
0
        strbuf_addf(&buf, " %s empty",
6160
0
              comment_line_str);
6161
6162
0
      FLEX_ALLOC_STR(entry, string, buf.buf);
6163
0
      oidcpy(&entry->entry.oid, &commit->object.oid);
6164
0
      oidmap_put(&commit2todo, entry);
6165
6166
0
      continue;
6167
0
    }
6168
6169
    /* Create a label from the commit message */
6170
0
    strbuf_reset(&label_from_message);
6171
0
    if (skip_prefix(oneline.buf, "# Merge ", &p1) &&
6172
0
        (p1 = strchr(p1, '\'')) &&
6173
0
        (p2 = strchr(++p1, '\'')))
6174
0
      strbuf_add(&label_from_message, p1, p2 - p1);
6175
0
    else if (skip_prefix(oneline.buf, "# Merge pull request ",
6176
0
             &p1) &&
6177
0
       (p1 = strstr(p1, " from ")))
6178
0
      strbuf_addstr(&label_from_message, p1 + strlen(" from "));
6179
0
    else
6180
0
      strbuf_addbuf(&label_from_message, &oneline);
6181
6182
0
    strbuf_reset(&buf);
6183
0
    strbuf_addf(&buf, "%s -C %s",
6184
0
          cmd_merge, oid_to_hex(&commit->object.oid));
6185
6186
    /* label the tips of merged branches */
6187
0
    for (; to_merge; to_merge = to_merge->next) {
6188
0
      const char *label = label_from_message.buf;
6189
0
      const struct name_decoration *decoration =
6190
0
        get_name_decoration(&to_merge->item->object);
6191
6192
0
      if (decoration)
6193
0
        skip_prefix(decoration->name, "refs/heads/",
6194
0
              &label);
6195
6196
0
      oid = &to_merge->item->object.oid;
6197
0
      strbuf_addch(&buf, ' ');
6198
6199
0
      if (!oidset_contains(&interesting, oid)) {
6200
0
        strbuf_addstr(&buf, label_oid(oid, NULL,
6201
0
                    &state));
6202
0
        continue;
6203
0
      }
6204
6205
0
      tips_tail = &commit_list_insert(to_merge->item,
6206
0
              tips_tail)->next;
6207
6208
0
      strbuf_addstr(&buf, label_oid(oid, label, &state));
6209
0
    }
6210
0
    strbuf_addf(&buf, " %s", oneline.buf);
6211
6212
0
    FLEX_ALLOC_STR(entry, string, buf.buf);
6213
0
    oidcpy(&entry->entry.oid, &commit->object.oid);
6214
0
    oidmap_put(&commit2todo, entry);
6215
0
  }
6216
0
  if (skipped_commit)
6217
0
    advise_if_enabled(ADVICE_SKIPPED_CHERRY_PICKS,
6218
0
          _("use --reapply-cherry-picks to include skipped commits"));
6219
6220
  /*
6221
   * Second phase:
6222
   * - label branch points
6223
   * - add HEAD to the branch tips
6224
   */
6225
0
  for (iter = commits; iter; iter = iter->next) {
6226
0
    struct commit_list *parent = iter->item->parents;
6227
0
    for (; parent; parent = parent->next) {
6228
0
      struct object_id *oid = &parent->item->object.oid;
6229
0
      if (!oidset_contains(&interesting, oid))
6230
0
        continue;
6231
0
      if (oidset_insert(&child_seen, oid))
6232
0
        label_oid(oid, "branch-point", &state);
6233
0
    }
6234
6235
    /* Add HEAD as implicit "tip of branch" */
6236
0
    if (!iter->next)
6237
0
      tips_tail = &commit_list_insert(iter->item,
6238
0
              tips_tail)->next;
6239
0
  }
6240
6241
  /*
6242
   * Third phase: output the todo list. This is a bit tricky, as we
6243
   * want to avoid jumping back and forth between revisions. To
6244
   * accomplish that goal, we walk backwards from the branch tips,
6245
   * gathering commits not yet shown, reversing the list on the fly,
6246
   * then outputting that list (labeling revisions as needed).
6247
   */
6248
0
  strbuf_addf(out, "%s onto\n", cmd_label);
6249
0
  for (iter = tips; iter; iter = iter->next) {
6250
0
    struct commit_list *list = NULL, *iter2;
6251
6252
0
    commit = iter->item;
6253
0
    if (oidset_contains(&shown, &commit->object.oid))
6254
0
      continue;
6255
0
    entry = oidmap_get(&state.commit2label, &commit->object.oid);
6256
6257
0
    if (entry)
6258
0
      strbuf_addf(out, "\n%s Branch %s\n", comment_line_str, entry->string);
6259
0
    else
6260
0
      strbuf_addch(out, '\n');
6261
6262
0
    while (oidset_contains(&interesting, &commit->object.oid) &&
6263
0
           !oidset_contains(&shown, &commit->object.oid)) {
6264
0
      commit_list_insert(commit, &list);
6265
0
      if (!commit->parents) {
6266
0
        commit = NULL;
6267
0
        break;
6268
0
      }
6269
0
      commit = commit->parents->item;
6270
0
    }
6271
6272
0
    if (!commit)
6273
0
      strbuf_addf(out, "%s %s\n", cmd_reset,
6274
0
            rebase_cousins || root_with_onto ?
6275
0
            "onto" : "[new root]");
6276
0
    else {
6277
0
      const char *to = NULL;
6278
6279
0
      entry = oidmap_get(&state.commit2label,
6280
0
             &commit->object.oid);
6281
0
      if (entry)
6282
0
        to = entry->string;
6283
0
      else if (!rebase_cousins)
6284
0
        to = label_oid(&commit->object.oid, NULL,
6285
0
                 &state);
6286
6287
0
      if (!to || !strcmp(to, "onto"))
6288
0
        strbuf_addf(out, "%s onto\n", cmd_reset);
6289
0
      else {
6290
0
        strbuf_reset(&oneline);
6291
0
        pretty_print_commit(pp, commit, &oneline);
6292
0
        strbuf_addf(out, "%s %s %s\n",
6293
0
              cmd_reset, to, oneline.buf);
6294
0
      }
6295
0
    }
6296
6297
0
    for (iter2 = list; iter2; iter2 = iter2->next) {
6298
0
      struct object_id *oid = &iter2->item->object.oid;
6299
0
      entry = oidmap_get(&commit2todo, oid);
6300
      /* only show if not already upstream */
6301
0
      if (entry)
6302
0
        strbuf_addf(out, "%s\n", entry->string);
6303
0
      entry = oidmap_get(&state.commit2label, oid);
6304
0
      if (entry)
6305
0
        strbuf_addf(out, "%s %s\n",
6306
0
              cmd_label, entry->string);
6307
0
      oidset_insert(&shown, oid);
6308
0
    }
6309
6310
0
    commit_list_free(list);
6311
0
  }
6312
6313
0
  commit_list_free(commits);
6314
0
  commit_list_free(tips);
6315
6316
0
  strbuf_release(&label_from_message);
6317
0
  strbuf_release(&oneline);
6318
0
  strbuf_release(&buf);
6319
6320
0
  oidset_clear(&interesting);
6321
0
  oidset_clear(&child_seen);
6322
0
  oidset_clear(&shown);
6323
0
  oidmap_clear(&commit2todo, 1);
6324
0
  oidmap_clear(&state.commit2label, 1);
6325
0
  hashmap_clear_and_free(&state.labels, struct labels_entry, entry);
6326
0
  strbuf_release(&state.buf);
6327
6328
0
  return 0;
6329
0
}
6330
6331
int sequencer_make_script(struct repository *r, struct strbuf *out,
6332
        struct strvec *argv, unsigned flags)
6333
0
{
6334
0
  char *format = NULL;
6335
0
  struct pretty_print_context pp = {0};
6336
0
  struct rev_info revs;
6337
0
  struct commit *commit;
6338
0
  int keep_empty = flags & TODO_LIST_KEEP_EMPTY;
6339
0
  const char *insn = flags & TODO_LIST_ABBREVIATE_CMDS ? "p" : "pick";
6340
0
  int rebase_merges = flags & TODO_LIST_REBASE_MERGES;
6341
0
  int reapply_cherry_picks = flags & TODO_LIST_REAPPLY_CHERRY_PICKS;
6342
0
  int skipped_commit = 0;
6343
0
  int ret = 0;
6344
6345
0
  repo_init_revisions(r, &revs, NULL);
6346
0
  revs.verbose_header = 1;
6347
0
  if (!rebase_merges)
6348
0
    revs.max_parents = 1;
6349
0
  revs.cherry_mark = !reapply_cherry_picks;
6350
0
  revs.limited = 1;
6351
0
  revs.reverse = 1;
6352
0
  revs.right_only = 1;
6353
0
  revs.sort_order = REV_SORT_IN_GRAPH_ORDER;
6354
0
  revs.topo_order = 1;
6355
6356
0
  repo_config_get_string(the_repository, "rebase.instructionFormat", &format);
6357
0
  if (!format || !*format) {
6358
0
    free(format);
6359
0
    format = xstrdup("# %s");
6360
0
  }
6361
0
  if (*format != '#') {
6362
0
    char *temp = format;
6363
0
    format = xstrfmt("# %s", temp);
6364
0
    free(temp);
6365
0
  }
6366
6367
0
  get_commit_format(format, &revs);
6368
0
  free(format);
6369
0
  pp.fmt = revs.commit_format;
6370
0
  pp.output_encoding = get_log_output_encoding();
6371
6372
0
  setup_revisions_from_strvec(argv, &revs, NULL);
6373
0
  if (argv->nr > 1) {
6374
0
    ret = error(_("make_script: unhandled options"));
6375
0
    goto cleanup;
6376
0
  }
6377
6378
0
  if (prepare_revision_walk(&revs) < 0) {
6379
0
    ret = error(_("make_script: error preparing revisions"));
6380
0
    goto cleanup;
6381
0
  }
6382
6383
0
  if (rebase_merges) {
6384
0
    ret = make_script_with_merges(&pp, &revs, out, flags);
6385
0
    goto cleanup;
6386
0
  }
6387
6388
0
  while ((commit = get_revision(&revs))) {
6389
0
    int is_empty = is_original_commit_empty(commit);
6390
6391
0
    if (!is_empty && (commit->object.flags & PATCHSAME)) {
6392
0
      if (flags & TODO_LIST_WARN_SKIPPED_CHERRY_PICKS)
6393
0
        warning(_("skipped previously applied commit %s"),
6394
0
          short_commit_name(r, commit));
6395
0
      skipped_commit = 1;
6396
0
      continue;
6397
0
    }
6398
0
    if (is_empty && !keep_empty)
6399
0
      continue;
6400
0
    strbuf_addf(out, "%s %s ", insn,
6401
0
          oid_to_hex(&commit->object.oid));
6402
0
    pretty_print_commit(&pp, commit, out);
6403
0
    if (is_empty)
6404
0
      strbuf_addf(out, " %s empty", comment_line_str);
6405
0
    strbuf_addch(out, '\n');
6406
0
  }
6407
0
  if (skipped_commit)
6408
0
    advise_if_enabled(ADVICE_SKIPPED_CHERRY_PICKS,
6409
0
          _("use --reapply-cherry-picks to include skipped commits"));
6410
0
cleanup:
6411
0
  release_revisions(&revs);
6412
0
  return ret;
6413
0
}
6414
6415
/*
6416
 * Add commands after pick and (series of) squash/fixup commands
6417
 * in the todo list.
6418
 */
6419
static void todo_list_add_exec_commands(struct todo_list *todo_list,
6420
          struct string_list *commands)
6421
0
{
6422
0
  struct strbuf *buf = &todo_list->buf;
6423
0
  size_t base_offset = buf->len;
6424
0
  int i, insert, nr = 0, alloc = 0;
6425
0
  struct todo_item *items = NULL, *base_items = NULL;
6426
6427
0
  CALLOC_ARRAY(base_items, commands->nr);
6428
0
  for (i = 0; i < commands->nr; i++) {
6429
0
    size_t command_len = strlen(commands->items[i].string);
6430
6431
0
    strbuf_addstr(buf, commands->items[i].string);
6432
0
    strbuf_addch(buf, '\n');
6433
6434
0
    base_items[i].command = TODO_EXEC;
6435
0
    base_items[i].offset_in_buf = base_offset;
6436
0
    base_items[i].arg_offset = base_offset;
6437
0
    base_items[i].arg_len = command_len;
6438
6439
0
    base_offset += command_len + 1;
6440
0
  }
6441
6442
  /*
6443
   * Insert <commands> after every pick. Here, fixup/squash chains
6444
   * are considered part of the pick, so we insert the commands *after*
6445
   * those chains if there are any.
6446
   *
6447
   * As we insert the exec commands immediately after rearranging
6448
   * any fixups and before the user edits the list, a fixup chain
6449
   * can never contain comments (any comments are empty picks that
6450
   * have been commented out because the user did not specify
6451
   * --keep-empty).  So, it is safe to insert an exec command
6452
   * without looking at the command following a comment.
6453
   */
6454
0
  insert = 0;
6455
0
  for (i = 0; i < todo_list->nr; i++) {
6456
0
    enum todo_command command = todo_list->items[i].command;
6457
0
    if (insert && !is_fixup(command)) {
6458
0
      ALLOC_GROW(items, nr + commands->nr, alloc);
6459
0
      COPY_ARRAY(items + nr, base_items, commands->nr);
6460
0
      nr += commands->nr;
6461
6462
0
      insert = 0;
6463
0
    }
6464
6465
0
    ALLOC_GROW(items, nr + 1, alloc);
6466
0
    items[nr++] = todo_list->items[i];
6467
6468
0
    if (command == TODO_PICK || command == TODO_MERGE)
6469
0
      insert = 1;
6470
0
  }
6471
6472
  /* insert or append final <commands> */
6473
0
  if (insert) {
6474
0
    ALLOC_GROW(items, nr + commands->nr, alloc);
6475
0
    COPY_ARRAY(items + nr, base_items, commands->nr);
6476
0
    nr += commands->nr;
6477
0
  }
6478
6479
0
  free(base_items);
6480
0
  FREE_AND_NULL(todo_list->items);
6481
0
  todo_list->items = items;
6482
0
  todo_list->nr = nr;
6483
0
  todo_list->alloc = alloc;
6484
0
}
6485
6486
static void todo_list_to_strbuf(struct repository *r,
6487
        struct todo_list *todo_list,
6488
        struct strbuf *buf, int num, unsigned flags)
6489
0
{
6490
0
  struct todo_item *item;
6491
0
  int i, max = todo_list->nr;
6492
6493
0
  if (num > 0 && num < max)
6494
0
    max = num;
6495
6496
0
  for (item = todo_list->items, i = 0; i < max; i++, item++) {
6497
0
    char cmd;
6498
6499
    /* if the item is not a command write it and continue */
6500
0
    if (item->command >= TODO_COMMENT) {
6501
0
      strbuf_addf(buf, "%.*s\n", item->arg_len,
6502
0
            todo_item_get_arg(todo_list, item));
6503
0
      continue;
6504
0
    }
6505
6506
    /* add command to the buffer */
6507
0
    cmd = command_to_char(item->command);
6508
0
    if ((flags & TODO_LIST_ABBREVIATE_CMDS) && cmd)
6509
0
      strbuf_addch(buf, cmd);
6510
0
    else
6511
0
      strbuf_addstr(buf, command_to_string(item->command));
6512
6513
    /* add commit id */
6514
0
    if (item->commit) {
6515
0
      const char *oid = flags & TODO_LIST_SHORTEN_IDS ?
6516
0
            short_commit_name(r, item->commit) :
6517
0
            oid_to_hex(&item->commit->object.oid);
6518
6519
0
      if (item->command == TODO_FIXUP) {
6520
0
        if (item->flags & TODO_EDIT_FIXUP_MSG)
6521
0
          strbuf_addstr(buf, " -c");
6522
0
        else if (item->flags & TODO_REPLACE_FIXUP_MSG) {
6523
0
          strbuf_addstr(buf, " -C");
6524
0
        }
6525
0
      }
6526
6527
0
      if (item->command == TODO_MERGE) {
6528
0
        if (item->flags & TODO_EDIT_MERGE_MSG)
6529
0
          strbuf_addstr(buf, " -c");
6530
0
        else
6531
0
          strbuf_addstr(buf, " -C");
6532
0
      }
6533
6534
0
      strbuf_addf(buf, " %s", oid);
6535
0
    }
6536
6537
    /* add all the rest */
6538
0
    if (!item->arg_len)
6539
0
      strbuf_addch(buf, '\n');
6540
0
    else
6541
0
      strbuf_addf(buf, " %.*s\n", item->arg_len,
6542
0
            todo_item_get_arg(todo_list, item));
6543
0
  }
6544
0
}
6545
6546
int todo_list_write_to_file(struct repository *r, struct todo_list *todo_list,
6547
          const char *file, const char *shortrevisions,
6548
          const char *shortonto, int num, unsigned flags)
6549
0
{
6550
0
  int res;
6551
0
  struct strbuf buf = STRBUF_INIT;
6552
6553
0
  todo_list_to_strbuf(r, todo_list, &buf, num, flags);
6554
0
  if (flags & TODO_LIST_APPEND_TODO_HELP)
6555
0
    append_todo_help(count_commands(todo_list),
6556
0
         shortrevisions, shortonto, &buf);
6557
6558
0
  res = write_message(buf.buf, buf.len, file, 0);
6559
0
  strbuf_release(&buf);
6560
6561
0
  return res;
6562
0
}
6563
6564
/* skip picking commits whose parents are unchanged */
6565
static int skip_unnecessary_picks(struct repository *r,
6566
          struct todo_list *todo_list,
6567
          struct object_id *base_oid)
6568
0
{
6569
0
  struct object_id *parent_oid;
6570
0
  int i;
6571
6572
0
  for (i = 0; i < todo_list->nr; i++) {
6573
0
    struct todo_item *item = todo_list->items + i;
6574
6575
0
    if (item->command >= TODO_NOOP)
6576
0
      continue;
6577
0
    if (item->command != TODO_PICK)
6578
0
      break;
6579
0
    if (repo_parse_commit(r, item->commit)) {
6580
0
      return error(_("could not parse commit '%s'"),
6581
0
        oid_to_hex(&item->commit->object.oid));
6582
0
    }
6583
0
    if (!item->commit->parents)
6584
0
      break; /* root commit */
6585
0
    if (item->commit->parents->next)
6586
0
      break; /* merge commit */
6587
0
    parent_oid = &item->commit->parents->item->object.oid;
6588
0
    if (!oideq(parent_oid, base_oid))
6589
0
      break;
6590
0
    oidcpy(base_oid, &item->commit->object.oid);
6591
0
  }
6592
0
  if (i > 0) {
6593
0
    const char *done_path = rebase_path_done();
6594
6595
0
    if (todo_list_write_to_file(r, todo_list, done_path, NULL, NULL, i, 0)) {
6596
0
      error_errno(_("could not write to '%s'"), done_path);
6597
0
      return -1;
6598
0
    }
6599
6600
0
    MOVE_ARRAY(todo_list->items, todo_list->items + i, todo_list->nr - i);
6601
0
    todo_list->nr -= i;
6602
0
    todo_list->current = 0;
6603
0
    todo_list->done_nr += i;
6604
6605
0
    if (is_fixup(peek_command(todo_list, 0)))
6606
0
      record_in_rewritten(base_oid, peek_command(todo_list, 0));
6607
0
  }
6608
6609
0
  return 0;
6610
0
}
6611
6612
struct todo_add_branch_context {
6613
  struct todo_item *items;
6614
  size_t items_nr;
6615
  size_t items_alloc;
6616
  struct strbuf *buf;
6617
  struct string_list refs_to_oids;
6618
};
6619
6620
static int add_decorations_to_list(const struct commit *commit,
6621
           struct todo_add_branch_context *ctx)
6622
0
{
6623
0
  const struct name_decoration *decoration = get_name_decoration(&commit->object);
6624
0
  char *head_ref = refs_resolve_refdup(get_main_ref_store(the_repository),
6625
0
               "HEAD",
6626
0
               RESOLVE_REF_READING,
6627
0
               NULL,
6628
0
               NULL);
6629
6630
0
  while (decoration) {
6631
0
    struct todo_item *item;
6632
0
    const char *path;
6633
0
    size_t base_offset = ctx->buf->len;
6634
6635
    /*
6636
     * If the branch is the current HEAD, then it will be
6637
     * updated by the default rebase behavior.
6638
     * Exclude it from the list of refs to update,
6639
     * as well as any non-branch decorations.
6640
     * Non-branch decorations may be present if the pretty format
6641
     * includes "%d", which would have loaded all refs
6642
     * into the global decoration table.
6643
     */
6644
0
    if ((head_ref && !strcmp(head_ref, decoration->name)) ||
6645
0
        (decoration->type != DECORATION_REF_LOCAL)) {
6646
0
      decoration = decoration->next;
6647
0
      continue;
6648
0
    }
6649
6650
0
    ALLOC_GROW(ctx->items,
6651
0
      ctx->items_nr + 1,
6652
0
      ctx->items_alloc);
6653
0
    item = &ctx->items[ctx->items_nr];
6654
0
    memset(item, 0, sizeof(*item));
6655
6656
    /* If the branch is checked out, then leave a comment instead. */
6657
0
    if ((path = branch_checked_out(decoration->name))) {
6658
0
      item->command = TODO_COMMENT;
6659
0
      strbuf_commented_addf(ctx->buf, comment_line_str,
6660
0
                "Ref %s checked out at '%s'\n",
6661
0
                decoration->name, path);
6662
0
    } else {
6663
0
      struct string_list_item *sti;
6664
0
      item->command = TODO_UPDATE_REF;
6665
0
      strbuf_addf(ctx->buf, "%s\n", decoration->name);
6666
6667
0
      sti = string_list_insert(&ctx->refs_to_oids,
6668
0
             decoration->name);
6669
0
      sti->util = init_update_ref_record(decoration->name);
6670
0
    }
6671
6672
0
    item->offset_in_buf = base_offset;
6673
0
    item->arg_offset = base_offset;
6674
0
    item->arg_len = ctx->buf->len - base_offset;
6675
0
    ctx->items_nr++;
6676
6677
0
    decoration = decoration->next;
6678
0
  }
6679
6680
0
  free(head_ref);
6681
0
  return 0;
6682
0
}
6683
6684
/*
6685
 * For each 'pick' command, find out if the commit has a decoration in
6686
 * refs/heads/. If so, then add a 'label for-update-refs/' command.
6687
 */
6688
static int todo_list_add_update_ref_commands(struct todo_list *todo_list)
6689
0
{
6690
0
  int i, res;
6691
0
  struct todo_add_branch_context ctx = {
6692
0
    .buf = &todo_list->buf,
6693
0
    .refs_to_oids = STRING_LIST_INIT_DUP,
6694
0
  };
6695
6696
0
  ctx.items_alloc = 2 * todo_list->nr + 1;
6697
0
  ALLOC_ARRAY(ctx.items, ctx.items_alloc);
6698
6699
0
  load_branch_decorations();
6700
6701
0
  for (i = 0; i < todo_list->nr; ) {
6702
0
    struct todo_item *item = &todo_list->items[i];
6703
6704
    /* insert ith item into new list */
6705
0
    ALLOC_GROW(ctx.items,
6706
0
         ctx.items_nr + 1,
6707
0
         ctx.items_alloc);
6708
6709
0
    ctx.items[ctx.items_nr++] = todo_list->items[i++];
6710
6711
0
    if (item->commit) {
6712
0
      add_decorations_to_list(item->commit, &ctx);
6713
0
    }
6714
0
  }
6715
6716
0
  res = write_update_refs_state(&ctx.refs_to_oids);
6717
6718
0
  string_list_clear(&ctx.refs_to_oids, 1);
6719
6720
0
  if (res) {
6721
    /* we failed, so clean up the new list. */
6722
0
    free(ctx.items);
6723
0
    return res;
6724
0
  }
6725
6726
0
  free(todo_list->items);
6727
0
  todo_list->items = ctx.items;
6728
0
  todo_list->nr = ctx.items_nr;
6729
0
  todo_list->alloc = ctx.items_alloc;
6730
6731
0
  return 0;
6732
0
}
6733
6734
int complete_action(struct repository *r, struct replay_opts *opts, unsigned flags,
6735
        const char *shortrevisions, const char *onto_name,
6736
        struct commit *onto, const struct object_id *orig_head,
6737
        struct string_list *commands, unsigned autosquash,
6738
        unsigned update_refs,
6739
        struct todo_list *todo_list)
6740
0
{
6741
0
  char shortonto[GIT_MAX_HEXSZ + 1];
6742
0
  const char *todo_file = rebase_path_todo();
6743
0
  struct todo_list new_todo = TODO_LIST_INIT;
6744
0
  struct strbuf *buf = &todo_list->buf, buf2 = STRBUF_INIT;
6745
0
  struct object_id oid = onto->object.oid;
6746
0
  int res;
6747
6748
0
  repo_find_unique_abbrev_r(r, shortonto, &oid,
6749
0
          DEFAULT_ABBREV);
6750
6751
0
  if (buf->len == 0) {
6752
0
    struct todo_item *item = append_new_todo(todo_list);
6753
0
    item->command = TODO_NOOP;
6754
0
    item->commit = NULL;
6755
0
    item->arg_len = item->arg_offset = item->flags = item->offset_in_buf = 0;
6756
0
  }
6757
6758
0
  if (update_refs && todo_list_add_update_ref_commands(todo_list))
6759
0
    return -1;
6760
6761
0
  if (autosquash && todo_list_rearrange_squash(todo_list))
6762
0
    return -1;
6763
6764
0
  if (commands->nr)
6765
0
    todo_list_add_exec_commands(todo_list, commands);
6766
6767
0
  if (count_commands(todo_list) == 0) {
6768
0
    apply_autostash(rebase_path_autostash());
6769
0
    sequencer_remove_state(opts);
6770
6771
0
    return error(_("nothing to do"));
6772
0
  }
6773
6774
0
  res = edit_todo_list(r, opts, todo_list, &new_todo, shortrevisions,
6775
0
           shortonto, flags);
6776
0
  if (res == -1)
6777
0
    return -1;
6778
0
  else if (res == -2) {
6779
0
    apply_autostash(rebase_path_autostash());
6780
0
    sequencer_remove_state(opts);
6781
6782
0
    return -1;
6783
0
  } else if (res == -3) {
6784
0
    apply_autostash(rebase_path_autostash());
6785
0
    sequencer_remove_state(opts);
6786
0
    todo_list_release(&new_todo);
6787
6788
0
    return error(_("nothing to do"));
6789
0
  } else if (res == -4) {
6790
0
    checkout_onto(r, opts, onto_name, &onto->object.oid, orig_head);
6791
0
    todo_list_release(&new_todo);
6792
6793
0
    return -1;
6794
0
  }
6795
6796
  /* Expand the commit IDs */
6797
0
  todo_list_to_strbuf(r, &new_todo, &buf2, -1, 0);
6798
0
  strbuf_swap(&new_todo.buf, &buf2);
6799
0
  strbuf_release(&buf2);
6800
  /* Nothing is done yet, and we're reparsing, so let's reset the count */
6801
0
  new_todo.total_nr = 0;
6802
0
  if (todo_list_parse_insn_buffer(r, opts, new_todo.buf.buf, &new_todo) < 0)
6803
0
    BUG("invalid todo list after expanding IDs:\n%s",
6804
0
        new_todo.buf.buf);
6805
6806
0
  if (opts->allow_ff && skip_unnecessary_picks(r, &new_todo, &oid)) {
6807
0
    todo_list_release(&new_todo);
6808
0
    return error(_("could not skip unnecessary pick commands"));
6809
0
  }
6810
6811
0
  if (todo_list_write_to_file(r, &new_todo, todo_file, NULL, NULL, -1,
6812
0
            flags & ~(TODO_LIST_SHORTEN_IDS))) {
6813
0
    todo_list_release(&new_todo);
6814
0
    return error_errno(_("could not write '%s'"), todo_file);
6815
0
  }
6816
6817
0
  res = -1;
6818
6819
0
  if (checkout_onto(r, opts, onto_name, &oid, orig_head))
6820
0
    goto cleanup;
6821
6822
0
  if (require_clean_work_tree(r, "rebase", NULL, 1, 1))
6823
0
    goto cleanup;
6824
6825
0
  todo_list_write_total_nr(&new_todo);
6826
0
  res = pick_commits(r, &new_todo, opts);
6827
6828
0
cleanup:
6829
0
  todo_list_release(&new_todo);
6830
6831
0
  return res;
6832
0
}
6833
6834
struct subject2item_entry {
6835
  struct hashmap_entry entry;
6836
  int i;
6837
  char subject[FLEX_ARRAY];
6838
};
6839
6840
static int subject2item_cmp(const void *fndata UNUSED,
6841
          const struct hashmap_entry *eptr,
6842
          const struct hashmap_entry *entry_or_key,
6843
          const void *key)
6844
0
{
6845
0
  const struct subject2item_entry *a, *b;
6846
6847
0
  a = container_of(eptr, const struct subject2item_entry, entry);
6848
0
  b = container_of(entry_or_key, const struct subject2item_entry, entry);
6849
6850
0
  return key ? strcmp(a->subject, key) : strcmp(a->subject, b->subject);
6851
0
}
6852
6853
0
define_commit_slab(commit_todo_item, struct todo_item *);
Unexecuted instantiation: sequencer.c:init_commit_todo_item_with_stride
Unexecuted instantiation: sequencer.c:commit_todo_item_at_peek
Unexecuted instantiation: sequencer.c:clear_commit_todo_item
6854
0
6855
0
static int skip_fixupish(const char *subject, const char **p) {
6856
0
  return skip_prefix(subject, "fixup! ", p) ||
6857
0
         skip_prefix(subject, "amend! ", p) ||
6858
0
         skip_prefix(subject, "squash! ", p);
6859
0
}
6860
6861
/*
6862
 * Rearrange the todo list that has both "pick commit-id msg" and "pick
6863
 * commit-id fixup!/squash! msg" in it so that the latter is put immediately
6864
 * after the former, and change "pick" to "fixup"/"squash".
6865
 *
6866
 * Note that if the config has specified a custom instruction format, each log
6867
 * message will have to be retrieved from the commit (as the oneline in the
6868
 * script cannot be trusted) in order to normalize the autosquash arrangement.
6869
 */
6870
int todo_list_rearrange_squash(struct todo_list *todo_list)
6871
0
{
6872
0
  struct hashmap subject2item;
6873
0
  int rearranged = 0, *next, *tail, i, nr = 0;
6874
0
  char **subjects;
6875
0
  struct commit_todo_item commit_todo;
6876
0
  struct todo_item *items = NULL;
6877
0
  int ret = 0;
6878
6879
0
  init_commit_todo_item(&commit_todo);
6880
  /*
6881
   * The hashmap maps onelines to the respective todo list index.
6882
   *
6883
   * If any items need to be rearranged, the next[i] value will indicate
6884
   * which item was moved directly after the i'th.
6885
   *
6886
   * In that case, last[i] will indicate the index of the latest item to
6887
   * be moved to appear after the i'th.
6888
   */
6889
0
  hashmap_init(&subject2item, subject2item_cmp, NULL, todo_list->nr);
6890
0
  ALLOC_ARRAY(next, todo_list->nr);
6891
0
  ALLOC_ARRAY(tail, todo_list->nr);
6892
0
  ALLOC_ARRAY(subjects, todo_list->nr);
6893
0
  for (i = 0; i < todo_list->nr; i++) {
6894
0
    struct strbuf buf = STRBUF_INIT;
6895
0
    struct todo_item *item = todo_list->items + i;
6896
0
    const char *commit_buffer, *subject, *p;
6897
0
    size_t subject_len;
6898
0
    int i2 = -1;
6899
0
    struct subject2item_entry *entry;
6900
6901
0
    next[i] = tail[i] = -1;
6902
0
    if (!item->commit || item->command == TODO_DROP) {
6903
0
      subjects[i] = NULL;
6904
0
      continue;
6905
0
    }
6906
6907
0
    if (is_fixup(item->command)) {
6908
0
      ret = error(_("the script was already rearranged."));
6909
0
      goto cleanup;
6910
0
    }
6911
6912
0
    repo_parse_commit(the_repository, item->commit);
6913
0
    commit_buffer = repo_logmsg_reencode(the_repository,
6914
0
                 item->commit, NULL,
6915
0
                 "UTF-8");
6916
0
    find_commit_subject(commit_buffer, &subject);
6917
0
    format_subject(&buf, subject, " ");
6918
0
    subject = subjects[i] = strbuf_detach(&buf, &subject_len);
6919
0
    repo_unuse_commit_buffer(the_repository, item->commit,
6920
0
           commit_buffer);
6921
0
    if (skip_fixupish(subject, &p)) {
6922
0
      struct commit *commit2;
6923
6924
0
      for (;;) {
6925
0
        while (isspace(*p))
6926
0
          p++;
6927
0
        if (!skip_fixupish(p, &p))
6928
0
          break;
6929
0
      }
6930
6931
0
      entry = hashmap_get_entry_from_hash(&subject2item,
6932
0
            strhash(p), p,
6933
0
            struct subject2item_entry,
6934
0
            entry);
6935
0
      if (entry)
6936
        /* found by title */
6937
0
        i2 = entry->i;
6938
0
      else if (!strchr(p, ' ') &&
6939
0
         (commit2 =
6940
0
          lookup_commit_reference_by_name(p)) &&
6941
0
         *commit_todo_item_at(&commit_todo, commit2))
6942
        /* found by commit name */
6943
0
        i2 = *commit_todo_item_at(&commit_todo, commit2)
6944
0
          - todo_list->items;
6945
0
      else {
6946
        /* copy can be a prefix of the commit subject */
6947
0
        for (i2 = 0; i2 < i; i2++)
6948
0
          if (subjects[i2] &&
6949
0
              starts_with(subjects[i2], p))
6950
0
            break;
6951
0
        if (i2 == i)
6952
0
          i2 = -1;
6953
0
      }
6954
0
    }
6955
0
    if (i2 >= 0) {
6956
0
      rearranged = 1;
6957
0
      if (starts_with(subject, "fixup!")) {
6958
0
        todo_list->items[i].command = TODO_FIXUP;
6959
0
      } else if (starts_with(subject, "amend!")) {
6960
0
        todo_list->items[i].command = TODO_FIXUP;
6961
0
        todo_list->items[i].flags = TODO_REPLACE_FIXUP_MSG;
6962
0
      } else {
6963
0
        todo_list->items[i].command = TODO_SQUASH;
6964
0
      }
6965
0
      if (tail[i2] < 0) {
6966
0
        next[i] = next[i2];
6967
0
        next[i2] = i;
6968
0
      } else {
6969
0
        next[i] = next[tail[i2]];
6970
0
        next[tail[i2]] = i;
6971
0
      }
6972
0
      tail[i2] = i;
6973
0
    } else if (!hashmap_get_from_hash(&subject2item,
6974
0
            strhash(subject), subject)) {
6975
0
      FLEX_ALLOC_MEM(entry, subject, subject, subject_len);
6976
0
      entry->i = i;
6977
0
      hashmap_entry_init(&entry->entry,
6978
0
          strhash(entry->subject));
6979
0
      hashmap_put(&subject2item, &entry->entry);
6980
0
    }
6981
6982
0
    *commit_todo_item_at(&commit_todo, item->commit) = item;
6983
0
  }
6984
6985
0
  if (rearranged) {
6986
0
    ALLOC_ARRAY(items, todo_list->nr);
6987
6988
0
    for (i = 0; i < todo_list->nr; i++) {
6989
0
      enum todo_command command = todo_list->items[i].command;
6990
0
      int cur = i;
6991
6992
      /*
6993
       * Initially, all commands are 'pick's. If it is a
6994
       * fixup or a squash now, we have rearranged it.
6995
       */
6996
0
      if (is_fixup(command))
6997
0
        continue;
6998
6999
0
      while (cur >= 0) {
7000
0
        items[nr++] = todo_list->items[cur];
7001
0
        cur = next[cur];
7002
0
      }
7003
0
    }
7004
7005
0
    assert(nr == todo_list->nr);
7006
0
    todo_list->alloc = nr;
7007
0
    FREE_AND_NULL(todo_list->items);
7008
0
    todo_list->items = items;
7009
0
  }
7010
7011
0
cleanup:
7012
0
  free(next);
7013
0
  free(tail);
7014
0
  for (i = 0; i < todo_list->nr; i++)
7015
0
    free(subjects[i]);
7016
0
  free(subjects);
7017
0
  hashmap_clear_and_free(&subject2item, struct subject2item_entry, entry);
7018
7019
0
  clear_commit_todo_item(&commit_todo);
7020
7021
0
  return ret;
7022
0
}
7023
7024
int sequencer_determine_whence(struct repository *r, enum commit_whence *whence)
7025
0
{
7026
0
  if (refs_ref_exists(get_main_ref_store(r), "CHERRY_PICK_HEAD")) {
7027
0
    struct object_id cherry_pick_head, rebase_head;
7028
7029
0
    if (file_exists(git_path_seq_dir()))
7030
0
      *whence = FROM_CHERRY_PICK_MULTI;
7031
0
    if (file_exists(rebase_path()) &&
7032
0
        !repo_get_oid(r, "REBASE_HEAD", &rebase_head) &&
7033
0
        !repo_get_oid(r, "CHERRY_PICK_HEAD", &cherry_pick_head) &&
7034
0
        oideq(&rebase_head, &cherry_pick_head))
7035
0
      *whence = FROM_REBASE_PICK;
7036
0
    else
7037
0
      *whence = FROM_CHERRY_PICK_SINGLE;
7038
7039
0
    return 1;
7040
0
  }
7041
7042
0
  return 0;
7043
0
}
7044
7045
int sequencer_get_update_refs_state(const char *wt_dir,
7046
            struct string_list *refs)
7047
0
{
7048
0
  int result = 0;
7049
0
  FILE *fp = NULL;
7050
0
  struct strbuf ref = STRBUF_INIT;
7051
0
  struct strbuf hash = STRBUF_INIT;
7052
0
  struct update_ref_record *rec = NULL;
7053
7054
0
  char *path = rebase_path_update_refs(wt_dir);
7055
7056
0
  fp = fopen(path, "r");
7057
0
  if (!fp)
7058
0
    goto cleanup;
7059
7060
0
  while (strbuf_getline(&ref, fp) != EOF) {
7061
0
    struct string_list_item *item;
7062
7063
0
    CALLOC_ARRAY(rec, 1);
7064
7065
0
    if (strbuf_getline(&hash, fp) == EOF ||
7066
0
        get_oid_hex(hash.buf, &rec->before)) {
7067
0
      warning(_("update-refs file at '%s' is invalid"),
7068
0
          path);
7069
0
      result = -1;
7070
0
      goto cleanup;
7071
0
    }
7072
7073
0
    if (strbuf_getline(&hash, fp) == EOF ||
7074
0
        get_oid_hex(hash.buf, &rec->after)) {
7075
0
      warning(_("update-refs file at '%s' is invalid"),
7076
0
          path);
7077
0
      result = -1;
7078
0
      goto cleanup;
7079
0
    }
7080
7081
0
    item = string_list_insert(refs, ref.buf);
7082
0
    item->util = rec;
7083
0
    rec = NULL;
7084
0
  }
7085
7086
0
cleanup:
7087
0
  if (fp)
7088
0
    fclose(fp);
7089
0
  free(path);
7090
0
  free(rec);
7091
0
  strbuf_release(&ref);
7092
0
  strbuf_release(&hash);
7093
0
  return result;
7094
0
}