#include "git-compat-util.h"

#include "abspath.h"

#include "advice.h"

#include "config.h"

#include "copy.h"

#include "environment.h"

#include "gettext.h"

#include "hex.h"

#include "lockfile.h"

#include "dir.h"

#include "object-file.h"

#include "object-name.h"

#include "object-store-ll.h"

#include "object.h"

#include "pager.h"

#include "commit.h"

#include "sequencer.h"

#include "tag.h"

#include "run-command.h"

#include "hook.h"

#include "exec-cmd.h"

#include "utf8.h"

#include "cache-tree.h"

#include "diff.h"

#include "path.h"

#include "revision.h"

#include "rerere.h"

#include "merge.h"

#include "merge-ort.h"

#include "merge-ort-wrappers.h"

#include "refs.h"

#include "sparse-index.h"

#include "strvec.h"

#include "quote.h"

#include "trailer.h"

#include "log-tree.h"

#include "wt-status.h"

#include "hashmap.h"

#include "notes-utils.h"

#include "sigchain.h"

#include "unpack-trees.h"

#include "worktree.h"

#include "oidmap.h"

#include "oidset.h"

#include "commit-slab.h"

#include "alias.h"

#include "commit-reach.h"

#include "rebase-interactive.h"

#include "reset.h"

#include "branch.h"

#define GIT_REFLOG_ACTION "GIT_REFLOG_ACTION"

/*

 * To accommodate common filesystem limitations, where the loose refs' file

 * names must not exceed `NAME_MAX`, the labels generated by `git rebase

 * --rebase-merges` need to be truncated if the corresponding commit subjects

 * are too long.

 * Add some margin to stay clear from reaching `NAME_MAX`.

 */

#define GIT_MAX_LABEL_LENGTH ((NAME_MAX) - (LOCK_SUFFIX_LEN) - 16)

static const char sign_off_header[] = "Signed-off-by: ";

static const char cherry_picked_prefix[] = "(cherry picked from commit ";

GIT_PATH_FUNC(git_path_commit_editmsg, "COMMIT_EDITMSG")

static GIT_PATH_FUNC(git_path_seq_dir, "sequencer")

static GIT_PATH_FUNC(git_path_todo_file, "sequencer/todo")

static GIT_PATH_FUNC(git_path_opts_file, "sequencer/opts")

static GIT_PATH_FUNC(git_path_head_file, "sequencer/head")

static GIT_PATH_FUNC(git_path_abort_safety_file, "sequencer/abort-safety")

static GIT_PATH_FUNC(rebase_path, "rebase-merge")

/*

 * The file containing rebase commands, comments, and empty lines.

 * This file is created by "git rebase -i" then edited by the user. As

 * the lines are processed, they are removed from the front of this

 * file and written to the tail of 'done'.

 */

GIT_PATH_FUNC(rebase_path_todo, "rebase-merge/git-rebase-todo")

GIT_PATH_FUNC(rebase_path_todo_backup, "rebase-merge/git-rebase-todo.backup")

GIT_PATH_FUNC(rebase_path_dropped, "rebase-merge/dropped")

/*

 * The rebase command lines that have already been processed. A line

 * is moved here when it is first handled, before any associated user

 * actions.

 */

static GIT_PATH_FUNC(rebase_path_done, "rebase-merge/done")

/*

 * The file to keep track of how many commands were already processed (e.g.

 * for the prompt).

 */

static GIT_PATH_FUNC(rebase_path_msgnum, "rebase-merge/msgnum")

/*

 * The file to keep track of how many commands are to be processed in total

 * (e.g. for the prompt).

 */

static GIT_PATH_FUNC(rebase_path_msgtotal, "rebase-merge/end")

/*

 * The commit message that is planned to be used for any changes that

 * need to be committed following a user interaction.

 */

static GIT_PATH_FUNC(rebase_path_message, "rebase-merge/message")

/*

 * The file into which is accumulated the suggested commit message for

 * squash/fixup commands. When the first of a series of squash/fixups

 * is seen, the file is created and the commit message from the

 * previous commit and from the first squash/fixup commit are written

 * to it. The commit message for each subsequent squash/fixup commit

 * is appended to the file as it is processed.

 */

static GIT_PATH_FUNC(rebase_path_squash_msg, "rebase-merge/message-squash")

/*

 * If the current series of squash/fixups has not yet included a squash

 * command, then this file exists and holds the commit message of the

 * original "pick" commit.  (If the series ends without a "squash"

 * command, then this can be used as the commit message of the combined

 * commit without opening the editor.)

 */

static GIT_PATH_FUNC(rebase_path_fixup_msg, "rebase-merge/message-fixup")

/*

 * This file contains the list fixup/squash commands that have been

 * accumulated into message-fixup or message-squash so far.

 */

static GIT_PATH_FUNC(rebase_path_current_fixups, "rebase-merge/current-fixups")

/*

 * A script to set the GIT_AUTHOR_NAME, GIT_AUTHOR_EMAIL, and

 * GIT_AUTHOR_DATE that will be used for the commit that is currently

 * being rebased.

 */

static GIT_PATH_FUNC(rebase_path_author_script, "rebase-merge/author-script")

/*

 * When an "edit" rebase command is being processed, the SHA1 of the

 * commit to be edited is recorded in this file.  When "git rebase

 * --continue" is executed, if there are any staged changes then they

 * will be amended to the HEAD commit, but only provided the HEAD

 * commit is still the commit to be edited.  When any other rebase

 * command is processed, this file is deleted.

 */

static GIT_PATH_FUNC(rebase_path_amend, "rebase-merge/amend")

/*

 * When we stop at a given patch via the "edit" command, this file contains

 * the commit object name of the corresponding patch.

 */

static GIT_PATH_FUNC(rebase_path_stopped_sha, "rebase-merge/stopped-sha")

/*

 * When we stop for the user to resolve conflicts this file contains

 * the patch of the commit that is being picked.

 */

static GIT_PATH_FUNC(rebase_path_patch, "rebase-merge/patch")

/*

 * For the post-rewrite hook, we make a list of rewritten commits and

 * their new sha1s.  The rewritten-pending list keeps the sha1s of

 * commits that have been processed, but not committed yet,

 * e.g. because they are waiting for a 'squash' command.

 */

static GIT_PATH_FUNC(rebase_path_rewritten_list, "rebase-merge/rewritten-list")

static GIT_PATH_FUNC(rebase_path_rewritten_pending,

  "rebase-merge/rewritten-pending")

/*

 * The path of the file containing the OID of the "squash onto" commit, i.e.

 * the dummy commit used for `reset [new root]`.

 */

static GIT_PATH_FUNC(rebase_path_squash_onto, "rebase-merge/squash-onto")

/*

 * The path of the file listing refs that need to be deleted after the rebase

 * finishes. This is used by the `label` command to record the need for cleanup.

 */

static GIT_PATH_FUNC(rebase_path_refs_to_delete, "rebase-merge/refs-to-delete")

/*

 * The update-refs file stores a list of refs that will be updated at the end

 * of the rebase sequence. The 'update-ref <ref>' commands in the todo file

 * update the OIDs for the refs in this file, but the refs are not updated

 * until the end of the rebase sequence.

 *

 * rebase_path_update_refs() returns the path to this file for a given

 * worktree directory. For the current worktree, pass the_repository->gitdir.

 */

static char *rebase_path_update_refs(const char *wt_git_dir)

{

  return xstrfmt("%s/rebase-merge/update-refs", wt_git_dir);

}

/*

 * The following files are written by git-rebase just after parsing the

 * command-line.

 */

static GIT_PATH_FUNC(rebase_path_gpg_sign_opt, "rebase-merge/gpg_sign_opt")

static GIT_PATH_FUNC(rebase_path_cdate_is_adate, "rebase-merge/cdate_is_adate")

static GIT_PATH_FUNC(rebase_path_ignore_date, "rebase-merge/ignore_date")

static GIT_PATH_FUNC(rebase_path_orig_head, "rebase-merge/orig-head")

static GIT_PATH_FUNC(rebase_path_verbose, "rebase-merge/verbose")

static GIT_PATH_FUNC(rebase_path_quiet, "rebase-merge/quiet")

static GIT_PATH_FUNC(rebase_path_signoff, "rebase-merge/signoff")

static GIT_PATH_FUNC(rebase_path_head_name, "rebase-merge/head-name")

static GIT_PATH_FUNC(rebase_path_onto, "rebase-merge/onto")

static GIT_PATH_FUNC(rebase_path_autostash, "rebase-merge/autostash")

static GIT_PATH_FUNC(rebase_path_strategy, "rebase-merge/strategy")

static GIT_PATH_FUNC(rebase_path_strategy_opts, "rebase-merge/strategy_opts")

static GIT_PATH_FUNC(rebase_path_allow_rerere_autoupdate, "rebase-merge/allow_rerere_autoupdate")

static GIT_PATH_FUNC(rebase_path_reschedule_failed_exec, "rebase-merge/reschedule-failed-exec")

static GIT_PATH_FUNC(rebase_path_no_reschedule_failed_exec, "rebase-merge/no-reschedule-failed-exec")

static GIT_PATH_FUNC(rebase_path_drop_redundant_commits, "rebase-merge/drop_redundant_commits")

static GIT_PATH_FUNC(rebase_path_keep_redundant_commits, "rebase-merge/keep_redundant_commits")

/**

 * A 'struct update_refs_record' represents a value in the update-refs

 * list. We use a string_list to map refs to these (before, after) pairs.

 */

struct update_ref_record {

  struct object_id before;

  struct object_id after;

};

static struct update_ref_record *init_update_ref_record(const char *ref)

{

  struct update_ref_record *rec;

  CALLOC_ARRAY(rec, 1);

  oidcpy(&rec->before, null_oid());

  oidcpy(&rec->after, null_oid());

  /* This may fail, but that's fine, we will keep the null OID. */

  read_ref(ref, &rec->before);

  return rec;

}

static int git_sequencer_config(const char *k, const char *v,

        const struct config_context *ctx, void *cb)

{

  struct replay_opts *opts = cb;

  int status;

  if (!strcmp(k, "commit.cleanup")) {

    const char *s;

    status = git_config_string(&s, k, v);

    if (status)

      return status;

    if (!strcmp(s, "verbatim")) {

      opts->default_msg_cleanup = COMMIT_MSG_CLEANUP_NONE;

      opts->explicit_cleanup = 1;

    } else if (!strcmp(s, "whitespace")) {

      opts->default_msg_cleanup = COMMIT_MSG_CLEANUP_SPACE;

      opts->explicit_cleanup = 1;

    } else if (!strcmp(s, "strip")) {

      opts->default_msg_cleanup = COMMIT_MSG_CLEANUP_ALL;

      opts->explicit_cleanup = 1;

    } else if (!strcmp(s, "scissors")) {

      opts->default_msg_cleanup = COMMIT_MSG_CLEANUP_SCISSORS;

      opts->explicit_cleanup = 1;

    } else {

      warning(_("invalid commit message cleanup mode '%s'"),

          s);

    }

    free((char *)s);

    return status;

  }

  if (!strcmp(k, "commit.gpgsign")) {

    opts->gpg_sign = git_config_bool(k, v) ? xstrdup("") : NULL;

    return 0;

  }

  if (!opts->default_strategy && !strcmp(k, "pull.twohead")) {

    int ret = git_config_string((const char**)&opts->default_strategy, k, v);

    if (ret == 0) {

      /*

       * pull.twohead is allowed to be multi-valued; we only

       * care about the first value.

       */

      char *tmp = strchr(opts->default_strategy, ' ');

      if (tmp)

        *tmp = '\0';

    }

    return ret;

  }

  if (opts->action == REPLAY_REVERT && !strcmp(k, "revert.reference"))

    opts->commit_use_reference = git_config_bool(k, v);

  return git_diff_basic_config(k, v, ctx, NULL);

}

void sequencer_init_config(struct replay_opts *opts)

{

  opts->default_msg_cleanup = COMMIT_MSG_CLEANUP_NONE;

  git_config(git_sequencer_config, opts);

}

static inline int is_rebase_i(const struct replay_opts *opts)

{

  return opts->action == REPLAY_INTERACTIVE_REBASE;

}

static const char *get_dir(const struct replay_opts *opts)

{

  if (is_rebase_i(opts))

    return rebase_path();

  return git_path_seq_dir();

}

static const char *get_todo_path(const struct replay_opts *opts)

{

  if (is_rebase_i(opts))

    return rebase_path_todo();

  return git_path_todo_file();

}

/*

 * Returns 0 for non-conforming footer

 * Returns 1 for conforming footer

 * Returns 2 when sob exists within conforming footer

 * Returns 3 when sob exists within conforming footer as last entry

 */

static int has_conforming_footer(struct strbuf *sb, struct strbuf *sob,

  size_t ignore_footer)

{

  struct process_trailer_options opts = PROCESS_TRAILER_OPTIONS_INIT;

  struct trailer_info info;

  size_t i;

  int found_sob = 0, found_sob_last = 0;

  char saved_char;

  opts.no_divider = 1;

  if (ignore_footer) {

    saved_char = sb->buf[sb->len - ignore_footer];

    sb->buf[sb->len - ignore_footer] = '\0';

  }

  trailer_info_get(&info, sb->buf, &opts);

  if (ignore_footer)

    sb->buf[sb->len - ignore_footer] = saved_char;

  if (info.trailer_start == info.trailer_end)

    return 0;

  for (i = 0; i < info.trailer_nr; i++)

    if (sob && !strncmp(info.trailers[i], sob->buf, sob->len)) {

      found_sob = 1;

      if (i == info.trailer_nr - 1)

        found_sob_last = 1;

    }

  trailer_info_release(&info);

  if (found_sob_last)

    return 3;

  if (found_sob)

    return 2;

  return 1;

}

static const char *gpg_sign_opt_quoted(struct replay_opts *opts)

{

  static struct strbuf buf = STRBUF_INIT;

  strbuf_reset(&buf);

  if (opts->gpg_sign)

    sq_quotef(&buf, "-S%s", opts->gpg_sign);

  return buf.buf;

}

void replay_opts_release(struct replay_opts *opts)

{

  free(opts->gpg_sign);

  free(opts->reflog_action);

  free(opts->default_strategy);

  free(opts->strategy);

  strvec_clear (&opts->xopts);

  strbuf_release(&opts->current_fixups);

  if (opts->revs)

    release_revisions(opts->revs);

  free(opts->revs);

}

int sequencer_remove_state(struct replay_opts *opts)

{

  struct strbuf buf = STRBUF_INIT;

  int ret = 0;

  if (is_rebase_i(opts) &&

      strbuf_read_file(&buf, rebase_path_refs_to_delete(), 0) > 0) {

    char *p = buf.buf;

    while (*p) {

      char *eol = strchr(p, '\n');

      if (eol)

        *eol = '\0';

      if (delete_ref("(rebase) cleanup", p, NULL, 0) < 0) {

        warning(_("could not delete '%s'"), p);

        ret = -1;

      }

      if (!eol)

        break;

      p = eol + 1;

    }

  }

  strbuf_reset(&buf);

  strbuf_addstr(&buf, get_dir(opts));

  if (remove_dir_recursively(&buf, 0))

    ret = error(_("could not remove '%s'"), buf.buf);

  strbuf_release(&buf);

  return ret;

}

static const char *action_name(const struct replay_opts *opts)

{

  switch (opts->action) {

  case REPLAY_REVERT:

    return N_("revert");

  case REPLAY_PICK:

    return N_("cherry-pick");

  case REPLAY_INTERACTIVE_REBASE:

    return N_("rebase");

  }

  die(_("unknown action: %d"), opts->action);

}

struct commit_message {

  char *parent_label;

  char *label;

  char *subject;

  const char *message;

};

static const char *short_commit_name(struct repository *r, struct commit *commit)

{

  return repo_find_unique_abbrev(r, &commit->object.oid, DEFAULT_ABBREV);

}

static int get_message(struct commit *commit, struct commit_message *out)

{

  const char *abbrev, *subject;

  int subject_len;

  out->message = repo_logmsg_reencode(the_repository, commit, NULL,

              get_commit_output_encoding());

  abbrev = short_commit_name(the_repository, commit);

  subject_len = find_commit_subject(out->message, &subject);

  out->subject = xmemdupz(subject, subject_len);

  out->label = xstrfmt("%s (%s)", abbrev, out->subject);

  out->parent_label = xstrfmt("parent of %s", out->label);

  return 0;

}

static void free_message(struct commit *commit, struct commit_message *msg)

{

  free(msg->parent_label);

  free(msg->label);

  free(msg->subject);

  repo_unuse_commit_buffer(the_repository, commit, msg->message);

}

static void print_advice(struct repository *r, int show_hint,

       struct replay_opts *opts)

{

  char *msg = getenv("GIT_CHERRY_PICK_HELP");

  if (msg) {

    advise("%s\n", msg);

    /*

     * A conflict has occurred but the porcelain

     * (typically rebase --interactive) wants to take care

     * of the commit itself so remove CHERRY_PICK_HEAD

     */

    refs_delete_ref(get_main_ref_store(r), "", "CHERRY_PICK_HEAD",

        NULL, 0);

    return;

  }

  if (show_hint) {

    if (opts->no_commit)

      advise(_("after resolving the conflicts, mark the corrected paths\n"

         "with 'git add <paths>' or 'git rm <paths>'"));

    else if (opts->action == REPLAY_PICK)

      advise(_("After resolving the conflicts, mark them with\n"

         "\"git add/rm <pathspec>\", then run\n"

         "\"git cherry-pick --continue\".\n"

         "You can instead skip this commit with \"git cherry-pick --skip\".\n"

         "To abort and get back to the state before \"git cherry-pick\",\n"

         "run \"git cherry-pick --abort\"."));

    else if (opts->action == REPLAY_REVERT)

      advise(_("After resolving the conflicts, mark them with\n"

         "\"git add/rm <pathspec>\", then run\n"

         "\"git revert --continue\".\n"

         "You can instead skip this commit with \"git revert --skip\".\n"

         "To abort and get back to the state before \"git revert\",\n"

         "run \"git revert --abort\"."));

    else

      BUG("unexpected pick action in print_advice()");

  }

}

static int write_message(const void *buf, size_t len, const char *filename,

       int append_eol)

{

  struct lock_file msg_file = LOCK_INIT;

  int msg_fd = hold_lock_file_for_update(&msg_file, filename, 0);

  if (msg_fd < 0)

    return error_errno(_("could not lock '%s'"), filename);

  if (write_in_full(msg_fd, buf, len) < 0) {

    error_errno(_("could not write to '%s'"), filename);

    rollback_lock_file(&msg_file);

    return -1;

  }

  if (append_eol && write(msg_fd, "\n", 1) < 0) {

    error_errno(_("could not write eol to '%s'"), filename);

    rollback_lock_file(&msg_file);

    return -1;

  }

  if (commit_lock_file(&msg_file) < 0)

    return error(_("failed to finalize '%s'"), filename);

  return 0;

}

int read_oneliner(struct strbuf *buf,

  const char *path, unsigned flags)

{

  int orig_len = buf->len;

  if (strbuf_read_file(buf, path, 0) < 0) {

    if ((flags & READ_ONELINER_WARN_MISSING) ||

        (errno != ENOENT && errno != ENOTDIR))

      warning_errno(_("could not read '%s'"), path);

    return 0;

  }

  if (buf->len > orig_len && buf->buf[buf->len - 1] == '\n') {

    if (--buf->len > orig_len && buf->buf[buf->len - 1] == '\r')

      --buf->len;

    buf->buf[buf->len] = '\0';

  }

  if ((flags & READ_ONELINER_SKIP_IF_EMPTY) && buf->len == orig_len)

    return 0;

  return 1;

}

static struct tree *empty_tree(struct repository *r)

{

  return lookup_tree(r, the_hash_algo->empty_tree);

}

static int error_dirty_index(struct repository *repo, struct replay_opts *opts)

{

  if (repo_read_index_unmerged(repo))

    return error_resolve_conflict(action_name(opts));

  error(_("your local changes would be overwritten by %s."),

    _(action_name(opts)));

  if (advice_enabled(ADVICE_COMMIT_BEFORE_MERGE))

    advise(_("commit your changes or stash them to proceed."));

  return -1;

}

static void update_abort_safety_file(void)

{

  struct object_id head;

  /* Do nothing on a single-pick */

  if (!file_exists(git_path_seq_dir()))

    return;

  if (!repo_get_oid(the_repository, "HEAD", &head))

    write_file(git_path_abort_safety_file(), "%s", oid_to_hex(&head));

  else

    write_file(git_path_abort_safety_file(), "%s", "");

}

static int fast_forward_to(struct repository *r,

         const struct object_id *to,

         const struct object_id *from,

         int unborn,

         struct replay_opts *opts)

{

  struct ref_transaction *transaction;

  struct strbuf sb = STRBUF_INIT;

  struct strbuf err = STRBUF_INIT;

  repo_read_index(r);

  if (checkout_fast_forward(r, from, to, 1))

    return -1; /* the callee should have complained already */

  strbuf_addf(&sb, "%s: fast-forward", action_name(opts));

  transaction = ref_transaction_begin(&err);

  if (!transaction ||

      ref_transaction_update(transaction, "HEAD",

           to, unborn && !is_rebase_i(opts) ?

           null_oid() : from,

           0, sb.buf, &err) ||

      ref_transaction_commit(transaction, &err)) {

    ref_transaction_free(transaction);

    error("%s", err.buf);

    strbuf_release(&sb);

    strbuf_release(&err);

    return -1;

  }

  strbuf_release(&sb);

  strbuf_release(&err);

  ref_transaction_free(transaction);

  update_abort_safety_file();

  return 0;

}

enum commit_msg_cleanup_mode get_cleanup_mode(const char *cleanup_arg,

  int use_editor)

{

  if (!cleanup_arg || !strcmp(cleanup_arg, "default"))

    return use_editor ? COMMIT_MSG_CLEANUP_ALL :

            COMMIT_MSG_CLEANUP_SPACE;

  else if (!strcmp(cleanup_arg, "verbatim"))

    return COMMIT_MSG_CLEANUP_NONE;

  else if (!strcmp(cleanup_arg, "whitespace"))

    return COMMIT_MSG_CLEANUP_SPACE;

  else if (!strcmp(cleanup_arg, "strip"))

    return COMMIT_MSG_CLEANUP_ALL;

  else if (!strcmp(cleanup_arg, "scissors"))

    return use_editor ? COMMIT_MSG_CLEANUP_SCISSORS :

            COMMIT_MSG_CLEANUP_SPACE;

  else

    die(_("Invalid cleanup mode %s"), cleanup_arg);

}

/*

 * NB using int rather than enum cleanup_mode to stop clang's

 * -Wtautological-constant-out-of-range-compare complaining that the comparison

 * is always true.

 */

static const char *describe_cleanup_mode(int cleanup_mode)

{

  static const char *modes[] = { "whitespace",

               "verbatim",

               "scissors",

               "strip" };

  if (cleanup_mode < ARRAY_SIZE(modes))

    return modes[cleanup_mode];

  BUG("invalid cleanup_mode provided (%d)", cleanup_mode);

}

void append_conflicts_hint(struct index_state *istate,

  struct strbuf *msgbuf, enum commit_msg_cleanup_mode cleanup_mode)

{

  int i;

  if (cleanup_mode == COMMIT_MSG_CLEANUP_SCISSORS) {

    strbuf_addch(msgbuf, '\n');

    wt_status_append_cut_line(msgbuf);

    strbuf_addch(msgbuf, comment_line_char);

  }

  strbuf_addch(msgbuf, '\n');

  strbuf_commented_addf(msgbuf, comment_line_char, "Conflicts:\n");

  for (i = 0; i < istate->cache_nr;) {

    const struct cache_entry *ce = istate->cache[i++];

    if (ce_stage(ce)) {

      strbuf_commented_addf(msgbuf, comment_line_char,

                "\t%s\n", ce->name);

      while (i < istate->cache_nr &&

             !strcmp(ce->name, istate->cache[i]->name))

        i++;

    }

  }

}

static int do_recursive_merge(struct repository *r,

            struct commit *base, struct commit *next,

            const char *base_label, const char *next_label,

            struct object_id *head, struct strbuf *msgbuf,

            struct replay_opts *opts)

{

  struct merge_options o;

  struct merge_result result;

  struct tree *next_tree, *base_tree, *head_tree;

  int clean, show_output;

  int i;

  struct lock_file index_lock = LOCK_INIT;

  if (repo_hold_locked_index(r, &index_lock, LOCK_REPORT_ON_ERROR) < 0)

    return -1;

  repo_read_index(r);

  init_merge_options(&o, r);

  o.ancestor = base ? base_label : "(empty tree)";

  o.branch1 = "HEAD";

  o.branch2 = next ? next_label : "(empty tree)";

  if (is_rebase_i(opts))

    o.buffer_output = 2;

  o.show_rename_progress = 1;

  head_tree = parse_tree_indirect(head);

  next_tree = next ? repo_get_commit_tree(r, next) : empty_tree(r);

  base_tree = base ? repo_get_commit_tree(r, base) : empty_tree(r);

  for (i = 0; i < opts->xopts.nr; i++)

    parse_merge_opt(&o, opts->xopts.v[i]);

  if (!opts->strategy || !strcmp(opts->strategy, "ort")) {

    memset(&result, 0, sizeof(result));

    merge_incore_nonrecursive(&o, base_tree, head_tree, next_tree,

              &result);

    show_output = !is_rebase_i(opts) || !result.clean;

    /*

     * TODO: merge_switch_to_result will update index/working tree;

     * we only really want to do that if !result.clean || this is

     * the final patch to be picked.  But determining this is the

     * final patch would take some work, and "head_tree" would need

     * to be replace with the tree the index matched before we

     * started doing any picks.

     */

    merge_switch_to_result(&o, head_tree, &result, 1, show_output);

    clean = result.clean;

  } else {

    ensure_full_index(r->index);

    clean = merge_trees(&o, head_tree, next_tree, base_tree);

    if (is_rebase_i(opts) && clean <= 0)

      fputs(o.obuf.buf, stdout);

    strbuf_release(&o.obuf);

  }

  if (clean < 0) {

    rollback_lock_file(&index_lock);

    return clean;

  }

  if (write_locked_index(r->index, &index_lock,

             COMMIT_LOCK | SKIP_IF_UNCHANGED))

    /*

     * TRANSLATORS: %s will be "revert", "cherry-pick" or

     * "rebase".

     */

    return error(_("%s: Unable to write new index file"),

      _(action_name(opts)));

  if (!clean)

    append_conflicts_hint(r->index, msgbuf,

              opts->default_msg_cleanup);

  return !clean;

}

static struct object_id *get_cache_tree_oid(struct index_state *istate)

{

  if (!cache_tree_fully_valid(istate->cache_tree))

    if (cache_tree_update(istate, 0)) {

      error(_("unable to update cache tree"));

      return NULL;

    }

  return &istate->cache_tree->oid;

}

static int is_index_unchanged(struct repository *r)

{

  struct object_id head_oid, *cache_tree_oid;

  struct commit *head_commit;

  struct index_state *istate = r->index;

  if (!resolve_ref_unsafe("HEAD", RESOLVE_REF_READING, &head_oid, NULL))

    return error(_("could not resolve HEAD commit"));

  head_commit = lookup_commit(r, &head_oid);

  /*

   * If head_commit is NULL, check_commit, called from

   * lookup_commit, would have indicated that head_commit is not

   * a commit object already.  repo_parse_commit() will return failure

   * without further complaints in such a case.  Otherwise, if

   * the commit is invalid, repo_parse_commit() will complain.  So

   * there is nothing for us to say here.  Just return failure.

   */

  if (repo_parse_commit(r, head_commit))

    return -1;

  if (!(cache_tree_oid = get_cache_tree_oid(istate)))

    return -1;

  return oideq(cache_tree_oid, get_commit_tree_oid(head_commit));

}

static int write_author_script(const char *message)

{

  struct strbuf buf = STRBUF_INIT;

  const char *eol;

  int res;

  for (;;)

    if (!*message || starts_with(message, "\n")) {

missing_author:

      /* Missing 'author' line? */

      unlink(rebase_path_author_script());

      return 0;

    } else if (skip_prefix(message, "author ", &message))

      break;

    else if ((eol = strchr(message, '\n')))

      message = eol + 1;

    else

      goto missing_author;

  strbuf_addstr(&buf, "GIT_AUTHOR_NAME='");

  while (*message && *message != '\n' && *message != '\r')

    if (skip_prefix(message, " <", &message))

      break;

    else if (*message != '\'')

      strbuf_addch(&buf, *(message++));

    else

      strbuf_addf(&buf, "'\\%c'", *(message++));

  strbuf_addstr(&buf, "'\nGIT_AUTHOR_EMAIL='");

  while (*message && *message != '\n' && *message != '\r')

    if (skip_prefix(message, "> ", &message))

      break;

    else if (*message != '\'')

      strbuf_addch(&buf, *(message++));

    else

      strbuf_addf(&buf, "'\\%c'", *(message++));

  strbuf_addstr(&buf, "'\nGIT_AUTHOR_DATE='@");

  while (*message && *message != '\n' && *message != '\r')

    if (*message != '\'')

      strbuf_addch(&buf, *(message++));

    else

      strbuf_addf(&buf, "'\\%c'", *(message++));

  strbuf_addch(&buf, '\'');

  res = write_message(buf.buf, buf.len, rebase_path_author_script(), 1);

  strbuf_release(&buf);

  return res;

}

/**

 * Take a series of KEY='VALUE' lines where VALUE part is

 * sq-quoted, and append <KEY, VALUE> at the end of the string list

 */

static int parse_key_value_squoted(char *buf, struct string_list *list)

{

  while (*buf) {

    struct string_list_item *item;

    char *np;

    char *cp = strchr(buf, '=');

    if (!cp) {

      np = strchrnul(buf, '\n');

      return error(_("no key present in '%.*s'"),

             (int) (np - buf), buf);

    }

    np = strchrnul(cp, '\n');

    *cp++ = '\0';

    item = string_list_append(list, buf);

    buf = np + (*np == '\n');

    *np = '\0';

    cp = sq_dequote(cp);

    if (!cp)

      return error(_("unable to dequote value of '%s'"),

             item->string);

    item->util = xstrdup(cp);

  }

  return 0;

}

/**

 * Reads and parses the state directory's "author-script" file, and sets name,

 * email and date accordingly.

 * Returns 0 on success, -1 if the file could not be parsed.

 *

 * The author script is of the format:

 *

 *  GIT_AUTHOR_NAME='$author_name'

 *  GIT_AUTHOR_EMAIL='$author_email'

 *  GIT_AUTHOR_DATE='$author_date'

 *

 * where $author_name, $author_email and $author_date are quoted. We are strict

 * with our parsing, as the file was meant to be eval'd in the now-removed

 * git-am.sh/git-rebase--interactive.sh scripts, and thus if the file differs

 * from what this function expects, it is better to bail out than to do

 * something that the user does not expect.

 */

int read_author_script(const char *path, char **name, char **email, char **date,

           int allow_missing)

{

  struct strbuf buf = STRBUF_INIT;

  struct string_list kv = STRING_LIST_INIT_DUP;

  int retval = -1; /* assume failure */

  int i, name_i = -2, email_i = -2, date_i = -2, err = 0;

  if (strbuf_read_file(&buf, path, 256) <= 0) {

    strbuf_release(&buf);

    if (errno == ENOENT && allow_missing)

      return 0;

    else

      return error_errno(_("could not open '%s' for reading"),

             path);

  }

  if (parse_key_value_squoted(buf.buf, &kv))

    goto finish;

  for (i = 0; i < kv.nr; i++) {