/*

 * Builtin "git merge"

 *

 * Copyright (c) 2008 Miklos Vajna <vmiklos@frugalware.org>

 *

 * Based on git-merge.sh by Junio C Hamano.

 */

#define USE_THE_INDEX_VARIABLE

#include "builtin.h"

#include "abspath.h"

#include "advice.h"

#include "config.h"

#include "editor.h"

#include "environment.h"

#include "gettext.h"

#include "hex.h"

#include "object-name.h"

#include "parse-options.h"

#include "lockfile.h"

#include "run-command.h"

#include "hook.h"

#include "diff.h"

#include "diff-merges.h"

#include "refs.h"

#include "refspec.h"

#include "commit.h"

#include "diffcore.h"

#include "path.h"

#include "revision.h"

#include "unpack-trees.h"

#include "cache-tree.h"

#include "dir.h"

#include "utf8.h"

#include "log-tree.h"

#include "color.h"

#include "rerere.h"

#include "help.h"

#include "merge.h"

#include "merge-recursive.h"

#include "merge-ort-wrappers.h"

#include "resolve-undo.h"

#include "remote.h"

#include "fmt-merge-msg.h"

#include "gpg-interface.h"

#include "sequencer.h"

#include "string-list.h"

#include "packfile.h"

#include "tag.h"

#include "alias.h"

#include "branch.h"

#include "commit-reach.h"

#include "wt-status.h"

#include "commit-graph.h"

#define DEFAULT_TWOHEAD (1<<0)

#define DEFAULT_OCTOPUS (1<<1)

#define NO_FAST_FORWARD (1<<2)

#define NO_TRIVIAL      (1<<3)

struct strategy {

  const char *name;

  unsigned attr;

};

static const char * const builtin_merge_usage[] = {

  N_("git merge [<options>] [<commit>...]"),

  "git merge --abort",

  "git merge --continue",

  NULL

};

static int show_diffstat = 1, shortlog_len = -1, squash;

static int option_commit = -1;

static int option_edit = -1;

static int allow_trivial = 1, have_message, verify_signatures;

static int check_trust_level = 1;

static int overwrite_ignore = 1;

static struct strbuf merge_msg = STRBUF_INIT;

static struct strategy **use_strategies;

static size_t use_strategies_nr, use_strategies_alloc;

static struct strvec xopts = STRVEC_INIT;

static const char *branch;

static char *branch_mergeoptions;

static int verbosity;

static int allow_rerere_auto;

static int abort_current_merge;

static int quit_current_merge;

static int continue_current_merge;

static int allow_unrelated_histories;

static int show_progress = -1;

static int default_to_upstream = 1;

static int signoff;

static const char *sign_commit;

static int autostash;

static int no_verify;

static char *into_name;

static struct strategy all_strategy[] = {

  { "recursive",  NO_TRIVIAL },

  { "octopus",    DEFAULT_OCTOPUS },

  { "ort",        DEFAULT_TWOHEAD | NO_TRIVIAL },

  { "resolve",    0 },

  { "ours",       NO_FAST_FORWARD | NO_TRIVIAL },

  { "subtree",    NO_FAST_FORWARD | NO_TRIVIAL },

};

static const char *pull_twohead, *pull_octopus;

enum ff_type {

  FF_NO,

  FF_ALLOW,

  FF_ONLY

};

static enum ff_type fast_forward = FF_ALLOW;

static const char *cleanup_arg;

static enum commit_msg_cleanup_mode cleanup_mode;

static int option_parse_message(const struct option *opt,

        const char *arg, int unset)

{

  struct strbuf *buf = opt->value;

  if (unset)

    strbuf_setlen(buf, 0);

  else if (arg) {

    strbuf_addf(buf, "%s%s", buf->len ? "\n\n" : "", arg);

    have_message = 1;

  } else

    return error(_("switch `m' requires a value"));

  return 0;

}

static enum parse_opt_result option_read_message(struct parse_opt_ctx_t *ctx,

             const struct option *opt,

             const char *arg_not_used,

             int unset)

{

  struct strbuf *buf = opt->value;

  const char *arg;

  BUG_ON_OPT_ARG(arg_not_used);

  if (unset)

    BUG("-F cannot be negated");

  if (ctx->opt) {

    arg = ctx->opt;

    ctx->opt = NULL;

  } else if (ctx->argc > 1) {

    ctx->argc--;

    arg = *++ctx->argv;

  } else

    return error(_("option `%s' requires a value"), opt->long_name);

  if (buf->len)

    strbuf_addch(buf, '\n');

  if (ctx->prefix && !is_absolute_path(arg))

    arg = prefix_filename(ctx->prefix, arg);

  if (strbuf_read_file(buf, arg, 0) < 0)

    return error(_("could not read file '%s'"), arg);

  have_message = 1;

  return 0;

}

static struct strategy *get_strategy(const char *name)

{

  int i;

  struct strategy *ret;

  static struct cmdnames main_cmds, other_cmds;

  static int loaded;

  char *default_strategy = getenv("GIT_TEST_MERGE_ALGORITHM");

  if (!name)

    return NULL;

  if (default_strategy &&

      !strcmp(default_strategy, "ort") &&

      !strcmp(name, "recursive")) {

    name = "ort";

  }

  for (i = 0; i < ARRAY_SIZE(all_strategy); i++)

    if (!strcmp(name, all_strategy[i].name))

      return &all_strategy[i];

  if (!loaded) {

    struct cmdnames not_strategies;

    loaded = 1;

    memset(&not_strategies, 0, sizeof(struct cmdnames));

    load_command_list("git-merge-", &main_cmds, &other_cmds);

    for (i = 0; i < main_cmds.cnt; i++) {

      int j, found = 0;

      struct cmdname *ent = main_cmds.names[i];

      for (j = 0; !found && j < ARRAY_SIZE(all_strategy); j++)

        if (!strncmp(ent->name, all_strategy[j].name, ent->len)

            && !all_strategy[j].name[ent->len])

          found = 1;

      if (!found)

        add_cmdname(&not_strategies, ent->name, ent->len);

    }

    exclude_cmds(&main_cmds, &not_strategies);

  }

  if (!is_in_cmdlist(&main_cmds, name) && !is_in_cmdlist(&other_cmds, name)) {

    fprintf(stderr, _("Could not find merge strategy '%s'.\n"), name);

    fprintf(stderr, _("Available strategies are:"));

    for (i = 0; i < main_cmds.cnt; i++)

      fprintf(stderr, " %s", main_cmds.names[i]->name);

    fprintf(stderr, ".\n");

    if (other_cmds.cnt) {

      fprintf(stderr, _("Available custom strategies are:"));

      for (i = 0; i < other_cmds.cnt; i++)

        fprintf(stderr, " %s", other_cmds.names[i]->name);

      fprintf(stderr, ".\n");

    }

    exit(1);

  }

  CALLOC_ARRAY(ret, 1);

  ret->name = xstrdup(name);

  ret->attr = NO_TRIVIAL;

  return ret;

}

static void append_strategy(struct strategy *s)

{

  ALLOC_GROW(use_strategies, use_strategies_nr + 1, use_strategies_alloc);

  use_strategies[use_strategies_nr++] = s;

}

static int option_parse_strategy(const struct option *opt UNUSED,

         const char *name, int unset)

{

  if (unset)

    return 0;

  append_strategy(get_strategy(name));

  return 0;

}

static struct option builtin_merge_options[] = {

  OPT_SET_INT('n', NULL, &show_diffstat,

    N_("do not show a diffstat at the end of the merge"), 0),

  OPT_BOOL(0, "stat", &show_diffstat,

    N_("show a diffstat at the end of the merge")),

  OPT_BOOL(0, "summary", &show_diffstat, N_("(synonym to --stat)")),

  { OPTION_INTEGER, 0, "log", &shortlog_len, N_("n"),

    N_("add (at most <n>) entries from shortlog to merge commit message"),

    PARSE_OPT_OPTARG, NULL, DEFAULT_MERGE_LOG_LEN },

  OPT_BOOL(0, "squash", &squash,

    N_("create a single commit instead of doing a merge")),

  OPT_BOOL(0, "commit", &option_commit,

    N_("perform a commit if the merge succeeds (default)")),

  OPT_BOOL('e', "edit", &option_edit,

    N_("edit message before committing")),

  OPT_CLEANUP(&cleanup_arg),

  OPT_SET_INT(0, "ff", &fast_forward, N_("allow fast-forward (default)"), FF_ALLOW),

  OPT_SET_INT_F(0, "ff-only", &fast_forward,

          N_("abort if fast-forward is not possible"),

          FF_ONLY, PARSE_OPT_NONEG),

  OPT_RERERE_AUTOUPDATE(&allow_rerere_auto),

  OPT_BOOL(0, "verify-signatures", &verify_signatures,

    N_("verify that the named commit has a valid GPG signature")),

  OPT_CALLBACK('s', "strategy", NULL, N_("strategy"),

    N_("merge strategy to use"), option_parse_strategy),

  OPT_STRVEC('X', "strategy-option", &xopts, N_("option=value"),

    N_("option for selected merge strategy")),

  OPT_CALLBACK('m', "message", &merge_msg, N_("message"),

    N_("merge commit message (for a non-fast-forward merge)"),

    option_parse_message),

  { OPTION_LOWLEVEL_CALLBACK, 'F', "file", &merge_msg, N_("path"),

    N_("read message from file"), PARSE_OPT_NONEG,

    NULL, 0, option_read_message },

  OPT_STRING(0, "into-name", &into_name, N_("name"),

       N_("use <name> instead of the real target")),

  OPT__VERBOSITY(&verbosity),

  OPT_BOOL(0, "abort", &abort_current_merge,

    N_("abort the current in-progress merge")),

  OPT_BOOL(0, "quit", &quit_current_merge,

    N_("--abort but leave index and working tree alone")),

  OPT_BOOL(0, "continue", &continue_current_merge,

    N_("continue the current in-progress merge")),

  OPT_BOOL(0, "allow-unrelated-histories", &allow_unrelated_histories,

     N_("allow merging unrelated histories")),

  OPT_SET_INT(0, "progress", &show_progress, N_("force progress reporting"), 1),

  { OPTION_STRING, 'S', "gpg-sign", &sign_commit, N_("key-id"),

    N_("GPG sign commit"), PARSE_OPT_OPTARG, NULL, (intptr_t) "" },

  OPT_AUTOSTASH(&autostash),

  OPT_BOOL(0, "overwrite-ignore", &overwrite_ignore, N_("update ignored files (default)")),

  OPT_BOOL(0, "signoff", &signoff, N_("add a Signed-off-by trailer")),

  OPT_BOOL(0, "no-verify", &no_verify, N_("bypass pre-merge-commit and commit-msg hooks")),

  OPT_END()

};

static int save_state(struct object_id *stash)

{

  int len;

  struct child_process cp = CHILD_PROCESS_INIT;

  struct strbuf buffer = STRBUF_INIT;

  struct lock_file lock_file = LOCK_INIT;

  int fd;

  int rc = -1;

  fd = repo_hold_locked_index(the_repository, &lock_file, 0);

  refresh_index(&the_index, REFRESH_QUIET, NULL, NULL, NULL);

  if (0 <= fd)

    repo_update_index_if_able(the_repository, &lock_file);

  rollback_lock_file(&lock_file);

  strvec_pushl(&cp.args, "stash", "create", NULL);

  cp.out = -1;

  cp.git_cmd = 1;

  if (start_command(&cp))

    die(_("could not run stash."));

  len = strbuf_read(&buffer, cp.out, 1024);

  close(cp.out);

  if (finish_command(&cp) || len < 0)

    die(_("stash failed"));

  else if (!len)   /* no changes */

    goto out;

  strbuf_setlen(&buffer, buffer.len-1);

  if (repo_get_oid(the_repository, buffer.buf, stash))

    die(_("not a valid object: %s"), buffer.buf);

  rc = 0;

out:

  strbuf_release(&buffer);

  return rc;

}

static void read_empty(const struct object_id *oid)

{

  struct child_process cmd = CHILD_PROCESS_INIT;

  strvec_pushl(&cmd.args, "read-tree", "-m", "-u", empty_tree_oid_hex(),

         oid_to_hex(oid), NULL);

  cmd.git_cmd = 1;

  if (run_command(&cmd))

    die(_("read-tree failed"));

}

static void reset_hard(const struct object_id *oid)

{

  struct child_process cmd = CHILD_PROCESS_INIT;

  strvec_pushl(&cmd.args, "read-tree", "-v", "--reset", "-u",

         oid_to_hex(oid), NULL);

  cmd.git_cmd = 1;

  if (run_command(&cmd))

    die(_("read-tree failed"));

}

static void restore_state(const struct object_id *head,

        const struct object_id *stash)

{

  struct child_process cmd = CHILD_PROCESS_INIT;

  reset_hard(head);

  if (is_null_oid(stash))

    goto refresh_cache;

  strvec_pushl(&cmd.args, "stash", "apply", "--index", "--quiet", NULL);

  strvec_push(&cmd.args, oid_to_hex(stash));

  /*

   * It is OK to ignore error here, for example when there was

   * nothing to restore.

   */

  cmd.git_cmd = 1;

  run_command(&cmd);

refresh_cache:

  discard_index(&the_index);

  if (repo_read_index(the_repository) < 0)

    die(_("could not read index"));

}

/* This is called when no merge was necessary. */

static void finish_up_to_date(void)

{

  if (verbosity >= 0) {

    if (squash)

      puts(_("Already up to date. (nothing to squash)"));

    else

      puts(_("Already up to date."));

  }

  remove_merge_branch_state(the_repository);

}

static void squash_message(struct commit *commit, struct commit_list *remoteheads)

{

  struct rev_info rev;

  struct strbuf out = STRBUF_INIT;

  struct commit_list *j;

  struct pretty_print_context ctx = {0};

  printf(_("Squash commit -- not updating HEAD\n"));

  repo_init_revisions(the_repository, &rev, NULL);

  diff_merges_suppress(&rev);

  rev.commit_format = CMIT_FMT_MEDIUM;

  commit->object.flags |= UNINTERESTING;

  add_pending_object(&rev, &commit->object, NULL);

  for (j = remoteheads; j; j = j->next)

    add_pending_object(&rev, &j->item->object, NULL);

  setup_revisions(0, NULL, &rev, NULL);

  if (prepare_revision_walk(&rev))

    die(_("revision walk setup failed"));

  ctx.abbrev = rev.abbrev;

  ctx.date_mode = rev.date_mode;

  ctx.fmt = rev.commit_format;

  strbuf_addstr(&out, "Squashed commit of the following:\n");

  while ((commit = get_revision(&rev)) != NULL) {

    strbuf_addch(&out, '\n');

    strbuf_addf(&out, "commit %s\n",

      oid_to_hex(&commit->object.oid));

    pretty_print_commit(&ctx, commit, &out);

  }

  write_file_buf(git_path_squash_msg(the_repository), out.buf, out.len);

  strbuf_release(&out);

  release_revisions(&rev);

}

static void finish(struct commit *head_commit,

       struct commit_list *remoteheads,

       const struct object_id *new_head, const char *msg)

{

  struct strbuf reflog_message = STRBUF_INIT;

  const struct object_id *head = &head_commit->object.oid;

  if (!msg)

    strbuf_addstr(&reflog_message, getenv("GIT_REFLOG_ACTION"));

  else {

    if (verbosity >= 0)

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

    strbuf_addf(&reflog_message, "%s: %s",

      getenv("GIT_REFLOG_ACTION"), msg);

  }

  if (squash) {

    squash_message(head_commit, remoteheads);

  } else {

    if (verbosity >= 0 && !merge_msg.len)

      printf(_("No merge message -- not updating HEAD\n"));

    else {

      update_ref(reflog_message.buf, "HEAD", new_head, head,

           0, UPDATE_REFS_DIE_ON_ERR);

      /*

       * We ignore errors in 'gc --auto', since the

       * user should see them.

       */

      run_auto_maintenance(verbosity < 0);

    }

  }

  if (new_head && show_diffstat) {

    struct diff_options opts;

    repo_diff_setup(the_repository, &opts);

    init_diffstat_widths(&opts);

    opts.output_format |=

      DIFF_FORMAT_SUMMARY | DIFF_FORMAT_DIFFSTAT;

    opts.detect_rename = DIFF_DETECT_RENAME;

    diff_setup_done(&opts);

    diff_tree_oid(head, new_head, "", &opts);

    diffcore_std(&opts);

    diff_flush(&opts);

  }

  /* Run a post-merge hook */

  run_hooks_l("post-merge", squash ? "1" : "0", NULL);

  if (new_head)

    apply_autostash(git_path_merge_autostash(the_repository));

  strbuf_release(&reflog_message);

}

/* Get the name for the merge commit's message. */

static void merge_name(const char *remote, struct strbuf *msg)

{

  struct commit *remote_head;

  struct object_id branch_head;

  struct strbuf bname = STRBUF_INIT;

  struct merge_remote_desc *desc;

  const char *ptr;

  char *found_ref = NULL;

  int len, early;

  strbuf_branchname(&bname, remote, 0);

  remote = bname.buf;

  oidclr(&branch_head);

  remote_head = get_merge_parent(remote);

  if (!remote_head)

    die(_("'%s' does not point to a commit"), remote);

  if (repo_dwim_ref(the_repository, remote, strlen(remote), &branch_head,

        &found_ref, 0) > 0) {

    if (starts_with(found_ref, "refs/heads/")) {

      strbuf_addf(msg, "%s\t\tbranch '%s' of .\n",

            oid_to_hex(&branch_head), remote);

      goto cleanup;

    }

    if (starts_with(found_ref, "refs/tags/")) {

      strbuf_addf(msg, "%s\t\ttag '%s' of .\n",

            oid_to_hex(&branch_head), remote);

      goto cleanup;

    }

    if (starts_with(found_ref, "refs/remotes/")) {

      strbuf_addf(msg, "%s\t\tremote-tracking branch '%s' of .\n",

            oid_to_hex(&branch_head), remote);

      goto cleanup;

    }

  }

  /* See if remote matches <name>^^^.. or <name>~<number> */

  for (len = 0, ptr = remote + strlen(remote);

       remote < ptr && ptr[-1] == '^';

       ptr--)

    len++;

  if (len)

    early = 1;

  else {

    early = 0;

    ptr = strrchr(remote, '~');

    if (ptr) {

      int seen_nonzero = 0;

      len++; /* count ~ */

      while (*++ptr && isdigit(*ptr)) {

        seen_nonzero |= (*ptr != '0');

        len++;

      }

      if (*ptr)

        len = 0; /* not ...~<number> */

      else if (seen_nonzero)

        early = 1;

      else if (len == 1)

        early = 1; /* "name~" is "name~1"! */

    }

  }

  if (len) {

    struct strbuf truname = STRBUF_INIT;

    strbuf_addf(&truname, "refs/heads/%s", remote);

    strbuf_setlen(&truname, truname.len - len);

    if (ref_exists(truname.buf)) {

      strbuf_addf(msg,

            "%s\t\tbranch '%s'%s of .\n",

            oid_to_hex(&remote_head->object.oid),

            truname.buf + 11,

            (early ? " (early part)" : ""));

      strbuf_release(&truname);

      goto cleanup;

    }

    strbuf_release(&truname);

  }

  desc = merge_remote_util(remote_head);

  if (desc && desc->obj && desc->obj->type == OBJ_TAG) {

    strbuf_addf(msg, "%s\t\t%s '%s'\n",

          oid_to_hex(&desc->obj->oid),

          type_name(desc->obj->type),

          remote);

    goto cleanup;

  }

  strbuf_addf(msg, "%s\t\tcommit '%s'\n",

    oid_to_hex(&remote_head->object.oid), remote);

cleanup:

  free(found_ref);

  strbuf_release(&bname);

}

static void parse_branch_merge_options(char *bmo)

{

  const char **argv;

  int argc;

  if (!bmo)

    return;

  argc = split_cmdline(bmo, &argv);

  if (argc < 0)

    die(_("Bad branch.%s.mergeoptions string: %s"), branch,

        _(split_cmdline_strerror(argc)));

  REALLOC_ARRAY(argv, argc + 2);

  MOVE_ARRAY(argv + 1, argv, argc + 1);

  argc++;

  argv[0] = "branch.*.mergeoptions";

  parse_options(argc, argv, NULL, builtin_merge_options,

          builtin_merge_usage, 0);

  free(argv);

}

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

          const struct config_context *ctx, void *cb)

{

  int status;

  const char *str;

  if (branch &&

      skip_prefix(k, "branch.", &str) &&

      skip_prefix(str, branch, &str) &&

      !strcmp(str, ".mergeoptions")) {

    free(branch_mergeoptions);

    branch_mergeoptions = xstrdup(v);

    return 0;

  }

  if (!strcmp(k, "merge.diffstat") || !strcmp(k, "merge.stat"))

    show_diffstat = git_config_bool(k, v);

  else if (!strcmp(k, "merge.verifysignatures"))

    verify_signatures = git_config_bool(k, v);

  else if (!strcmp(k, "pull.twohead"))

    return git_config_string(&pull_twohead, k, v);

  else if (!strcmp(k, "pull.octopus"))

    return git_config_string(&pull_octopus, k, v);

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

    return git_config_string(&cleanup_arg, k, v);

  else if (!strcmp(k, "merge.ff")) {

    int boolval = git_parse_maybe_bool(v);

    if (0 <= boolval) {

      fast_forward = boolval ? FF_ALLOW : FF_NO;

    } else if (v && !strcmp(v, "only")) {

      fast_forward = FF_ONLY;

    } /* do not barf on values from future versions of git */

    return 0;

  } else if (!strcmp(k, "merge.defaulttoupstream")) {

    default_to_upstream = git_config_bool(k, v);

    return 0;

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

    sign_commit = git_config_bool(k, v) ? "" : NULL;

    return 0;

  } else if (!strcmp(k, "gpg.mintrustlevel")) {

    check_trust_level = 0;

  } else if (!strcmp(k, "merge.autostash")) {

    autostash = git_config_bool(k, v);

    return 0;

  }

  status = fmt_merge_msg_config(k, v, ctx, cb);

  if (status)

    return status;

  return git_diff_ui_config(k, v, ctx, cb);

}

static int read_tree_trivial(struct object_id *common, struct object_id *head,

           struct object_id *one)

{

  int i, nr_trees = 0;

  struct tree *trees[MAX_UNPACK_TREES];

  struct tree_desc t[MAX_UNPACK_TREES];

  struct unpack_trees_options opts;

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

  opts.head_idx = 2;

  opts.src_index = &the_index;

  opts.dst_index = &the_index;

  opts.update = 1;

  opts.verbose_update = 1;

  opts.trivial_merges_only = 1;

  opts.merge = 1;

  opts.preserve_ignored = 0; /* FIXME: !overwrite_ignore */

  trees[nr_trees] = parse_tree_indirect(common);

  if (!trees[nr_trees++])

    return -1;

  trees[nr_trees] = parse_tree_indirect(head);

  if (!trees[nr_trees++])

    return -1;

  trees[nr_trees] = parse_tree_indirect(one);

  if (!trees[nr_trees++])

    return -1;

  opts.fn = threeway_merge;

  cache_tree_free(&the_index.cache_tree);

  for (i = 0; i < nr_trees; i++) {

    parse_tree(trees[i]);

    init_tree_desc(t+i, trees[i]->buffer, trees[i]->size);

  }

  if (unpack_trees(nr_trees, t, &opts))

    return -1;

  return 0;

}

static void write_tree_trivial(struct object_id *oid)

{

  if (write_index_as_tree(oid, &the_index, get_index_file(), 0, NULL))

    die(_("git write-tree failed to write a tree"));

}

static int try_merge_strategy(const char *strategy, struct commit_list *common,

            struct commit_list *remoteheads,

            struct commit *head)

{

  const char *head_arg = "HEAD";

  if (repo_refresh_and_write_index(the_repository, REFRESH_QUIET,

           SKIP_IF_UNCHANGED, 0, NULL, NULL,

           NULL) < 0)

    return error(_("Unable to write index."));

  if (!strcmp(strategy, "recursive") || !strcmp(strategy, "subtree") ||

      !strcmp(strategy, "ort")) {

    struct lock_file lock = LOCK_INIT;

    int clean, x;

    struct commit *result;

    struct commit_list *reversed = NULL;

    struct merge_options o;

    struct commit_list *j;

    if (remoteheads->next) {

      error(_("Not handling anything other than two heads merge."));

      return 2;

    }

    init_merge_options(&o, the_repository);

    if (!strcmp(strategy, "subtree"))

      o.subtree_shift = "";

    o.show_rename_progress =

      show_progress == -1 ? isatty(2) : show_progress;

    for (x = 0; x < xopts.nr; x++)

      if (parse_merge_opt(&o, xopts.v[x]))

        die(_("unknown strategy option: -X%s"), xopts.v[x]);

    o.branch1 = head_arg;

    o.branch2 = merge_remote_util(remoteheads->item)->name;

    for (j = common; j; j = j->next)

      commit_list_insert(j->item, &reversed);

    repo_hold_locked_index(the_repository, &lock,

               LOCK_DIE_ON_ERROR);

    if (!strcmp(strategy, "ort"))

      clean = merge_ort_recursive(&o, head, remoteheads->item,

                reversed, &result);

    else

      clean = merge_recursive(&o, head, remoteheads->item,

            reversed, &result);

    if (clean < 0) {

      rollback_lock_file(&lock);

      return 2;

    }

    if (write_locked_index(&the_index, &lock,

               COMMIT_LOCK | SKIP_IF_UNCHANGED))

      die(_("unable to write %s"), get_index_file());

    return clean ? 0 : 1;

  } else {

    return try_merge_command(the_repository,

           strategy, xopts.nr, xopts.v,

           common, head_arg, remoteheads);

  }

}

static void count_diff_files(struct diff_queue_struct *q,

           struct diff_options *opt UNUSED, void *data)

{

  int *count = data;

  (*count) += q->nr;

}

static int count_unmerged_entries(void)

{

  int i, ret = 0;

  for (i = 0; i < the_index.cache_nr; i++)

    if (ce_stage(the_index.cache[i]))

      ret++;

  return ret;

}

static void add_strategies(const char *string, unsigned attr)

{

  int i;

  if (string) {

    struct string_list list = STRING_LIST_INIT_DUP;

    struct string_list_item *item;

    string_list_split(&list, string, ' ', -1);

    for_each_string_list_item(item, &list)

      append_strategy(get_strategy(item->string));

    string_list_clear(&list, 0);

    return;

  }

  for (i = 0; i < ARRAY_SIZE(all_strategy); i++)

    if (all_strategy[i].attr & attr)

      append_strategy(&all_strategy[i]);

}

static void read_merge_msg(struct strbuf *msg)

{

  const char *filename = git_path_merge_msg(the_repository);

  strbuf_reset(msg);

  if (strbuf_read_file(msg, filename, 0) < 0)

    die_errno(_("Could not read from '%s'"), filename);

}

static void write_merge_state(struct commit_list *);

static void abort_commit(struct commit_list *remoteheads, const char *err_msg)

{

  if (err_msg)

    error("%s", err_msg);

  fprintf(stderr,

    _("Not committing merge; use 'git commit' to complete the merge.\n"));

  write_merge_state(remoteheads);

  exit(1);

}

static const char merge_editor_comment[] =

N_("Please enter a commit message to explain why this merge is necessary,\n"

   "especially if it merges an updated upstream into a topic branch.\n"

   "\n");

static const char scissors_editor_comment[] =

N_("An empty message aborts the commit.\n");

static const char no_scissors_editor_comment[] =

N_("Lines starting with '%c' will be ignored, and an empty message aborts\n"

   "the commit.\n");

static void write_merge_heads(struct commit_list *);

static void prepare_to_commit(struct commit_list *remoteheads)

{

  struct strbuf msg = STRBUF_INIT;

  const char *index_file = get_index_file();

  if (!no_verify) {

    int invoked_hook;

    if (run_commit_hook(0 < option_edit, index_file, &invoked_hook,

            "pre-merge-commit", NULL))

      abort_commit(remoteheads, NULL);

    /*

     * Re-read the index as pre-merge-commit hook could have updated it,

     * and write it out as a tree.  We must do this before we invoke

     * the editor and after we invoke run_status above.

     */

    if (invoked_hook)

      discard_index(&the_index);

  }

  read_index_from(&the_index, index_file, get_git_dir());

  strbuf_addbuf(&msg, &merge_msg);

  if (squash)

    BUG("the control must not reach here under --squash");

  if (0 < option_edit) {

    strbuf_addch(&msg, '\n');

    if (cleanup_mode == COMMIT_MSG_CLEANUP_SCISSORS) {

      wt_status_append_cut_line(&msg);

      strbuf_commented_addf(&msg, comment_line_char, "\n");

    }

    strbuf_commented_addf(&msg, comment_line_char,

              _(merge_editor_comment));

    if (cleanup_mode == COMMIT_MSG_CLEANUP_SCISSORS)

      strbuf_commented_addf(&msg, comment_line_char,

                _(scissors_editor_comment));

    else

      strbuf_commented_addf(&msg, comment_line_char,

        _(no_scissors_editor_comment), comment_line_char);

  }

  if (signoff)

    append_signoff(&msg, ignore_non_trailer(msg.buf, msg.len), 0);

  write_merge_heads(remoteheads);

  write_file_buf(git_path_merge_msg(the_repository), msg.buf, msg.len);

  if (run_commit_hook(0 < option_edit, get_index_file(), NULL,

          "prepare-commit-msg",

          git_path_merge_msg(the_repository), "merge", NULL))

    abort_commit(remoteheads, NULL);

  if (0 < option_edit) {

    if (launch_editor(git_path_merge_msg(the_repository), NULL, NULL))

      abort_commit(remoteheads, NULL);

  }