builtin-merge.con commit clone: fix creation of explicitly named target directory (44a68fd)
   1/*
   2 * Builtin "git merge"
   3 *
   4 * Copyright (c) 2008 Miklos Vajna <vmiklos@frugalware.org>
   5 *
   6 * Based on git-merge.sh by Junio C Hamano.
   7 */
   8
   9#include "cache.h"
  10#include "parse-options.h"
  11#include "builtin.h"
  12#include "run-command.h"
  13#include "diff.h"
  14#include "refs.h"
  15#include "commit.h"
  16#include "diffcore.h"
  17#include "revision.h"
  18#include "unpack-trees.h"
  19#include "cache-tree.h"
  20#include "dir.h"
  21#include "utf8.h"
  22#include "log-tree.h"
  23#include "color.h"
  24#include "rerere.h"
  25
  26#define DEFAULT_TWOHEAD (1<<0)
  27#define DEFAULT_OCTOPUS (1<<1)
  28#define NO_FAST_FORWARD (1<<2)
  29#define NO_TRIVIAL      (1<<3)
  30
  31struct strategy {
  32        const char *name;
  33        unsigned attr;
  34};
  35
  36static const char * const builtin_merge_usage[] = {
  37        "git-merge [options] <remote>...",
  38        "git-merge [options] <msg> HEAD <remote>",
  39        NULL
  40};
  41
  42static int show_diffstat = 1, option_log, squash;
  43static int option_commit = 1, allow_fast_forward = 1;
  44static int allow_trivial = 1, have_message;
  45static struct strbuf merge_msg;
  46static struct commit_list *remoteheads;
  47static unsigned char head[20], stash[20];
  48static struct strategy **use_strategies;
  49static size_t use_strategies_nr, use_strategies_alloc;
  50static const char *branch;
  51
  52static struct strategy all_strategy[] = {
  53        { "recursive",  DEFAULT_TWOHEAD | NO_TRIVIAL },
  54        { "octopus",    DEFAULT_OCTOPUS },
  55        { "resolve",    0 },
  56        { "ours",       NO_FAST_FORWARD | NO_TRIVIAL },
  57        { "subtree",    NO_FAST_FORWARD | NO_TRIVIAL },
  58};
  59
  60static const char *pull_twohead, *pull_octopus;
  61
  62static int option_parse_message(const struct option *opt,
  63                                const char *arg, int unset)
  64{
  65        struct strbuf *buf = opt->value;
  66
  67        if (unset)
  68                strbuf_setlen(buf, 0);
  69        else if (arg) {
  70                strbuf_addf(buf, "%s\n\n", arg);
  71                have_message = 1;
  72        } else
  73                return error("switch `m' requires a value");
  74        return 0;
  75}
  76
  77static struct strategy *get_strategy(const char *name)
  78{
  79        int i;
  80        struct strbuf err;
  81
  82        if (!name)
  83                return NULL;
  84
  85        for (i = 0; i < ARRAY_SIZE(all_strategy); i++)
  86                if (!strcmp(name, all_strategy[i].name))
  87                        return &all_strategy[i];
  88
  89        strbuf_init(&err, 0);
  90        for (i = 0; i < ARRAY_SIZE(all_strategy); i++)
  91                strbuf_addf(&err, " %s", all_strategy[i].name);
  92        fprintf(stderr, "Could not find merge strategy '%s'.\n", name);
  93        fprintf(stderr, "Available strategies are:%s.\n", err.buf);
  94        exit(1);
  95}
  96
  97static void append_strategy(struct strategy *s)
  98{
  99        ALLOC_GROW(use_strategies, use_strategies_nr + 1, use_strategies_alloc);
 100        use_strategies[use_strategies_nr++] = s;
 101}
 102
 103static int option_parse_strategy(const struct option *opt,
 104                                 const char *name, int unset)
 105{
 106        if (unset)
 107                return 0;
 108
 109        append_strategy(get_strategy(name));
 110        return 0;
 111}
 112
 113static int option_parse_n(const struct option *opt,
 114                          const char *arg, int unset)
 115{
 116        show_diffstat = unset;
 117        return 0;
 118}
 119
 120static struct option builtin_merge_options[] = {
 121        { OPTION_CALLBACK, 'n', NULL, NULL, NULL,
 122                "do not show a diffstat at the end of the merge",
 123                PARSE_OPT_NOARG, option_parse_n },
 124        OPT_BOOLEAN(0, "stat", &show_diffstat,
 125                "show a diffstat at the end of the merge"),
 126        OPT_BOOLEAN(0, "summary", &show_diffstat, "(synonym to --stat)"),
 127        OPT_BOOLEAN(0, "log", &option_log,
 128                "add list of one-line log to merge commit message"),
 129        OPT_BOOLEAN(0, "squash", &squash,
 130                "create a single commit instead of doing a merge"),
 131        OPT_BOOLEAN(0, "commit", &option_commit,
 132                "perform a commit if the merge succeeds (default)"),
 133        OPT_BOOLEAN(0, "ff", &allow_fast_forward,
 134                "allow fast forward (default)"),
 135        OPT_CALLBACK('s', "strategy", &use_strategies, "strategy",
 136                "merge strategy to use", option_parse_strategy),
 137        OPT_CALLBACK('m', "message", &merge_msg, "message",
 138                "message to be used for the merge commit (if any)",
 139                option_parse_message),
 140        OPT_END()
 141};
 142
 143/* Cleans up metadata that is uninteresting after a succeeded merge. */
 144static void drop_save(void)
 145{
 146        unlink(git_path("MERGE_HEAD"));
 147        unlink(git_path("MERGE_MSG"));
 148}
 149
 150static void save_state(void)
 151{
 152        int len;
 153        struct child_process cp;
 154        struct strbuf buffer = STRBUF_INIT;
 155        const char *argv[] = {"stash", "create", NULL};
 156
 157        memset(&cp, 0, sizeof(cp));
 158        cp.argv = argv;
 159        cp.out = -1;
 160        cp.git_cmd = 1;
 161
 162        if (start_command(&cp))
 163                die("could not run stash.");
 164        len = strbuf_read(&buffer, cp.out, 1024);
 165        close(cp.out);
 166
 167        if (finish_command(&cp) || len < 0)
 168                die("stash failed");
 169        else if (!len)
 170                return;
 171        strbuf_setlen(&buffer, buffer.len-1);
 172        if (get_sha1(buffer.buf, stash))
 173                die("not a valid object: %s", buffer.buf);
 174}
 175
 176static void reset_hard(unsigned const char *sha1, int verbose)
 177{
 178        int i = 0;
 179        const char *args[6];
 180
 181        args[i++] = "read-tree";
 182        if (verbose)
 183                args[i++] = "-v";
 184        args[i++] = "--reset";
 185        args[i++] = "-u";
 186        args[i++] = sha1_to_hex(sha1);
 187        args[i] = NULL;
 188
 189        if (run_command_v_opt(args, RUN_GIT_CMD))
 190                die("read-tree failed");
 191}
 192
 193static void restore_state(void)
 194{
 195        struct strbuf sb;
 196        const char *args[] = { "stash", "apply", NULL, NULL };
 197
 198        if (is_null_sha1(stash))
 199                return;
 200
 201        reset_hard(head, 1);
 202
 203        strbuf_init(&sb, 0);
 204        args[2] = sha1_to_hex(stash);
 205
 206        /*
 207         * It is OK to ignore error here, for example when there was
 208         * nothing to restore.
 209         */
 210        run_command_v_opt(args, RUN_GIT_CMD);
 211
 212        strbuf_release(&sb);
 213        refresh_cache(REFRESH_QUIET);
 214}
 215
 216/* This is called when no merge was necessary. */
 217static void finish_up_to_date(const char *msg)
 218{
 219        printf("%s%s\n", squash ? " (nothing to squash)" : "", msg);
 220        drop_save();
 221}
 222
 223static void squash_message(void)
 224{
 225        struct rev_info rev;
 226        struct commit *commit;
 227        struct strbuf out;
 228        struct commit_list *j;
 229        int fd;
 230
 231        printf("Squash commit -- not updating HEAD\n");
 232        fd = open(git_path("SQUASH_MSG"), O_WRONLY | O_CREAT, 0666);
 233        if (fd < 0)
 234                die("Could not write to %s", git_path("SQUASH_MSG"));
 235
 236        init_revisions(&rev, NULL);
 237        rev.ignore_merges = 1;
 238        rev.commit_format = CMIT_FMT_MEDIUM;
 239
 240        commit = lookup_commit(head);
 241        commit->object.flags |= UNINTERESTING;
 242        add_pending_object(&rev, &commit->object, NULL);
 243
 244        for (j = remoteheads; j; j = j->next)
 245                add_pending_object(&rev, &j->item->object, NULL);
 246
 247        setup_revisions(0, NULL, &rev, NULL);
 248        if (prepare_revision_walk(&rev))
 249                die("revision walk setup failed");
 250
 251        strbuf_init(&out, 0);
 252        strbuf_addstr(&out, "Squashed commit of the following:\n");
 253        while ((commit = get_revision(&rev)) != NULL) {
 254                strbuf_addch(&out, '\n');
 255                strbuf_addf(&out, "commit %s\n",
 256                        sha1_to_hex(commit->object.sha1));
 257                pretty_print_commit(rev.commit_format, commit, &out, rev.abbrev,
 258                        NULL, NULL, rev.date_mode, 0);
 259        }
 260        write(fd, out.buf, out.len);
 261        close(fd);
 262        strbuf_release(&out);
 263}
 264
 265static int run_hook(const char *name)
 266{
 267        struct child_process hook;
 268        const char *argv[3], *env[2];
 269        char index[PATH_MAX];
 270
 271        argv[0] = git_path("hooks/%s", name);
 272        if (access(argv[0], X_OK) < 0)
 273                return 0;
 274
 275        snprintf(index, sizeof(index), "GIT_INDEX_FILE=%s", get_index_file());
 276        env[0] = index;
 277        env[1] = NULL;
 278
 279        if (squash)
 280                argv[1] = "1";
 281        else
 282                argv[1] = "0";
 283        argv[2] = NULL;
 284
 285        memset(&hook, 0, sizeof(hook));
 286        hook.argv = argv;
 287        hook.no_stdin = 1;
 288        hook.stdout_to_stderr = 1;
 289        hook.env = env;
 290
 291        return run_command(&hook);
 292}
 293
 294static void finish(const unsigned char *new_head, const char *msg)
 295{
 296        struct strbuf reflog_message;
 297
 298        strbuf_init(&reflog_message, 0);
 299        if (!msg)
 300                strbuf_addstr(&reflog_message, getenv("GIT_REFLOG_ACTION"));
 301        else {
 302                printf("%s\n", msg);
 303                strbuf_addf(&reflog_message, "%s: %s",
 304                        getenv("GIT_REFLOG_ACTION"), msg);
 305        }
 306        if (squash) {
 307                squash_message();
 308        } else {
 309                if (!merge_msg.len)
 310                        printf("No merge message -- not updating HEAD\n");
 311                else {
 312                        const char *argv_gc_auto[] = { "gc", "--auto", NULL };
 313                        update_ref(reflog_message.buf, "HEAD",
 314                                new_head, head, 0,
 315                                DIE_ON_ERR);
 316                        /*
 317                         * We ignore errors in 'gc --auto', since the
 318                         * user should see them.
 319                         */
 320                        run_command_v_opt(argv_gc_auto, RUN_GIT_CMD);
 321                }
 322        }
 323        if (new_head && show_diffstat) {
 324                struct diff_options opts;
 325                diff_setup(&opts);
 326                opts.output_format |=
 327                        DIFF_FORMAT_SUMMARY | DIFF_FORMAT_DIFFSTAT;
 328                opts.detect_rename = DIFF_DETECT_RENAME;
 329                if (diff_use_color_default > 0)
 330                        DIFF_OPT_SET(&opts, COLOR_DIFF);
 331                if (diff_setup_done(&opts) < 0)
 332                        die("diff_setup_done failed");
 333                diff_tree_sha1(head, new_head, "", &opts);
 334                diffcore_std(&opts);
 335                diff_flush(&opts);
 336        }
 337
 338        /* Run a post-merge hook */
 339        run_hook("post-merge");
 340
 341        strbuf_release(&reflog_message);
 342}
 343
 344/* Get the name for the merge commit's message. */
 345static void merge_name(const char *remote, struct strbuf *msg)
 346{
 347        struct object *remote_head;
 348        unsigned char branch_head[20], buf_sha[20];
 349        struct strbuf buf;
 350        const char *ptr;
 351        int len, early;
 352
 353        memset(branch_head, 0, sizeof(branch_head));
 354        remote_head = peel_to_type(remote, 0, NULL, OBJ_COMMIT);
 355        if (!remote_head)
 356                die("'%s' does not point to a commit", remote);
 357
 358        strbuf_init(&buf, 0);
 359        strbuf_addstr(&buf, "refs/heads/");
 360        strbuf_addstr(&buf, remote);
 361        resolve_ref(buf.buf, branch_head, 0, 0);
 362
 363        if (!hashcmp(remote_head->sha1, branch_head)) {
 364                strbuf_addf(msg, "%s\t\tbranch '%s' of .\n",
 365                        sha1_to_hex(branch_head), remote);
 366                return;
 367        }
 368
 369        /* See if remote matches <name>^^^.. or <name>~<number> */
 370        for (len = 0, ptr = remote + strlen(remote);
 371             remote < ptr && ptr[-1] == '^';
 372             ptr--)
 373                len++;
 374        if (len)
 375                early = 1;
 376        else {
 377                early = 0;
 378                ptr = strrchr(remote, '~');
 379                if (ptr) {
 380                        int seen_nonzero = 0;
 381
 382                        len++; /* count ~ */
 383                        while (*++ptr && isdigit(*ptr)) {
 384                                seen_nonzero |= (*ptr != '0');
 385                                len++;
 386                        }
 387                        if (*ptr)
 388                                len = 0; /* not ...~<number> */
 389                        else if (seen_nonzero)
 390                                early = 1;
 391                        else if (len == 1)
 392                                early = 1; /* "name~" is "name~1"! */
 393                }
 394        }
 395        if (len) {
 396                struct strbuf truname = STRBUF_INIT;
 397                strbuf_addstr(&truname, "refs/heads/");
 398                strbuf_addstr(&truname, remote);
 399                strbuf_setlen(&truname, truname.len - len);
 400                if (resolve_ref(truname.buf, buf_sha, 0, 0)) {
 401                        strbuf_addf(msg,
 402                                    "%s\t\tbranch '%s'%s of .\n",
 403                                    sha1_to_hex(remote_head->sha1),
 404                                    truname.buf + 11,
 405                                    (early ? " (early part)" : ""));
 406                        return;
 407                }
 408        }
 409
 410        if (!strcmp(remote, "FETCH_HEAD") &&
 411                        !access(git_path("FETCH_HEAD"), R_OK)) {
 412                FILE *fp;
 413                struct strbuf line;
 414                char *ptr;
 415
 416                strbuf_init(&line, 0);
 417                fp = fopen(git_path("FETCH_HEAD"), "r");
 418                if (!fp)
 419                        die("could not open %s for reading: %s",
 420                                git_path("FETCH_HEAD"), strerror(errno));
 421                strbuf_getline(&line, fp, '\n');
 422                fclose(fp);
 423                ptr = strstr(line.buf, "\tnot-for-merge\t");
 424                if (ptr)
 425                        strbuf_remove(&line, ptr-line.buf+1, 13);
 426                strbuf_addbuf(msg, &line);
 427                strbuf_release(&line);
 428                return;
 429        }
 430        strbuf_addf(msg, "%s\t\tcommit '%s'\n",
 431                sha1_to_hex(remote_head->sha1), remote);
 432}
 433
 434static int git_merge_config(const char *k, const char *v, void *cb)
 435{
 436        if (branch && !prefixcmp(k, "branch.") &&
 437                !prefixcmp(k + 7, branch) &&
 438                !strcmp(k + 7 + strlen(branch), ".mergeoptions")) {
 439                const char **argv;
 440                int argc;
 441                char *buf;
 442
 443                buf = xstrdup(v);
 444                argc = split_cmdline(buf, &argv);
 445                argv = xrealloc(argv, sizeof(*argv) * (argc + 2));
 446                memmove(argv + 1, argv, sizeof(*argv) * (argc + 1));
 447                argc++;
 448                parse_options(argc, argv, builtin_merge_options,
 449                              builtin_merge_usage, 0);
 450                free(buf);
 451        }
 452
 453        if (!strcmp(k, "merge.diffstat") || !strcmp(k, "merge.stat"))
 454                show_diffstat = git_config_bool(k, v);
 455        else if (!strcmp(k, "pull.twohead"))
 456                return git_config_string(&pull_twohead, k, v);
 457        else if (!strcmp(k, "pull.octopus"))
 458                return git_config_string(&pull_octopus, k, v);
 459        else if (!strcmp(k, "merge.log") || !strcmp(k, "merge.summary"))
 460                option_log = git_config_bool(k, v);
 461        return git_diff_ui_config(k, v, cb);
 462}
 463
 464static int read_tree_trivial(unsigned char *common, unsigned char *head,
 465                             unsigned char *one)
 466{
 467        int i, nr_trees = 0;
 468        struct tree *trees[MAX_UNPACK_TREES];
 469        struct tree_desc t[MAX_UNPACK_TREES];
 470        struct unpack_trees_options opts;
 471
 472        memset(&opts, 0, sizeof(opts));
 473        opts.head_idx = 2;
 474        opts.src_index = &the_index;
 475        opts.dst_index = &the_index;
 476        opts.update = 1;
 477        opts.verbose_update = 1;
 478        opts.trivial_merges_only = 1;
 479        opts.merge = 1;
 480        trees[nr_trees] = parse_tree_indirect(common);
 481        if (!trees[nr_trees++])
 482                return -1;
 483        trees[nr_trees] = parse_tree_indirect(head);
 484        if (!trees[nr_trees++])
 485                return -1;
 486        trees[nr_trees] = parse_tree_indirect(one);
 487        if (!trees[nr_trees++])
 488                return -1;
 489        opts.fn = threeway_merge;
 490        cache_tree_free(&active_cache_tree);
 491        for (i = 0; i < nr_trees; i++) {
 492                parse_tree(trees[i]);
 493                init_tree_desc(t+i, trees[i]->buffer, trees[i]->size);
 494        }
 495        if (unpack_trees(nr_trees, t, &opts))
 496                return -1;
 497        return 0;
 498}
 499
 500static void write_tree_trivial(unsigned char *sha1)
 501{
 502        if (write_cache_as_tree(sha1, 0, NULL))
 503                die("git write-tree failed to write a tree");
 504}
 505
 506static int try_merge_strategy(const char *strategy, struct commit_list *common,
 507                              const char *head_arg)
 508{
 509        const char **args;
 510        int i = 0, ret;
 511        struct commit_list *j;
 512        struct strbuf buf;
 513
 514        args = xmalloc((4 + commit_list_count(common) +
 515                        commit_list_count(remoteheads)) * sizeof(char *));
 516        strbuf_init(&buf, 0);
 517        strbuf_addf(&buf, "merge-%s", strategy);
 518        args[i++] = buf.buf;
 519        for (j = common; j; j = j->next)
 520                args[i++] = xstrdup(sha1_to_hex(j->item->object.sha1));
 521        args[i++] = "--";
 522        args[i++] = head_arg;
 523        for (j = remoteheads; j; j = j->next)
 524                args[i++] = xstrdup(sha1_to_hex(j->item->object.sha1));
 525        args[i] = NULL;
 526        ret = run_command_v_opt(args, RUN_GIT_CMD);
 527        strbuf_release(&buf);
 528        i = 1;
 529        for (j = common; j; j = j->next)
 530                free((void *)args[i++]);
 531        i += 2;
 532        for (j = remoteheads; j; j = j->next)
 533                free((void *)args[i++]);
 534        free(args);
 535        return -ret;
 536}
 537
 538static void count_diff_files(struct diff_queue_struct *q,
 539                             struct diff_options *opt, void *data)
 540{
 541        int *count = data;
 542
 543        (*count) += q->nr;
 544}
 545
 546static int count_unmerged_entries(void)
 547{
 548        const struct index_state *state = &the_index;
 549        int i, ret = 0;
 550
 551        for (i = 0; i < state->cache_nr; i++)
 552                if (ce_stage(state->cache[i]))
 553                        ret++;
 554
 555        return ret;
 556}
 557
 558static int checkout_fast_forward(unsigned char *head, unsigned char *remote)
 559{
 560        struct tree *trees[MAX_UNPACK_TREES];
 561        struct unpack_trees_options opts;
 562        struct tree_desc t[MAX_UNPACK_TREES];
 563        int i, fd, nr_trees = 0;
 564        struct dir_struct dir;
 565        struct lock_file *lock_file = xcalloc(1, sizeof(struct lock_file));
 566
 567        refresh_cache(REFRESH_QUIET);
 568
 569        fd = hold_locked_index(lock_file, 1);
 570
 571        memset(&trees, 0, sizeof(trees));
 572        memset(&opts, 0, sizeof(opts));
 573        memset(&t, 0, sizeof(t));
 574        memset(&dir, 0, sizeof(dir));
 575        dir.show_ignored = 1;
 576        dir.exclude_per_dir = ".gitignore";
 577        opts.dir = &dir;
 578
 579        opts.head_idx = 1;
 580        opts.src_index = &the_index;
 581        opts.dst_index = &the_index;
 582        opts.update = 1;
 583        opts.verbose_update = 1;
 584        opts.merge = 1;
 585        opts.fn = twoway_merge;
 586
 587        trees[nr_trees] = parse_tree_indirect(head);
 588        if (!trees[nr_trees++])
 589                return -1;
 590        trees[nr_trees] = parse_tree_indirect(remote);
 591        if (!trees[nr_trees++])
 592                return -1;
 593        for (i = 0; i < nr_trees; i++) {
 594                parse_tree(trees[i]);
 595                init_tree_desc(t+i, trees[i]->buffer, trees[i]->size);
 596        }
 597        if (unpack_trees(nr_trees, t, &opts))
 598                return -1;
 599        if (write_cache(fd, active_cache, active_nr) ||
 600                commit_locked_index(lock_file))
 601                die("unable to write new index file");
 602        return 0;
 603}
 604
 605static void split_merge_strategies(const char *string, struct strategy **list,
 606                                   int *nr, int *alloc)
 607{
 608        char *p, *q, *buf;
 609
 610        if (!string)
 611                return;
 612
 613        buf = xstrdup(string);
 614        q = buf;
 615        for (;;) {
 616                p = strchr(q, ' ');
 617                if (!p) {
 618                        ALLOC_GROW(*list, *nr + 1, *alloc);
 619                        (*list)[(*nr)++].name = xstrdup(q);
 620                        free(buf);
 621                        return;
 622                } else {
 623                        *p = '\0';
 624                        ALLOC_GROW(*list, *nr + 1, *alloc);
 625                        (*list)[(*nr)++].name = xstrdup(q);
 626                        q = ++p;
 627                }
 628        }
 629}
 630
 631static void add_strategies(const char *string, unsigned attr)
 632{
 633        struct strategy *list = NULL;
 634        int list_alloc = 0, list_nr = 0, i;
 635
 636        memset(&list, 0, sizeof(list));
 637        split_merge_strategies(string, &list, &list_nr, &list_alloc);
 638        if (list) {
 639                for (i = 0; i < list_nr; i++)
 640                        append_strategy(get_strategy(list[i].name));
 641                return;
 642        }
 643        for (i = 0; i < ARRAY_SIZE(all_strategy); i++)
 644                if (all_strategy[i].attr & attr)
 645                        append_strategy(&all_strategy[i]);
 646
 647}
 648
 649static int merge_trivial(void)
 650{
 651        unsigned char result_tree[20], result_commit[20];
 652        struct commit_list *parent = xmalloc(sizeof(struct commit_list *));
 653
 654        write_tree_trivial(result_tree);
 655        printf("Wonderful.\n");
 656        parent->item = lookup_commit(head);
 657        parent->next = xmalloc(sizeof(struct commit_list *));
 658        parent->next->item = remoteheads->item;
 659        parent->next->next = NULL;
 660        commit_tree(merge_msg.buf, result_tree, parent, result_commit);
 661        finish(result_commit, "In-index merge");
 662        drop_save();
 663        return 0;
 664}
 665
 666static int finish_automerge(struct commit_list *common,
 667                            unsigned char *result_tree,
 668                            const char *wt_strategy)
 669{
 670        struct commit_list *parents = NULL, *j;
 671        struct strbuf buf = STRBUF_INIT;
 672        unsigned char result_commit[20];
 673
 674        free_commit_list(common);
 675        if (allow_fast_forward) {
 676                parents = remoteheads;
 677                commit_list_insert(lookup_commit(head), &parents);
 678                parents = reduce_heads(parents);
 679        } else {
 680                struct commit_list **pptr = &parents;
 681
 682                pptr = &commit_list_insert(lookup_commit(head),
 683                                pptr)->next;
 684                for (j = remoteheads; j; j = j->next)
 685                        pptr = &commit_list_insert(j->item, pptr)->next;
 686        }
 687        free_commit_list(remoteheads);
 688        strbuf_addch(&merge_msg, '\n');
 689        commit_tree(merge_msg.buf, result_tree, parents, result_commit);
 690        strbuf_addf(&buf, "Merge made by %s.", wt_strategy);
 691        finish(result_commit, buf.buf);
 692        strbuf_release(&buf);
 693        drop_save();
 694        return 0;
 695}
 696
 697static int suggest_conflicts(void)
 698{
 699        FILE *fp;
 700        int pos;
 701
 702        fp = fopen(git_path("MERGE_MSG"), "a");
 703        if (!fp)
 704                die("Could open %s for writing", git_path("MERGE_MSG"));
 705        fprintf(fp, "\nConflicts:\n");
 706        for (pos = 0; pos < active_nr; pos++) {
 707                struct cache_entry *ce = active_cache[pos];
 708
 709                if (ce_stage(ce)) {
 710                        fprintf(fp, "\t%s\n", ce->name);
 711                        while (pos + 1 < active_nr &&
 712                                        !strcmp(ce->name,
 713                                                active_cache[pos + 1]->name))
 714                                pos++;
 715                }
 716        }
 717        fclose(fp);
 718        rerere();
 719        printf("Automatic merge failed; "
 720                        "fix conflicts and then commit the result.\n");
 721        return 1;
 722}
 723
 724static struct commit *is_old_style_invocation(int argc, const char **argv)
 725{
 726        struct commit *second_token = NULL;
 727        if (argc > 1) {
 728                unsigned char second_sha1[20];
 729
 730                if (get_sha1(argv[1], second_sha1))
 731                        return NULL;
 732                second_token = lookup_commit_reference_gently(second_sha1, 0);
 733                if (!second_token)
 734                        die("'%s' is not a commit", argv[1]);
 735                if (hashcmp(second_token->object.sha1, head))
 736                        return NULL;
 737        }
 738        return second_token;
 739}
 740
 741static int evaluate_result(void)
 742{
 743        int cnt = 0;
 744        struct rev_info rev;
 745
 746        discard_cache();
 747        if (read_cache() < 0)
 748                die("failed to read the cache");
 749
 750        /* Check how many files differ. */
 751        init_revisions(&rev, "");
 752        setup_revisions(0, NULL, &rev, NULL);
 753        rev.diffopt.output_format |=
 754                DIFF_FORMAT_CALLBACK;
 755        rev.diffopt.format_callback = count_diff_files;
 756        rev.diffopt.format_callback_data = &cnt;
 757        run_diff_files(&rev, 0);
 758
 759        /*
 760         * Check how many unmerged entries are
 761         * there.
 762         */
 763        cnt += count_unmerged_entries();
 764
 765        return cnt;
 766}
 767
 768int cmd_merge(int argc, const char **argv, const char *prefix)
 769{
 770        unsigned char result_tree[20];
 771        struct strbuf buf;
 772        const char *head_arg;
 773        int flag, head_invalid = 0, i;
 774        int best_cnt = -1, merge_was_ok = 0, automerge_was_ok = 0;
 775        struct commit_list *common = NULL;
 776        const char *best_strategy = NULL, *wt_strategy = NULL;
 777        struct commit_list **remotes = &remoteheads;
 778
 779        setup_work_tree();
 780        if (read_cache_unmerged())
 781                die("You are in the middle of a conflicted merge.");
 782
 783        /*
 784         * Check if we are _not_ on a detached HEAD, i.e. if there is a
 785         * current branch.
 786         */
 787        branch = resolve_ref("HEAD", head, 0, &flag);
 788        if (branch && !prefixcmp(branch, "refs/heads/"))
 789                branch += 11;
 790        if (is_null_sha1(head))
 791                head_invalid = 1;
 792
 793        git_config(git_merge_config, NULL);
 794
 795        /* for color.ui */
 796        if (diff_use_color_default == -1)
 797                diff_use_color_default = git_use_color_default;
 798
 799        argc = parse_options(argc, argv, builtin_merge_options,
 800                        builtin_merge_usage, 0);
 801
 802        if (squash) {
 803                if (!allow_fast_forward)
 804                        die("You cannot combine --squash with --no-ff.");
 805                option_commit = 0;
 806        }
 807
 808        if (!argc)
 809                usage_with_options(builtin_merge_usage,
 810                        builtin_merge_options);
 811
 812        /*
 813         * This could be traditional "merge <msg> HEAD <commit>..."  and
 814         * the way we can tell it is to see if the second token is HEAD,
 815         * but some people might have misused the interface and used a
 816         * committish that is the same as HEAD there instead.
 817         * Traditional format never would have "-m" so it is an
 818         * additional safety measure to check for it.
 819         */
 820        strbuf_init(&buf, 0);
 821
 822        if (!have_message && is_old_style_invocation(argc, argv)) {
 823                strbuf_addstr(&merge_msg, argv[0]);
 824                head_arg = argv[1];
 825                argv += 2;
 826                argc -= 2;
 827        } else if (head_invalid) {
 828                struct object *remote_head;
 829                /*
 830                 * If the merged head is a valid one there is no reason
 831                 * to forbid "git merge" into a branch yet to be born.
 832                 * We do the same for "git pull".
 833                 */
 834                if (argc != 1)
 835                        die("Can merge only exactly one commit into "
 836                                "empty head");
 837                remote_head = peel_to_type(argv[0], 0, NULL, OBJ_COMMIT);
 838                if (!remote_head)
 839                        die("%s - not something we can merge", argv[0]);
 840                update_ref("initial pull", "HEAD", remote_head->sha1, NULL, 0,
 841                                DIE_ON_ERR);
 842                reset_hard(remote_head->sha1, 0);
 843                return 0;
 844        } else {
 845                struct strbuf msg;
 846
 847                /* We are invoked directly as the first-class UI. */
 848                head_arg = "HEAD";
 849
 850                /*
 851                 * All the rest are the commits being merged;
 852                 * prepare the standard merge summary message to
 853                 * be appended to the given message.  If remote
 854                 * is invalid we will die later in the common
 855                 * codepath so we discard the error in this
 856                 * loop.
 857                 */
 858                strbuf_init(&msg, 0);
 859                for (i = 0; i < argc; i++)
 860                        merge_name(argv[i], &msg);
 861                fmt_merge_msg(option_log, &msg, &merge_msg);
 862                if (merge_msg.len)
 863                        strbuf_setlen(&merge_msg, merge_msg.len-1);
 864        }
 865
 866        if (head_invalid || !argc)
 867                usage_with_options(builtin_merge_usage,
 868                        builtin_merge_options);
 869
 870        strbuf_addstr(&buf, "merge");
 871        for (i = 0; i < argc; i++)
 872                strbuf_addf(&buf, " %s", argv[i]);
 873        setenv("GIT_REFLOG_ACTION", buf.buf, 0);
 874        strbuf_reset(&buf);
 875
 876        for (i = 0; i < argc; i++) {
 877                struct object *o;
 878
 879                o = peel_to_type(argv[i], 0, NULL, OBJ_COMMIT);
 880                if (!o)
 881                        die("%s - not something we can merge", argv[i]);
 882                remotes = &commit_list_insert(lookup_commit(o->sha1),
 883                        remotes)->next;
 884
 885                strbuf_addf(&buf, "GITHEAD_%s", sha1_to_hex(o->sha1));
 886                setenv(buf.buf, argv[i], 1);
 887                strbuf_reset(&buf);
 888        }
 889
 890        if (!use_strategies) {
 891                if (!remoteheads->next)
 892                        add_strategies(pull_twohead, DEFAULT_TWOHEAD);
 893                else
 894                        add_strategies(pull_octopus, DEFAULT_OCTOPUS);
 895        }
 896
 897        for (i = 0; i < use_strategies_nr; i++) {
 898                if (use_strategies[i]->attr & NO_FAST_FORWARD)
 899                        allow_fast_forward = 0;
 900                if (use_strategies[i]->attr & NO_TRIVIAL)
 901                        allow_trivial = 0;
 902        }
 903
 904        if (!remoteheads->next)
 905                common = get_merge_bases(lookup_commit(head),
 906                                remoteheads->item, 1);
 907        else {
 908                struct commit_list *list = remoteheads;
 909                commit_list_insert(lookup_commit(head), &list);
 910                common = get_octopus_merge_bases(list);
 911                free(list);
 912        }
 913
 914        update_ref("updating ORIG_HEAD", "ORIG_HEAD", head, NULL, 0,
 915                DIE_ON_ERR);
 916
 917        if (!common)
 918                ; /* No common ancestors found. We need a real merge. */
 919        else if (!remoteheads->next && !common->next &&
 920                        common->item == remoteheads->item) {
 921                /*
 922                 * If head can reach all the merge then we are up to date.
 923                 * but first the most common case of merging one remote.
 924                 */
 925                finish_up_to_date("Already up-to-date.");
 926                return 0;
 927        } else if (allow_fast_forward && !remoteheads->next &&
 928                        !common->next &&
 929                        !hashcmp(common->item->object.sha1, head)) {
 930                /* Again the most common case of merging one remote. */
 931                struct strbuf msg;
 932                struct object *o;
 933                char hex[41];
 934
 935                strcpy(hex, find_unique_abbrev(head, DEFAULT_ABBREV));
 936
 937                printf("Updating %s..%s\n",
 938                        hex,
 939                        find_unique_abbrev(remoteheads->item->object.sha1,
 940                        DEFAULT_ABBREV));
 941                strbuf_init(&msg, 0);
 942                strbuf_addstr(&msg, "Fast forward");
 943                if (have_message)
 944                        strbuf_addstr(&msg,
 945                                " (no commit created; -m option ignored)");
 946                o = peel_to_type(sha1_to_hex(remoteheads->item->object.sha1),
 947                        0, NULL, OBJ_COMMIT);
 948                if (!o)
 949                        return 1;
 950
 951                if (checkout_fast_forward(head, remoteheads->item->object.sha1))
 952                        return 1;
 953
 954                finish(o->sha1, msg.buf);
 955                drop_save();
 956                return 0;
 957        } else if (!remoteheads->next && common->next)
 958                ;
 959                /*
 960                 * We are not doing octopus and not fast forward.  Need
 961                 * a real merge.
 962                 */
 963        else if (!remoteheads->next && !common->next && option_commit) {
 964                /*
 965                 * We are not doing octopus, not fast forward, and have
 966                 * only one common.
 967                 */
 968                refresh_cache(REFRESH_QUIET);
 969                if (allow_trivial) {
 970                        /* See if it is really trivial. */
 971                        git_committer_info(IDENT_ERROR_ON_NO_NAME);
 972                        printf("Trying really trivial in-index merge...\n");
 973                        if (!read_tree_trivial(common->item->object.sha1,
 974                                        head, remoteheads->item->object.sha1))
 975                                return merge_trivial();
 976                        printf("Nope.\n");
 977                }
 978        } else {
 979                /*
 980                 * An octopus.  If we can reach all the remote we are up
 981                 * to date.
 982                 */
 983                int up_to_date = 1;
 984                struct commit_list *j;
 985
 986                for (j = remoteheads; j; j = j->next) {
 987                        struct commit_list *common_one;
 988
 989                        /*
 990                         * Here we *have* to calculate the individual
 991                         * merge_bases again, otherwise "git merge HEAD^
 992                         * HEAD^^" would be missed.
 993                         */
 994                        common_one = get_merge_bases(lookup_commit(head),
 995                                j->item, 1);
 996                        if (hashcmp(common_one->item->object.sha1,
 997                                j->item->object.sha1)) {
 998                                up_to_date = 0;
 999                                break;
1000                        }
1001                }
1002                if (up_to_date) {
1003                        finish_up_to_date("Already up-to-date. Yeeah!");
1004                        return 0;
1005                }
1006        }
1007
1008        /* We are going to make a new commit. */
1009        git_committer_info(IDENT_ERROR_ON_NO_NAME);
1010
1011        /*
1012         * At this point, we need a real merge.  No matter what strategy
1013         * we use, it would operate on the index, possibly affecting the
1014         * working tree, and when resolved cleanly, have the desired
1015         * tree in the index -- this means that the index must be in
1016         * sync with the head commit.  The strategies are responsible
1017         * to ensure this.
1018         */
1019        if (use_strategies_nr != 1) {
1020                /*
1021                 * Stash away the local changes so that we can try more
1022                 * than one.
1023                 */
1024                save_state();
1025        } else {
1026                memcpy(stash, null_sha1, 20);
1027        }
1028
1029        for (i = 0; i < use_strategies_nr; i++) {
1030                int ret;
1031                if (i) {
1032                        printf("Rewinding the tree to pristine...\n");
1033                        restore_state();
1034                }
1035                if (use_strategies_nr != 1)
1036                        printf("Trying merge strategy %s...\n",
1037                                use_strategies[i]->name);
1038                /*
1039                 * Remember which strategy left the state in the working
1040                 * tree.
1041                 */
1042                wt_strategy = use_strategies[i]->name;
1043
1044                ret = try_merge_strategy(use_strategies[i]->name,
1045                        common, head_arg);
1046                if (!option_commit && !ret) {
1047                        merge_was_ok = 1;
1048                        /*
1049                         * This is necessary here just to avoid writing
1050                         * the tree, but later we will *not* exit with
1051                         * status code 1 because merge_was_ok is set.
1052                         */
1053                        ret = 1;
1054                }
1055
1056                if (ret) {
1057                        /*
1058                         * The backend exits with 1 when conflicts are
1059                         * left to be resolved, with 2 when it does not
1060                         * handle the given merge at all.
1061                         */
1062                        if (ret == 1) {
1063                                int cnt = evaluate_result();
1064
1065                                if (best_cnt <= 0 || cnt <= best_cnt) {
1066                                        best_strategy = use_strategies[i]->name;
1067                                        best_cnt = cnt;
1068                                }
1069                        }
1070                        if (merge_was_ok)
1071                                break;
1072                        else
1073                                continue;
1074                }
1075
1076                /* Automerge succeeded. */
1077                discard_cache();
1078                write_tree_trivial(result_tree);
1079                automerge_was_ok = 1;
1080                break;
1081        }
1082
1083        /*
1084         * If we have a resulting tree, that means the strategy module
1085         * auto resolved the merge cleanly.
1086         */
1087        if (automerge_was_ok)
1088                return finish_automerge(common, result_tree, wt_strategy);
1089
1090        /*
1091         * Pick the result from the best strategy and have the user fix
1092         * it up.
1093         */
1094        if (!best_strategy) {
1095                restore_state();
1096                if (use_strategies_nr > 1)
1097                        fprintf(stderr,
1098                                "No merge strategy handled the merge.\n");
1099                else
1100                        fprintf(stderr, "Merge with strategy %s failed.\n",
1101                                use_strategies[0]->name);
1102                return 2;
1103        } else if (best_strategy == wt_strategy)
1104                ; /* We already have its result in the working tree. */
1105        else {
1106                printf("Rewinding the tree to pristine...\n");
1107                restore_state();
1108                printf("Using the %s to prepare resolving by hand.\n",
1109                        best_strategy);
1110                try_merge_strategy(best_strategy, common, head_arg);
1111        }
1112
1113        if (squash)
1114                finish(NULL, NULL);
1115        else {
1116                int fd;
1117                struct commit_list *j;
1118
1119                for (j = remoteheads; j; j = j->next)
1120                        strbuf_addf(&buf, "%s\n",
1121                                sha1_to_hex(j->item->object.sha1));
1122                fd = open(git_path("MERGE_HEAD"), O_WRONLY | O_CREAT, 0666);
1123                if (fd < 0)
1124                        die("Could open %s for writing",
1125                                git_path("MERGE_HEAD"));
1126                if (write_in_full(fd, buf.buf, buf.len) != buf.len)
1127                        die("Could not write to %s", git_path("MERGE_HEAD"));
1128                close(fd);
1129                strbuf_addch(&merge_msg, '\n');
1130                fd = open(git_path("MERGE_MSG"), O_WRONLY | O_CREAT, 0666);
1131                if (fd < 0)
1132                        die("Could open %s for writing", git_path("MERGE_MSG"));
1133                if (write_in_full(fd, merge_msg.buf, merge_msg.len) !=
1134                        merge_msg.len)
1135                        die("Could not write to %s", git_path("MERGE_MSG"));
1136                close(fd);
1137        }
1138
1139        if (merge_was_ok) {
1140                fprintf(stderr, "Automatic merge went well; "
1141                        "stopped before committing as requested\n");
1142                return 0;
1143        } else
1144                return suggest_conflicts();
1145}