merge-recursive.con commit Merge branch 'js/nedmalloc-gcc6-warnings' (ffdcac4)
   1/*
   2 * Recursive Merge algorithm stolen from git-merge-recursive.py by
   3 * Fredrik Kuivinen.
   4 * The thieves were Alex Riesen and Johannes Schindelin, in June/July 2006
   5 */
   6#include "cache.h"
   7#include "advice.h"
   8#include "lockfile.h"
   9#include "cache-tree.h"
  10#include "commit.h"
  11#include "blob.h"
  12#include "builtin.h"
  13#include "tree-walk.h"
  14#include "diff.h"
  15#include "diffcore.h"
  16#include "tag.h"
  17#include "unpack-trees.h"
  18#include "string-list.h"
  19#include "xdiff-interface.h"
  20#include "ll-merge.h"
  21#include "attr.h"
  22#include "merge-recursive.h"
  23#include "dir.h"
  24#include "submodule.h"
  25
  26static struct tree *shift_tree_object(struct tree *one, struct tree *two,
  27                                      const char *subtree_shift)
  28{
  29        struct object_id shifted;
  30
  31        if (!*subtree_shift) {
  32                shift_tree(&one->object.oid, &two->object.oid, &shifted, 0);
  33        } else {
  34                shift_tree_by(&one->object.oid, &two->object.oid, &shifted,
  35                              subtree_shift);
  36        }
  37        if (!oidcmp(&two->object.oid, &shifted))
  38                return two;
  39        return lookup_tree(shifted.hash);
  40}
  41
  42static struct commit *make_virtual_commit(struct tree *tree, const char *comment)
  43{
  44        struct commit *commit = alloc_commit_node();
  45        struct merge_remote_desc *desc = xmalloc(sizeof(*desc));
  46
  47        desc->name = comment;
  48        desc->obj = (struct object *)commit;
  49        commit->tree = tree;
  50        commit->util = desc;
  51        commit->object.parsed = 1;
  52        return commit;
  53}
  54
  55/*
  56 * Since we use get_tree_entry(), which does not put the read object into
  57 * the object pool, we cannot rely on a == b.
  58 */
  59static int oid_eq(const struct object_id *a, const struct object_id *b)
  60{
  61        if (!a && !b)
  62                return 2;
  63        return a && b && oidcmp(a, b) == 0;
  64}
  65
  66enum rename_type {
  67        RENAME_NORMAL = 0,
  68        RENAME_DELETE,
  69        RENAME_ONE_FILE_TO_ONE,
  70        RENAME_ONE_FILE_TO_TWO,
  71        RENAME_TWO_FILES_TO_ONE
  72};
  73
  74struct rename_conflict_info {
  75        enum rename_type rename_type;
  76        struct diff_filepair *pair1;
  77        struct diff_filepair *pair2;
  78        const char *branch1;
  79        const char *branch2;
  80        struct stage_data *dst_entry1;
  81        struct stage_data *dst_entry2;
  82        struct diff_filespec ren1_other;
  83        struct diff_filespec ren2_other;
  84};
  85
  86/*
  87 * Since we want to write the index eventually, we cannot reuse the index
  88 * for these (temporary) data.
  89 */
  90struct stage_data {
  91        struct {
  92                unsigned mode;
  93                struct object_id oid;
  94        } stages[4];
  95        struct rename_conflict_info *rename_conflict_info;
  96        unsigned processed:1;
  97};
  98
  99static inline void setup_rename_conflict_info(enum rename_type rename_type,
 100                                              struct diff_filepair *pair1,
 101                                              struct diff_filepair *pair2,
 102                                              const char *branch1,
 103                                              const char *branch2,
 104                                              struct stage_data *dst_entry1,
 105                                              struct stage_data *dst_entry2,
 106                                              struct merge_options *o,
 107                                              struct stage_data *src_entry1,
 108                                              struct stage_data *src_entry2)
 109{
 110        struct rename_conflict_info *ci = xcalloc(1, sizeof(struct rename_conflict_info));
 111        ci->rename_type = rename_type;
 112        ci->pair1 = pair1;
 113        ci->branch1 = branch1;
 114        ci->branch2 = branch2;
 115
 116        ci->dst_entry1 = dst_entry1;
 117        dst_entry1->rename_conflict_info = ci;
 118        dst_entry1->processed = 0;
 119
 120        assert(!pair2 == !dst_entry2);
 121        if (dst_entry2) {
 122                ci->dst_entry2 = dst_entry2;
 123                ci->pair2 = pair2;
 124                dst_entry2->rename_conflict_info = ci;
 125        }
 126
 127        if (rename_type == RENAME_TWO_FILES_TO_ONE) {
 128                /*
 129                 * For each rename, there could have been
 130                 * modifications on the side of history where that
 131                 * file was not renamed.
 132                 */
 133                int ostage1 = o->branch1 == branch1 ? 3 : 2;
 134                int ostage2 = ostage1 ^ 1;
 135
 136                ci->ren1_other.path = pair1->one->path;
 137                oidcpy(&ci->ren1_other.oid, &src_entry1->stages[ostage1].oid);
 138                ci->ren1_other.mode = src_entry1->stages[ostage1].mode;
 139
 140                ci->ren2_other.path = pair2->one->path;
 141                oidcpy(&ci->ren2_other.oid, &src_entry2->stages[ostage2].oid);
 142                ci->ren2_other.mode = src_entry2->stages[ostage2].mode;
 143        }
 144}
 145
 146static int show(struct merge_options *o, int v)
 147{
 148        return (!o->call_depth && o->verbosity >= v) || o->verbosity >= 5;
 149}
 150
 151static void flush_output(struct merge_options *o)
 152{
 153        if (o->obuf.len) {
 154                fputs(o->obuf.buf, stdout);
 155                strbuf_reset(&o->obuf);
 156        }
 157}
 158
 159__attribute__((format (printf, 3, 4)))
 160static void output(struct merge_options *o, int v, const char *fmt, ...)
 161{
 162        va_list ap;
 163
 164        if (!show(o, v))
 165                return;
 166
 167        strbuf_addchars(&o->obuf, ' ', o->call_depth * 2);
 168
 169        va_start(ap, fmt);
 170        strbuf_vaddf(&o->obuf, fmt, ap);
 171        va_end(ap);
 172
 173        strbuf_addch(&o->obuf, '\n');
 174        if (!o->buffer_output)
 175                flush_output(o);
 176}
 177
 178static void output_commit_title(struct merge_options *o, struct commit *commit)
 179{
 180        int i;
 181        flush_output(o);
 182        for (i = o->call_depth; i--;)
 183                fputs("  ", stdout);
 184        if (commit->util)
 185                printf("virtual %s\n", merge_remote_util(commit)->name);
 186        else {
 187                printf("%s ", find_unique_abbrev(commit->object.oid.hash, DEFAULT_ABBREV));
 188                if (parse_commit(commit) != 0)
 189                        printf(_("(bad commit)\n"));
 190                else {
 191                        const char *title;
 192                        const char *msg = get_commit_buffer(commit, NULL);
 193                        int len = find_commit_subject(msg, &title);
 194                        if (len)
 195                                printf("%.*s\n", len, title);
 196                        unuse_commit_buffer(commit, msg);
 197                }
 198        }
 199}
 200
 201static int add_cacheinfo(unsigned int mode, const struct object_id *oid,
 202                const char *path, int stage, int refresh, int options)
 203{
 204        struct cache_entry *ce;
 205        int ret;
 206
 207        ce = make_cache_entry(mode, oid ? oid->hash : null_sha1, path, stage, 0);
 208        if (!ce)
 209                return error(_("addinfo_cache failed for path '%s'"), path);
 210
 211        ret = add_cache_entry(ce, options);
 212        if (refresh) {
 213                struct cache_entry *nce;
 214
 215                nce = refresh_cache_entry(ce, CE_MATCH_REFRESH | CE_MATCH_IGNORE_MISSING);
 216                if (nce != ce)
 217                        ret = add_cache_entry(nce, options);
 218        }
 219        return ret;
 220}
 221
 222static void init_tree_desc_from_tree(struct tree_desc *desc, struct tree *tree)
 223{
 224        parse_tree(tree);
 225        init_tree_desc(desc, tree->buffer, tree->size);
 226}
 227
 228static int git_merge_trees(int index_only,
 229                           struct tree *common,
 230                           struct tree *head,
 231                           struct tree *merge)
 232{
 233        int rc;
 234        struct tree_desc t[3];
 235        struct unpack_trees_options opts;
 236
 237        memset(&opts, 0, sizeof(opts));
 238        if (index_only)
 239                opts.index_only = 1;
 240        else
 241                opts.update = 1;
 242        opts.merge = 1;
 243        opts.head_idx = 2;
 244        opts.fn = threeway_merge;
 245        opts.src_index = &the_index;
 246        opts.dst_index = &the_index;
 247        setup_unpack_trees_porcelain(&opts, "merge");
 248
 249        init_tree_desc_from_tree(t+0, common);
 250        init_tree_desc_from_tree(t+1, head);
 251        init_tree_desc_from_tree(t+2, merge);
 252
 253        rc = unpack_trees(3, t, &opts);
 254        cache_tree_free(&active_cache_tree);
 255        return rc;
 256}
 257
 258struct tree *write_tree_from_memory(struct merge_options *o)
 259{
 260        struct tree *result = NULL;
 261
 262        if (unmerged_cache()) {
 263                int i;
 264                fprintf(stderr, "BUG: There are unmerged index entries:\n");
 265                for (i = 0; i < active_nr; i++) {
 266                        const struct cache_entry *ce = active_cache[i];
 267                        if (ce_stage(ce))
 268                                fprintf(stderr, "BUG: %d %.*s\n", ce_stage(ce),
 269                                        (int)ce_namelen(ce), ce->name);
 270                }
 271                die("Bug in merge-recursive.c");
 272        }
 273
 274        if (!active_cache_tree)
 275                active_cache_tree = cache_tree();
 276
 277        if (!cache_tree_fully_valid(active_cache_tree) &&
 278            cache_tree_update(&the_index, 0) < 0)
 279                die(_("error building trees"));
 280
 281        result = lookup_tree(active_cache_tree->sha1);
 282
 283        return result;
 284}
 285
 286static int save_files_dirs(const unsigned char *sha1,
 287                struct strbuf *base, const char *path,
 288                unsigned int mode, int stage, void *context)
 289{
 290        int baselen = base->len;
 291        struct merge_options *o = context;
 292
 293        strbuf_addstr(base, path);
 294
 295        if (S_ISDIR(mode))
 296                string_list_insert(&o->current_directory_set, base->buf);
 297        else
 298                string_list_insert(&o->current_file_set, base->buf);
 299
 300        strbuf_setlen(base, baselen);
 301        return (S_ISDIR(mode) ? READ_TREE_RECURSIVE : 0);
 302}
 303
 304static int get_files_dirs(struct merge_options *o, struct tree *tree)
 305{
 306        int n;
 307        struct pathspec match_all;
 308        memset(&match_all, 0, sizeof(match_all));
 309        if (read_tree_recursive(tree, "", 0, 0, &match_all, save_files_dirs, o))
 310                return 0;
 311        n = o->current_file_set.nr + o->current_directory_set.nr;
 312        return n;
 313}
 314
 315/*
 316 * Returns an index_entry instance which doesn't have to correspond to
 317 * a real cache entry in Git's index.
 318 */
 319static struct stage_data *insert_stage_data(const char *path,
 320                struct tree *o, struct tree *a, struct tree *b,
 321                struct string_list *entries)
 322{
 323        struct string_list_item *item;
 324        struct stage_data *e = xcalloc(1, sizeof(struct stage_data));
 325        get_tree_entry(o->object.oid.hash, path,
 326                        e->stages[1].oid.hash, &e->stages[1].mode);
 327        get_tree_entry(a->object.oid.hash, path,
 328                        e->stages[2].oid.hash, &e->stages[2].mode);
 329        get_tree_entry(b->object.oid.hash, path,
 330                        e->stages[3].oid.hash, &e->stages[3].mode);
 331        item = string_list_insert(entries, path);
 332        item->util = e;
 333        return e;
 334}
 335
 336/*
 337 * Create a dictionary mapping file names to stage_data objects. The
 338 * dictionary contains one entry for every path with a non-zero stage entry.
 339 */
 340static struct string_list *get_unmerged(void)
 341{
 342        struct string_list *unmerged = xcalloc(1, sizeof(struct string_list));
 343        int i;
 344
 345        unmerged->strdup_strings = 1;
 346
 347        for (i = 0; i < active_nr; i++) {
 348                struct string_list_item *item;
 349                struct stage_data *e;
 350                const struct cache_entry *ce = active_cache[i];
 351                if (!ce_stage(ce))
 352                        continue;
 353
 354                item = string_list_lookup(unmerged, ce->name);
 355                if (!item) {
 356                        item = string_list_insert(unmerged, ce->name);
 357                        item->util = xcalloc(1, sizeof(struct stage_data));
 358                }
 359                e = item->util;
 360                e->stages[ce_stage(ce)].mode = ce->ce_mode;
 361                hashcpy(e->stages[ce_stage(ce)].oid.hash, ce->sha1);
 362        }
 363
 364        return unmerged;
 365}
 366
 367static int string_list_df_name_compare(const void *a, const void *b)
 368{
 369        const struct string_list_item *one = a;
 370        const struct string_list_item *two = b;
 371        int onelen = strlen(one->string);
 372        int twolen = strlen(two->string);
 373        /*
 374         * Here we only care that entries for D/F conflicts are
 375         * adjacent, in particular with the file of the D/F conflict
 376         * appearing before files below the corresponding directory.
 377         * The order of the rest of the list is irrelevant for us.
 378         *
 379         * To achieve this, we sort with df_name_compare and provide
 380         * the mode S_IFDIR so that D/F conflicts will sort correctly.
 381         * We use the mode S_IFDIR for everything else for simplicity,
 382         * since in other cases any changes in their order due to
 383         * sorting cause no problems for us.
 384         */
 385        int cmp = df_name_compare(one->string, onelen, S_IFDIR,
 386                                  two->string, twolen, S_IFDIR);
 387        /*
 388         * Now that 'foo' and 'foo/bar' compare equal, we have to make sure
 389         * that 'foo' comes before 'foo/bar'.
 390         */
 391        if (cmp)
 392                return cmp;
 393        return onelen - twolen;
 394}
 395
 396static void record_df_conflict_files(struct merge_options *o,
 397                                     struct string_list *entries)
 398{
 399        /* If there is a D/F conflict and the file for such a conflict
 400         * currently exist in the working tree, we want to allow it to be
 401         * removed to make room for the corresponding directory if needed.
 402         * The files underneath the directories of such D/F conflicts will
 403         * be processed before the corresponding file involved in the D/F
 404         * conflict.  If the D/F directory ends up being removed by the
 405         * merge, then we won't have to touch the D/F file.  If the D/F
 406         * directory needs to be written to the working copy, then the D/F
 407         * file will simply be removed (in make_room_for_path()) to make
 408         * room for the necessary paths.  Note that if both the directory
 409         * and the file need to be present, then the D/F file will be
 410         * reinstated with a new unique name at the time it is processed.
 411         */
 412        struct string_list df_sorted_entries;
 413        const char *last_file = NULL;
 414        int last_len = 0;
 415        int i;
 416
 417        /*
 418         * If we're merging merge-bases, we don't want to bother with
 419         * any working directory changes.
 420         */
 421        if (o->call_depth)
 422                return;
 423
 424        /* Ensure D/F conflicts are adjacent in the entries list. */
 425        memset(&df_sorted_entries, 0, sizeof(struct string_list));
 426        for (i = 0; i < entries->nr; i++) {
 427                struct string_list_item *next = &entries->items[i];
 428                string_list_append(&df_sorted_entries, next->string)->util =
 429                                   next->util;
 430        }
 431        qsort(df_sorted_entries.items, entries->nr, sizeof(*entries->items),
 432              string_list_df_name_compare);
 433
 434        string_list_clear(&o->df_conflict_file_set, 1);
 435        for (i = 0; i < df_sorted_entries.nr; i++) {
 436                const char *path = df_sorted_entries.items[i].string;
 437                int len = strlen(path);
 438                struct stage_data *e = df_sorted_entries.items[i].util;
 439
 440                /*
 441                 * Check if last_file & path correspond to a D/F conflict;
 442                 * i.e. whether path is last_file+'/'+<something>.
 443                 * If so, record that it's okay to remove last_file to make
 444                 * room for path and friends if needed.
 445                 */
 446                if (last_file &&
 447                    len > last_len &&
 448                    memcmp(path, last_file, last_len) == 0 &&
 449                    path[last_len] == '/') {
 450                        string_list_insert(&o->df_conflict_file_set, last_file);
 451                }
 452
 453                /*
 454                 * Determine whether path could exist as a file in the
 455                 * working directory as a possible D/F conflict.  This
 456                 * will only occur when it exists in stage 2 as a
 457                 * file.
 458                 */
 459                if (S_ISREG(e->stages[2].mode) || S_ISLNK(e->stages[2].mode)) {
 460                        last_file = path;
 461                        last_len = len;
 462                } else {
 463                        last_file = NULL;
 464                }
 465        }
 466        string_list_clear(&df_sorted_entries, 0);
 467}
 468
 469struct rename {
 470        struct diff_filepair *pair;
 471        struct stage_data *src_entry;
 472        struct stage_data *dst_entry;
 473        unsigned processed:1;
 474};
 475
 476/*
 477 * Get information of all renames which occurred between 'o_tree' and
 478 * 'tree'. We need the three trees in the merge ('o_tree', 'a_tree' and
 479 * 'b_tree') to be able to associate the correct cache entries with
 480 * the rename information. 'tree' is always equal to either a_tree or b_tree.
 481 */
 482static struct string_list *get_renames(struct merge_options *o,
 483                                       struct tree *tree,
 484                                       struct tree *o_tree,
 485                                       struct tree *a_tree,
 486                                       struct tree *b_tree,
 487                                       struct string_list *entries)
 488{
 489        int i;
 490        struct string_list *renames;
 491        struct diff_options opts;
 492
 493        renames = xcalloc(1, sizeof(struct string_list));
 494        if (!o->detect_rename)
 495                return renames;
 496
 497        diff_setup(&opts);
 498        DIFF_OPT_SET(&opts, RECURSIVE);
 499        DIFF_OPT_CLR(&opts, RENAME_EMPTY);
 500        opts.detect_rename = DIFF_DETECT_RENAME;
 501        opts.rename_limit = o->merge_rename_limit >= 0 ? o->merge_rename_limit :
 502                            o->diff_rename_limit >= 0 ? o->diff_rename_limit :
 503                            1000;
 504        opts.rename_score = o->rename_score;
 505        opts.show_rename_progress = o->show_rename_progress;
 506        opts.output_format = DIFF_FORMAT_NO_OUTPUT;
 507        diff_setup_done(&opts);
 508        diff_tree_sha1(o_tree->object.oid.hash, tree->object.oid.hash, "", &opts);
 509        diffcore_std(&opts);
 510        if (opts.needed_rename_limit > o->needed_rename_limit)
 511                o->needed_rename_limit = opts.needed_rename_limit;
 512        for (i = 0; i < diff_queued_diff.nr; ++i) {
 513                struct string_list_item *item;
 514                struct rename *re;
 515                struct diff_filepair *pair = diff_queued_diff.queue[i];
 516                if (pair->status != 'R') {
 517                        diff_free_filepair(pair);
 518                        continue;
 519                }
 520                re = xmalloc(sizeof(*re));
 521                re->processed = 0;
 522                re->pair = pair;
 523                item = string_list_lookup(entries, re->pair->one->path);
 524                if (!item)
 525                        re->src_entry = insert_stage_data(re->pair->one->path,
 526                                        o_tree, a_tree, b_tree, entries);
 527                else
 528                        re->src_entry = item->util;
 529
 530                item = string_list_lookup(entries, re->pair->two->path);
 531                if (!item)
 532                        re->dst_entry = insert_stage_data(re->pair->two->path,
 533                                        o_tree, a_tree, b_tree, entries);
 534                else
 535                        re->dst_entry = item->util;
 536                item = string_list_insert(renames, pair->one->path);
 537                item->util = re;
 538        }
 539        opts.output_format = DIFF_FORMAT_NO_OUTPUT;
 540        diff_queued_diff.nr = 0;
 541        diff_flush(&opts);
 542        return renames;
 543}
 544
 545static int update_stages(const char *path, const struct diff_filespec *o,
 546                         const struct diff_filespec *a,
 547                         const struct diff_filespec *b)
 548{
 549
 550        /*
 551         * NOTE: It is usually a bad idea to call update_stages on a path
 552         * before calling update_file on that same path, since it can
 553         * sometimes lead to spurious "refusing to lose untracked file..."
 554         * messages from update_file (via make_room_for path via
 555         * would_lose_untracked).  Instead, reverse the order of the calls
 556         * (executing update_file first and then update_stages).
 557         */
 558        int clear = 1;
 559        int options = ADD_CACHE_OK_TO_ADD | ADD_CACHE_SKIP_DFCHECK;
 560        if (clear)
 561                if (remove_file_from_cache(path))
 562                        return -1;
 563        if (o)
 564                if (add_cacheinfo(o->mode, &o->oid, path, 1, 0, options))
 565                        return -1;
 566        if (a)
 567                if (add_cacheinfo(a->mode, &a->oid, path, 2, 0, options))
 568                        return -1;
 569        if (b)
 570                if (add_cacheinfo(b->mode, &b->oid, path, 3, 0, options))
 571                        return -1;
 572        return 0;
 573}
 574
 575static void update_entry(struct stage_data *entry,
 576                         struct diff_filespec *o,
 577                         struct diff_filespec *a,
 578                         struct diff_filespec *b)
 579{
 580        entry->processed = 0;
 581        entry->stages[1].mode = o->mode;
 582        entry->stages[2].mode = a->mode;
 583        entry->stages[3].mode = b->mode;
 584        oidcpy(&entry->stages[1].oid, &o->oid);
 585        oidcpy(&entry->stages[2].oid, &a->oid);
 586        oidcpy(&entry->stages[3].oid, &b->oid);
 587}
 588
 589static int remove_file(struct merge_options *o, int clean,
 590                       const char *path, int no_wd)
 591{
 592        int update_cache = o->call_depth || clean;
 593        int update_working_directory = !o->call_depth && !no_wd;
 594
 595        if (update_cache) {
 596                if (remove_file_from_cache(path))
 597                        return -1;
 598        }
 599        if (update_working_directory) {
 600                if (ignore_case) {
 601                        struct cache_entry *ce;
 602                        ce = cache_file_exists(path, strlen(path), ignore_case);
 603                        if (ce && ce_stage(ce) == 0)
 604                                return 0;
 605                }
 606                if (remove_path(path))
 607                        return -1;
 608        }
 609        return 0;
 610}
 611
 612/* add a string to a strbuf, but converting "/" to "_" */
 613static void add_flattened_path(struct strbuf *out, const char *s)
 614{
 615        size_t i = out->len;
 616        strbuf_addstr(out, s);
 617        for (; i < out->len; i++)
 618                if (out->buf[i] == '/')
 619                        out->buf[i] = '_';
 620}
 621
 622static char *unique_path(struct merge_options *o, const char *path, const char *branch)
 623{
 624        struct strbuf newpath = STRBUF_INIT;
 625        int suffix = 0;
 626        size_t base_len;
 627
 628        strbuf_addf(&newpath, "%s~", path);
 629        add_flattened_path(&newpath, branch);
 630
 631        base_len = newpath.len;
 632        while (string_list_has_string(&o->current_file_set, newpath.buf) ||
 633               string_list_has_string(&o->current_directory_set, newpath.buf) ||
 634               (!o->call_depth && file_exists(newpath.buf))) {
 635                strbuf_setlen(&newpath, base_len);
 636                strbuf_addf(&newpath, "_%d", suffix++);
 637        }
 638
 639        string_list_insert(&o->current_file_set, newpath.buf);
 640        return strbuf_detach(&newpath, NULL);
 641}
 642
 643static int dir_in_way(const char *path, int check_working_copy)
 644{
 645        int pos;
 646        struct strbuf dirpath = STRBUF_INIT;
 647        struct stat st;
 648
 649        strbuf_addstr(&dirpath, path);
 650        strbuf_addch(&dirpath, '/');
 651
 652        pos = cache_name_pos(dirpath.buf, dirpath.len);
 653
 654        if (pos < 0)
 655                pos = -1 - pos;
 656        if (pos < active_nr &&
 657            !strncmp(dirpath.buf, active_cache[pos]->name, dirpath.len)) {
 658                strbuf_release(&dirpath);
 659                return 1;
 660        }
 661
 662        strbuf_release(&dirpath);
 663        return check_working_copy && !lstat(path, &st) && S_ISDIR(st.st_mode);
 664}
 665
 666static int was_tracked(const char *path)
 667{
 668        int pos = cache_name_pos(path, strlen(path));
 669
 670        if (pos < 0)
 671                pos = -1 - pos;
 672        while (pos < active_nr &&
 673               !strcmp(path, active_cache[pos]->name)) {
 674                /*
 675                 * If stage #0, it is definitely tracked.
 676                 * If it has stage #2 then it was tracked
 677                 * before this merge started.  All other
 678                 * cases the path was not tracked.
 679                 */
 680                switch (ce_stage(active_cache[pos])) {
 681                case 0:
 682                case 2:
 683                        return 1;
 684                }
 685                pos++;
 686        }
 687        return 0;
 688}
 689
 690static int would_lose_untracked(const char *path)
 691{
 692        return !was_tracked(path) && file_exists(path);
 693}
 694
 695static int make_room_for_path(struct merge_options *o, const char *path)
 696{
 697        int status, i;
 698        const char *msg = _("failed to create path '%s'%s");
 699
 700        /* Unlink any D/F conflict files that are in the way */
 701        for (i = 0; i < o->df_conflict_file_set.nr; i++) {
 702                const char *df_path = o->df_conflict_file_set.items[i].string;
 703                size_t pathlen = strlen(path);
 704                size_t df_pathlen = strlen(df_path);
 705                if (df_pathlen < pathlen &&
 706                    path[df_pathlen] == '/' &&
 707                    strncmp(path, df_path, df_pathlen) == 0) {
 708                        output(o, 3,
 709                               _("Removing %s to make room for subdirectory\n"),
 710                               df_path);
 711                        unlink(df_path);
 712                        unsorted_string_list_delete_item(&o->df_conflict_file_set,
 713                                                         i, 0);
 714                        break;
 715                }
 716        }
 717
 718        /* Make sure leading directories are created */
 719        status = safe_create_leading_directories_const(path);
 720        if (status) {
 721                if (status == SCLD_EXISTS) {
 722                        /* something else exists */
 723                        error(msg, path, _(": perhaps a D/F conflict?"));
 724                        return -1;
 725                }
 726                die(msg, path, "");
 727        }
 728
 729        /*
 730         * Do not unlink a file in the work tree if we are not
 731         * tracking it.
 732         */
 733        if (would_lose_untracked(path))
 734                return error(_("refusing to lose untracked file at '%s'"),
 735                             path);
 736
 737        /* Successful unlink is good.. */
 738        if (!unlink(path))
 739                return 0;
 740        /* .. and so is no existing file */
 741        if (errno == ENOENT)
 742                return 0;
 743        /* .. but not some other error (who really cares what?) */
 744        return error(msg, path, _(": perhaps a D/F conflict?"));
 745}
 746
 747static void update_file_flags(struct merge_options *o,
 748                              const struct object_id *oid,
 749                              unsigned mode,
 750                              const char *path,
 751                              int update_cache,
 752                              int update_wd)
 753{
 754        if (o->call_depth)
 755                update_wd = 0;
 756
 757        if (update_wd) {
 758                enum object_type type;
 759                void *buf;
 760                unsigned long size;
 761
 762                if (S_ISGITLINK(mode)) {
 763                        /*
 764                         * We may later decide to recursively descend into
 765                         * the submodule directory and update its index
 766                         * and/or work tree, but we do not do that now.
 767                         */
 768                        update_wd = 0;
 769                        goto update_index;
 770                }
 771
 772                buf = read_sha1_file(oid->hash, &type, &size);
 773                if (!buf)
 774                        die(_("cannot read object %s '%s'"), oid_to_hex(oid), path);
 775                if (type != OBJ_BLOB)
 776                        die(_("blob expected for %s '%s'"), oid_to_hex(oid), path);
 777                if (S_ISREG(mode)) {
 778                        struct strbuf strbuf = STRBUF_INIT;
 779                        if (convert_to_working_tree(path, buf, size, &strbuf)) {
 780                                free(buf);
 781                                size = strbuf.len;
 782                                buf = strbuf_detach(&strbuf, NULL);
 783                        }
 784                }
 785
 786                if (make_room_for_path(o, path) < 0) {
 787                        update_wd = 0;
 788                        free(buf);
 789                        goto update_index;
 790                }
 791                if (S_ISREG(mode) || (!has_symlinks && S_ISLNK(mode))) {
 792                        int fd;
 793                        if (mode & 0100)
 794                                mode = 0777;
 795                        else
 796                                mode = 0666;
 797                        fd = open(path, O_WRONLY | O_TRUNC | O_CREAT, mode);
 798                        if (fd < 0)
 799                                die_errno(_("failed to open '%s'"), path);
 800                        write_in_full(fd, buf, size);
 801                        close(fd);
 802                } else if (S_ISLNK(mode)) {
 803                        char *lnk = xmemdupz(buf, size);
 804                        safe_create_leading_directories_const(path);
 805                        unlink(path);
 806                        if (symlink(lnk, path))
 807                                die_errno(_("failed to symlink '%s'"), path);
 808                        free(lnk);
 809                } else
 810                        die(_("do not know what to do with %06o %s '%s'"),
 811                            mode, oid_to_hex(oid), path);
 812                free(buf);
 813        }
 814 update_index:
 815        if (update_cache)
 816                add_cacheinfo(mode, oid, path, 0, update_wd, ADD_CACHE_OK_TO_ADD);
 817}
 818
 819static void update_file(struct merge_options *o,
 820                        int clean,
 821                        const struct object_id *oid,
 822                        unsigned mode,
 823                        const char *path)
 824{
 825        update_file_flags(o, oid, mode, path, o->call_depth || clean, !o->call_depth);
 826}
 827
 828/* Low level file merging, update and removal */
 829
 830struct merge_file_info {
 831        struct object_id oid;
 832        unsigned mode;
 833        unsigned clean:1,
 834                 merge:1;
 835};
 836
 837static int merge_3way(struct merge_options *o,
 838                      mmbuffer_t *result_buf,
 839                      const struct diff_filespec *one,
 840                      const struct diff_filespec *a,
 841                      const struct diff_filespec *b,
 842                      const char *branch1,
 843                      const char *branch2)
 844{
 845        mmfile_t orig, src1, src2;
 846        struct ll_merge_options ll_opts = {0};
 847        char *base_name, *name1, *name2;
 848        int merge_status;
 849
 850        ll_opts.renormalize = o->renormalize;
 851        ll_opts.xdl_opts = o->xdl_opts;
 852
 853        if (o->call_depth) {
 854                ll_opts.virtual_ancestor = 1;
 855                ll_opts.variant = 0;
 856        } else {
 857                switch (o->recursive_variant) {
 858                case MERGE_RECURSIVE_OURS:
 859                        ll_opts.variant = XDL_MERGE_FAVOR_OURS;
 860                        break;
 861                case MERGE_RECURSIVE_THEIRS:
 862                        ll_opts.variant = XDL_MERGE_FAVOR_THEIRS;
 863                        break;
 864                default:
 865                        ll_opts.variant = 0;
 866                        break;
 867                }
 868        }
 869
 870        if (strcmp(a->path, b->path) ||
 871            (o->ancestor != NULL && strcmp(a->path, one->path) != 0)) {
 872                base_name = o->ancestor == NULL ? NULL :
 873                        mkpathdup("%s:%s", o->ancestor, one->path);
 874                name1 = mkpathdup("%s:%s", branch1, a->path);
 875                name2 = mkpathdup("%s:%s", branch2, b->path);
 876        } else {
 877                base_name = o->ancestor == NULL ? NULL :
 878                        mkpathdup("%s", o->ancestor);
 879                name1 = mkpathdup("%s", branch1);
 880                name2 = mkpathdup("%s", branch2);
 881        }
 882
 883        read_mmblob(&orig, one->oid.hash);
 884        read_mmblob(&src1, a->oid.hash);
 885        read_mmblob(&src2, b->oid.hash);
 886
 887        merge_status = ll_merge(result_buf, a->path, &orig, base_name,
 888                                &src1, name1, &src2, name2, &ll_opts);
 889
 890        free(base_name);
 891        free(name1);
 892        free(name2);
 893        free(orig.ptr);
 894        free(src1.ptr);
 895        free(src2.ptr);
 896        return merge_status;
 897}
 898
 899static struct merge_file_info merge_file_1(struct merge_options *o,
 900                                           const struct diff_filespec *one,
 901                                           const struct diff_filespec *a,
 902                                           const struct diff_filespec *b,
 903                                           const char *branch1,
 904                                           const char *branch2)
 905{
 906        struct merge_file_info result;
 907        result.merge = 0;
 908        result.clean = 1;
 909
 910        if ((S_IFMT & a->mode) != (S_IFMT & b->mode)) {
 911                result.clean = 0;
 912                if (S_ISREG(a->mode)) {
 913                        result.mode = a->mode;
 914                        oidcpy(&result.oid, &a->oid);
 915                } else {
 916                        result.mode = b->mode;
 917                        oidcpy(&result.oid, &b->oid);
 918                }
 919        } else {
 920                if (!oid_eq(&a->oid, &one->oid) && !oid_eq(&b->oid, &one->oid))
 921                        result.merge = 1;
 922
 923                /*
 924                 * Merge modes
 925                 */
 926                if (a->mode == b->mode || a->mode == one->mode)
 927                        result.mode = b->mode;
 928                else {
 929                        result.mode = a->mode;
 930                        if (b->mode != one->mode) {
 931                                result.clean = 0;
 932                                result.merge = 1;
 933                        }
 934                }
 935
 936                if (oid_eq(&a->oid, &b->oid) || oid_eq(&a->oid, &one->oid))
 937                        oidcpy(&result.oid, &b->oid);
 938                else if (oid_eq(&b->oid, &one->oid))
 939                        oidcpy(&result.oid, &a->oid);
 940                else if (S_ISREG(a->mode)) {
 941                        mmbuffer_t result_buf;
 942                        int merge_status;
 943
 944                        merge_status = merge_3way(o, &result_buf, one, a, b,
 945                                                  branch1, branch2);
 946
 947                        if ((merge_status < 0) || !result_buf.ptr)
 948                                die(_("Failed to execute internal merge"));
 949
 950                        if (write_sha1_file(result_buf.ptr, result_buf.size,
 951                                            blob_type, result.oid.hash))
 952                                die(_("Unable to add %s to database"),
 953                                    a->path);
 954
 955                        free(result_buf.ptr);
 956                        result.clean = (merge_status == 0);
 957                } else if (S_ISGITLINK(a->mode)) {
 958                        result.clean = merge_submodule(result.oid.hash,
 959                                                       one->path,
 960                                                       one->oid.hash,
 961                                                       a->oid.hash,
 962                                                       b->oid.hash,
 963                                                       !o->call_depth);
 964                } else if (S_ISLNK(a->mode)) {
 965                        oidcpy(&result.oid, &a->oid);
 966
 967                        if (!oid_eq(&a->oid, &b->oid))
 968                                result.clean = 0;
 969                } else {
 970                        die(_("unsupported object type in the tree"));
 971                }
 972        }
 973
 974        return result;
 975}
 976
 977static struct merge_file_info
 978merge_file_special_markers(struct merge_options *o,
 979                           const struct diff_filespec *one,
 980                           const struct diff_filespec *a,
 981                           const struct diff_filespec *b,
 982                           const char *branch1,
 983                           const char *filename1,
 984                           const char *branch2,
 985                           const char *filename2)
 986{
 987        char *side1 = NULL;
 988        char *side2 = NULL;
 989        struct merge_file_info mfi;
 990
 991        if (filename1)
 992                side1 = xstrfmt("%s:%s", branch1, filename1);
 993        if (filename2)
 994                side2 = xstrfmt("%s:%s", branch2, filename2);
 995
 996        mfi = merge_file_1(o, one, a, b,
 997                           side1 ? side1 : branch1, side2 ? side2 : branch2);
 998        free(side1);
 999        free(side2);
1000        return mfi;
1001}
1002
1003static struct merge_file_info merge_file_one(struct merge_options *o,
1004                                         const char *path,
1005                                         const struct object_id *o_oid, int o_mode,
1006                                         const struct object_id *a_oid, int a_mode,
1007                                         const struct object_id *b_oid, int b_mode,
1008                                         const char *branch1,
1009                                         const char *branch2)
1010{
1011        struct diff_filespec one, a, b;
1012
1013        one.path = a.path = b.path = (char *)path;
1014        oidcpy(&one.oid, o_oid);
1015        one.mode = o_mode;
1016        oidcpy(&a.oid, a_oid);
1017        a.mode = a_mode;
1018        oidcpy(&b.oid, b_oid);
1019        b.mode = b_mode;
1020        return merge_file_1(o, &one, &a, &b, branch1, branch2);
1021}
1022
1023static void handle_change_delete(struct merge_options *o,
1024                                 const char *path,
1025                                 const struct object_id *o_oid, int o_mode,
1026                                 const struct object_id *a_oid, int a_mode,
1027                                 const struct object_id *b_oid, int b_mode,
1028                                 const char *change, const char *change_past)
1029{
1030        char *renamed = NULL;
1031        if (dir_in_way(path, !o->call_depth)) {
1032                renamed = unique_path(o, path, a_oid ? o->branch1 : o->branch2);
1033        }
1034
1035        if (o->call_depth) {
1036                /*
1037                 * We cannot arbitrarily accept either a_sha or b_sha as
1038                 * correct; since there is no true "middle point" between
1039                 * them, simply reuse the base version for virtual merge base.
1040                 */
1041                remove_file_from_cache(path);
1042                update_file(o, 0, o_oid, o_mode, renamed ? renamed : path);
1043        } else if (!a_oid) {
1044                if (!renamed) {
1045                        output(o, 1, _("CONFLICT (%s/delete): %s deleted in %s "
1046                               "and %s in %s. Version %s of %s left in tree."),
1047                               change, path, o->branch1, change_past,
1048                               o->branch2, o->branch2, path);
1049                        update_file(o, 0, b_oid, b_mode, path);
1050                } else {
1051                        output(o, 1, _("CONFLICT (%s/delete): %s deleted in %s "
1052                               "and %s in %s. Version %s of %s left in tree at %s."),
1053                               change, path, o->branch1, change_past,
1054                               o->branch2, o->branch2, path, renamed);
1055                        update_file(o, 0, b_oid, b_mode, renamed);
1056                }
1057        } else {
1058                if (!renamed) {
1059                        output(o, 1, _("CONFLICT (%s/delete): %s deleted in %s "
1060                               "and %s in %s. Version %s of %s left in tree."),
1061                               change, path, o->branch2, change_past,
1062                               o->branch1, o->branch1, path);
1063                } else {
1064                        output(o, 1, _("CONFLICT (%s/delete): %s deleted in %s "
1065                               "and %s in %s. Version %s of %s left in tree at %s."),
1066                               change, path, o->branch2, change_past,
1067                               o->branch1, o->branch1, path, renamed);
1068                        update_file(o, 0, a_oid, a_mode, renamed);
1069                }
1070                /*
1071                 * No need to call update_file() on path when !renamed, since
1072                 * that would needlessly touch path.  We could call
1073                 * update_file_flags() with update_cache=0 and update_wd=0,
1074                 * but that's a no-op.
1075                 */
1076        }
1077        free(renamed);
1078}
1079
1080static void conflict_rename_delete(struct merge_options *o,
1081                                   struct diff_filepair *pair,
1082                                   const char *rename_branch,
1083                                   const char *other_branch)
1084{
1085        const struct diff_filespec *orig = pair->one;
1086        const struct diff_filespec *dest = pair->two;
1087        const struct object_id *a_oid = NULL;
1088        const struct object_id *b_oid = NULL;
1089        int a_mode = 0;
1090        int b_mode = 0;
1091
1092        if (rename_branch == o->branch1) {
1093                a_oid = &dest->oid;
1094                a_mode = dest->mode;
1095        } else {
1096                b_oid = &dest->oid;
1097                b_mode = dest->mode;
1098        }
1099
1100        handle_change_delete(o,
1101                             o->call_depth ? orig->path : dest->path,
1102                             &orig->oid, orig->mode,
1103                             a_oid, a_mode,
1104                             b_oid, b_mode,
1105                             _("rename"), _("renamed"));
1106
1107        if (o->call_depth) {
1108                remove_file_from_cache(dest->path);
1109        } else {
1110                update_stages(dest->path, NULL,
1111                              rename_branch == o->branch1 ? dest : NULL,
1112                              rename_branch == o->branch1 ? NULL : dest);
1113        }
1114
1115}
1116
1117static struct diff_filespec *filespec_from_entry(struct diff_filespec *target,
1118                                                 struct stage_data *entry,
1119                                                 int stage)
1120{
1121        struct object_id *oid = &entry->stages[stage].oid;
1122        unsigned mode = entry->stages[stage].mode;
1123        if (mode == 0 || is_null_oid(oid))
1124                return NULL;
1125        oidcpy(&target->oid, oid);
1126        target->mode = mode;
1127        return target;
1128}
1129
1130static void handle_file(struct merge_options *o,
1131                        struct diff_filespec *rename,
1132                        int stage,
1133                        struct rename_conflict_info *ci)
1134{
1135        char *dst_name = rename->path;
1136        struct stage_data *dst_entry;
1137        const char *cur_branch, *other_branch;
1138        struct diff_filespec other;
1139        struct diff_filespec *add;
1140
1141        if (stage == 2) {
1142                dst_entry = ci->dst_entry1;
1143                cur_branch = ci->branch1;
1144                other_branch = ci->branch2;
1145        } else {
1146                dst_entry = ci->dst_entry2;
1147                cur_branch = ci->branch2;
1148                other_branch = ci->branch1;
1149        }
1150
1151        add = filespec_from_entry(&other, dst_entry, stage ^ 1);
1152        if (add) {
1153                char *add_name = unique_path(o, rename->path, other_branch);
1154                update_file(o, 0, &add->oid, add->mode, add_name);
1155
1156                remove_file(o, 0, rename->path, 0);
1157                dst_name = unique_path(o, rename->path, cur_branch);
1158        } else {
1159                if (dir_in_way(rename->path, !o->call_depth)) {
1160                        dst_name = unique_path(o, rename->path, cur_branch);
1161                        output(o, 1, _("%s is a directory in %s adding as %s instead"),
1162                               rename->path, other_branch, dst_name);
1163                }
1164        }
1165        update_file(o, 0, &rename->oid, rename->mode, dst_name);
1166        if (stage == 2)
1167                update_stages(rename->path, NULL, rename, add);
1168        else
1169                update_stages(rename->path, NULL, add, rename);
1170
1171        if (dst_name != rename->path)
1172                free(dst_name);
1173}
1174
1175static void conflict_rename_rename_1to2(struct merge_options *o,
1176                                        struct rename_conflict_info *ci)
1177{
1178        /* One file was renamed in both branches, but to different names. */
1179        struct diff_filespec *one = ci->pair1->one;
1180        struct diff_filespec *a = ci->pair1->two;
1181        struct diff_filespec *b = ci->pair2->two;
1182
1183        output(o, 1, _("CONFLICT (rename/rename): "
1184               "Rename \"%s\"->\"%s\" in branch \"%s\" "
1185               "rename \"%s\"->\"%s\" in \"%s\"%s"),
1186               one->path, a->path, ci->branch1,
1187               one->path, b->path, ci->branch2,
1188               o->call_depth ? _(" (left unresolved)") : "");
1189        if (o->call_depth) {
1190                struct merge_file_info mfi;
1191                struct diff_filespec other;
1192                struct diff_filespec *add;
1193                mfi = merge_file_one(o, one->path,
1194                                 &one->oid, one->mode,
1195                                 &a->oid, a->mode,
1196                                 &b->oid, b->mode,
1197                                 ci->branch1, ci->branch2);
1198                /*
1199                 * FIXME: For rename/add-source conflicts (if we could detect
1200                 * such), this is wrong.  We should instead find a unique
1201                 * pathname and then either rename the add-source file to that
1202                 * unique path, or use that unique path instead of src here.
1203                 */
1204                update_file(o, 0, &mfi.oid, mfi.mode, one->path);
1205
1206                /*
1207                 * Above, we put the merged content at the merge-base's
1208                 * path.  Now we usually need to delete both a->path and
1209                 * b->path.  However, the rename on each side of the merge
1210                 * could also be involved in a rename/add conflict.  In
1211                 * such cases, we should keep the added file around,
1212                 * resolving the conflict at that path in its favor.
1213                 */
1214                add = filespec_from_entry(&other, ci->dst_entry1, 2 ^ 1);
1215                if (add)
1216                        update_file(o, 0, &add->oid, add->mode, a->path);
1217                else
1218                        remove_file_from_cache(a->path);
1219                add = filespec_from_entry(&other, ci->dst_entry2, 3 ^ 1);
1220                if (add)
1221                        update_file(o, 0, &add->oid, add->mode, b->path);
1222                else
1223                        remove_file_from_cache(b->path);
1224        } else {
1225                handle_file(o, a, 2, ci);
1226                handle_file(o, b, 3, ci);
1227        }
1228}
1229
1230static void conflict_rename_rename_2to1(struct merge_options *o,
1231                                        struct rename_conflict_info *ci)
1232{
1233        /* Two files, a & b, were renamed to the same thing, c. */
1234        struct diff_filespec *a = ci->pair1->one;
1235        struct diff_filespec *b = ci->pair2->one;
1236        struct diff_filespec *c1 = ci->pair1->two;
1237        struct diff_filespec *c2 = ci->pair2->two;
1238        char *path = c1->path; /* == c2->path */
1239        struct merge_file_info mfi_c1;
1240        struct merge_file_info mfi_c2;
1241
1242        output(o, 1, _("CONFLICT (rename/rename): "
1243               "Rename %s->%s in %s. "
1244               "Rename %s->%s in %s"),
1245               a->path, c1->path, ci->branch1,
1246               b->path, c2->path, ci->branch2);
1247
1248        remove_file(o, 1, a->path, o->call_depth || would_lose_untracked(a->path));
1249        remove_file(o, 1, b->path, o->call_depth || would_lose_untracked(b->path));
1250
1251        mfi_c1 = merge_file_special_markers(o, a, c1, &ci->ren1_other,
1252                                            o->branch1, c1->path,
1253                                            o->branch2, ci->ren1_other.path);
1254        mfi_c2 = merge_file_special_markers(o, b, &ci->ren2_other, c2,
1255                                            o->branch1, ci->ren2_other.path,
1256                                            o->branch2, c2->path);
1257
1258        if (o->call_depth) {
1259                /*
1260                 * If mfi_c1.clean && mfi_c2.clean, then it might make
1261                 * sense to do a two-way merge of those results.  But, I
1262                 * think in all cases, it makes sense to have the virtual
1263                 * merge base just undo the renames; they can be detected
1264                 * again later for the non-recursive merge.
1265                 */
1266                remove_file(o, 0, path, 0);
1267                update_file(o, 0, &mfi_c1.oid, mfi_c1.mode, a->path);
1268                update_file(o, 0, &mfi_c2.oid, mfi_c2.mode, b->path);
1269        } else {
1270                char *new_path1 = unique_path(o, path, ci->branch1);
1271                char *new_path2 = unique_path(o, path, ci->branch2);
1272                output(o, 1, _("Renaming %s to %s and %s to %s instead"),
1273                       a->path, new_path1, b->path, new_path2);
1274                remove_file(o, 0, path, 0);
1275                update_file(o, 0, &mfi_c1.oid, mfi_c1.mode, new_path1);
1276                update_file(o, 0, &mfi_c2.oid, mfi_c2.mode, new_path2);
1277                free(new_path2);
1278                free(new_path1);
1279        }
1280}
1281
1282static int process_renames(struct merge_options *o,
1283                           struct string_list *a_renames,
1284                           struct string_list *b_renames)
1285{
1286        int clean_merge = 1, i, j;
1287        struct string_list a_by_dst = STRING_LIST_INIT_NODUP;
1288        struct string_list b_by_dst = STRING_LIST_INIT_NODUP;
1289        const struct rename *sre;
1290
1291        for (i = 0; i < a_renames->nr; i++) {
1292                sre = a_renames->items[i].util;
1293                string_list_insert(&a_by_dst, sre->pair->two->path)->util
1294                        = (void *)sre;
1295        }
1296        for (i = 0; i < b_renames->nr; i++) {
1297                sre = b_renames->items[i].util;
1298                string_list_insert(&b_by_dst, sre->pair->two->path)->util
1299                        = (void *)sre;
1300        }
1301
1302        for (i = 0, j = 0; i < a_renames->nr || j < b_renames->nr;) {
1303                struct string_list *renames1, *renames2Dst;
1304                struct rename *ren1 = NULL, *ren2 = NULL;
1305                const char *branch1, *branch2;
1306                const char *ren1_src, *ren1_dst;
1307                struct string_list_item *lookup;
1308
1309                if (i >= a_renames->nr) {
1310                        ren2 = b_renames->items[j++].util;
1311                } else if (j >= b_renames->nr) {
1312                        ren1 = a_renames->items[i++].util;
1313                } else {
1314                        int compare = strcmp(a_renames->items[i].string,
1315                                             b_renames->items[j].string);
1316                        if (compare <= 0)
1317                                ren1 = a_renames->items[i++].util;
1318                        if (compare >= 0)
1319                                ren2 = b_renames->items[j++].util;
1320                }
1321
1322                /* TODO: refactor, so that 1/2 are not needed */
1323                if (ren1) {
1324                        renames1 = a_renames;
1325                        renames2Dst = &b_by_dst;
1326                        branch1 = o->branch1;
1327                        branch2 = o->branch2;
1328                } else {
1329                        struct rename *tmp;
1330                        renames1 = b_renames;
1331                        renames2Dst = &a_by_dst;
1332                        branch1 = o->branch2;
1333                        branch2 = o->branch1;
1334                        tmp = ren2;
1335                        ren2 = ren1;
1336                        ren1 = tmp;
1337                }
1338
1339                if (ren1->processed)
1340                        continue;
1341                ren1->processed = 1;
1342                ren1->dst_entry->processed = 1;
1343                /* BUG: We should only mark src_entry as processed if we
1344                 * are not dealing with a rename + add-source case.
1345                 */
1346                ren1->src_entry->processed = 1;
1347
1348                ren1_src = ren1->pair->one->path;
1349                ren1_dst = ren1->pair->two->path;
1350
1351                if (ren2) {
1352                        /* One file renamed on both sides */
1353                        const char *ren2_src = ren2->pair->one->path;
1354                        const char *ren2_dst = ren2->pair->two->path;
1355                        enum rename_type rename_type;
1356                        if (strcmp(ren1_src, ren2_src) != 0)
1357                                die("ren1_src != ren2_src");
1358                        ren2->dst_entry->processed = 1;
1359                        ren2->processed = 1;
1360                        if (strcmp(ren1_dst, ren2_dst) != 0) {
1361                                rename_type = RENAME_ONE_FILE_TO_TWO;
1362                                clean_merge = 0;
1363                        } else {
1364                                rename_type = RENAME_ONE_FILE_TO_ONE;
1365                                /* BUG: We should only remove ren1_src in
1366                                 * the base stage (think of rename +
1367                                 * add-source cases).
1368                                 */
1369                                remove_file(o, 1, ren1_src, 1);
1370                                update_entry(ren1->dst_entry,
1371                                             ren1->pair->one,
1372                                             ren1->pair->two,
1373                                             ren2->pair->two);
1374                        }
1375                        setup_rename_conflict_info(rename_type,
1376                                                   ren1->pair,
1377                                                   ren2->pair,
1378                                                   branch1,
1379                                                   branch2,
1380                                                   ren1->dst_entry,
1381                                                   ren2->dst_entry,
1382                                                   o,
1383                                                   NULL,
1384                                                   NULL);
1385                } else if ((lookup = string_list_lookup(renames2Dst, ren1_dst))) {
1386                        /* Two different files renamed to the same thing */
1387                        char *ren2_dst;
1388                        ren2 = lookup->util;
1389                        ren2_dst = ren2->pair->two->path;
1390                        if (strcmp(ren1_dst, ren2_dst) != 0)
1391                                die("ren1_dst != ren2_dst");
1392
1393                        clean_merge = 0;
1394                        ren2->processed = 1;
1395                        /*
1396                         * BUG: We should only mark src_entry as processed
1397                         * if we are not dealing with a rename + add-source
1398                         * case.
1399                         */
1400                        ren2->src_entry->processed = 1;
1401
1402                        setup_rename_conflict_info(RENAME_TWO_FILES_TO_ONE,
1403                                                   ren1->pair,
1404                                                   ren2->pair,
1405                                                   branch1,
1406                                                   branch2,
1407                                                   ren1->dst_entry,
1408                                                   ren2->dst_entry,
1409                                                   o,
1410                                                   ren1->src_entry,
1411                                                   ren2->src_entry);
1412
1413                } else {
1414                        /* Renamed in 1, maybe changed in 2 */
1415                        /* we only use sha1 and mode of these */
1416                        struct diff_filespec src_other, dst_other;
1417                        int try_merge;
1418
1419                        /*
1420                         * unpack_trees loads entries from common-commit
1421                         * into stage 1, from head-commit into stage 2, and
1422                         * from merge-commit into stage 3.  We keep track
1423                         * of which side corresponds to the rename.
1424                         */
1425                        int renamed_stage = a_renames == renames1 ? 2 : 3;
1426                        int other_stage =   a_renames == renames1 ? 3 : 2;
1427
1428                        /* BUG: We should only remove ren1_src in the base
1429                         * stage and in other_stage (think of rename +
1430                         * add-source case).
1431                         */
1432                        remove_file(o, 1, ren1_src,
1433                                    renamed_stage == 2 || !was_tracked(ren1_src));
1434
1435                        oidcpy(&src_other.oid,
1436                               &ren1->src_entry->stages[other_stage].oid);
1437                        src_other.mode = ren1->src_entry->stages[other_stage].mode;
1438                        oidcpy(&dst_other.oid,
1439                               &ren1->dst_entry->stages[other_stage].oid);
1440                        dst_other.mode = ren1->dst_entry->stages[other_stage].mode;
1441                        try_merge = 0;
1442
1443                        if (oid_eq(&src_other.oid, &null_oid)) {
1444                                setup_rename_conflict_info(RENAME_DELETE,
1445                                                           ren1->pair,
1446                                                           NULL,
1447                                                           branch1,
1448                                                           branch2,
1449                                                           ren1->dst_entry,
1450                                                           NULL,
1451                                                           o,
1452                                                           NULL,
1453                                                           NULL);
1454                        } else if ((dst_other.mode == ren1->pair->two->mode) &&
1455                                   oid_eq(&dst_other.oid, &ren1->pair->two->oid)) {
1456                                /*
1457                                 * Added file on the other side identical to
1458                                 * the file being renamed: clean merge.
1459                                 * Also, there is no need to overwrite the
1460                                 * file already in the working copy, so call
1461                                 * update_file_flags() instead of
1462                                 * update_file().
1463                                 */
1464                                update_file_flags(o,
1465                                                  &ren1->pair->two->oid,
1466                                                  ren1->pair->two->mode,
1467                                                  ren1_dst,
1468                                                  1, /* update_cache */
1469                                                  0  /* update_wd    */);
1470                        } else if (!oid_eq(&dst_other.oid, &null_oid)) {
1471                                clean_merge = 0;
1472                                try_merge = 1;
1473                                output(o, 1, _("CONFLICT (rename/add): Rename %s->%s in %s. "
1474                                       "%s added in %s"),
1475                                       ren1_src, ren1_dst, branch1,
1476                                       ren1_dst, branch2);
1477                                if (o->call_depth) {
1478                                        struct merge_file_info mfi;
1479                                        mfi = merge_file_one(o, ren1_dst, &null_oid, 0,
1480                                                         &ren1->pair->two->oid,
1481                                                         ren1->pair->two->mode,
1482                                                         &dst_other.oid,
1483                                                         dst_other.mode,
1484                                                         branch1, branch2);
1485                                        output(o, 1, _("Adding merged %s"), ren1_dst);
1486                                        update_file(o, 0, &mfi.oid,
1487                                                    mfi.mode, ren1_dst);
1488                                        try_merge = 0;
1489                                } else {
1490                                        char *new_path = unique_path(o, ren1_dst, branch2);
1491                                        output(o, 1, _("Adding as %s instead"), new_path);
1492                                        update_file(o, 0, &dst_other.oid,
1493                                                    dst_other.mode, new_path);
1494                                        free(new_path);
1495                                }
1496                        } else
1497                                try_merge = 1;
1498
1499                        if (try_merge) {
1500                                struct diff_filespec *one, *a, *b;
1501                                src_other.path = (char *)ren1_src;
1502
1503                                one = ren1->pair->one;
1504                                if (a_renames == renames1) {
1505                                        a = ren1->pair->two;
1506                                        b = &src_other;
1507                                } else {
1508                                        b = ren1->pair->two;
1509                                        a = &src_other;
1510                                }
1511                                update_entry(ren1->dst_entry, one, a, b);
1512                                setup_rename_conflict_info(RENAME_NORMAL,
1513                                                           ren1->pair,
1514                                                           NULL,
1515                                                           branch1,
1516                                                           NULL,
1517                                                           ren1->dst_entry,
1518                                                           NULL,
1519                                                           o,
1520                                                           NULL,
1521                                                           NULL);
1522                        }
1523                }
1524        }
1525        string_list_clear(&a_by_dst, 0);
1526        string_list_clear(&b_by_dst, 0);
1527
1528        return clean_merge;
1529}
1530
1531static struct object_id *stage_oid(const struct object_id *oid, unsigned mode)
1532{
1533        return (is_null_oid(oid) || mode == 0) ? NULL: (struct object_id *)oid;
1534}
1535
1536static int read_oid_strbuf(const struct object_id *oid, struct strbuf *dst)
1537{
1538        void *buf;
1539        enum object_type type;
1540        unsigned long size;
1541        buf = read_sha1_file(oid->hash, &type, &size);
1542        if (!buf)
1543                return error(_("cannot read object %s"), oid_to_hex(oid));
1544        if (type != OBJ_BLOB) {
1545                free(buf);
1546                return error(_("object %s is not a blob"), oid_to_hex(oid));
1547        }
1548        strbuf_attach(dst, buf, size, size + 1);
1549        return 0;
1550}
1551
1552static int blob_unchanged(const struct object_id *o_oid,
1553                          unsigned o_mode,
1554                          const struct object_id *a_oid,
1555                          unsigned a_mode,
1556                          int renormalize, const char *path)
1557{
1558        struct strbuf o = STRBUF_INIT;
1559        struct strbuf a = STRBUF_INIT;
1560        int ret = 0; /* assume changed for safety */
1561
1562        if (a_mode != o_mode)
1563                return 0;
1564        if (oid_eq(o_oid, a_oid))
1565                return 1;
1566        if (!renormalize)
1567                return 0;
1568
1569        assert(o_oid && a_oid);
1570        if (read_oid_strbuf(o_oid, &o) || read_oid_strbuf(a_oid, &a))
1571                goto error_return;
1572        /*
1573         * Note: binary | is used so that both renormalizations are
1574         * performed.  Comparison can be skipped if both files are
1575         * unchanged since their sha1s have already been compared.
1576         */
1577        if (renormalize_buffer(path, o.buf, o.len, &o) |
1578            renormalize_buffer(path, a.buf, a.len, &a))
1579                ret = (o.len == a.len && !memcmp(o.buf, a.buf, o.len));
1580
1581error_return:
1582        strbuf_release(&o);
1583        strbuf_release(&a);
1584        return ret;
1585}
1586
1587static void handle_modify_delete(struct merge_options *o,
1588                                 const char *path,
1589                                 struct object_id *o_oid, int o_mode,
1590                                 struct object_id *a_oid, int a_mode,
1591                                 struct object_id *b_oid, int b_mode)
1592{
1593        handle_change_delete(o,
1594                             path,
1595                             o_oid, o_mode,
1596                             a_oid, a_mode,
1597                             b_oid, b_mode,
1598                             _("modify"), _("modified"));
1599}
1600
1601static int merge_content(struct merge_options *o,
1602                         const char *path,
1603                         struct object_id *o_oid, int o_mode,
1604                         struct object_id *a_oid, int a_mode,
1605                         struct object_id *b_oid, int b_mode,
1606                         struct rename_conflict_info *rename_conflict_info)
1607{
1608        const char *reason = _("content");
1609        const char *path1 = NULL, *path2 = NULL;
1610        struct merge_file_info mfi;
1611        struct diff_filespec one, a, b;
1612        unsigned df_conflict_remains = 0;
1613
1614        if (!o_oid) {
1615                reason = _("add/add");
1616                o_oid = (struct object_id *)&null_oid;
1617        }
1618        one.path = a.path = b.path = (char *)path;
1619        oidcpy(&one.oid, o_oid);
1620        one.mode = o_mode;
1621        oidcpy(&a.oid, a_oid);
1622        a.mode = a_mode;
1623        oidcpy(&b.oid, b_oid);
1624        b.mode = b_mode;
1625
1626        if (rename_conflict_info) {
1627                struct diff_filepair *pair1 = rename_conflict_info->pair1;
1628
1629                path1 = (o->branch1 == rename_conflict_info->branch1) ?
1630                        pair1->two->path : pair1->one->path;
1631                /* If rename_conflict_info->pair2 != NULL, we are in
1632                 * RENAME_ONE_FILE_TO_ONE case.  Otherwise, we have a
1633                 * normal rename.
1634                 */
1635                path2 = (rename_conflict_info->pair2 ||
1636                         o->branch2 == rename_conflict_info->branch1) ?
1637                        pair1->two->path : pair1->one->path;
1638
1639                if (dir_in_way(path, !o->call_depth))
1640                        df_conflict_remains = 1;
1641        }
1642        mfi = merge_file_special_markers(o, &one, &a, &b,
1643                                         o->branch1, path1,
1644                                         o->branch2, path2);
1645
1646        if (mfi.clean && !df_conflict_remains &&
1647            oid_eq(&mfi.oid, a_oid) && mfi.mode == a_mode) {
1648                int path_renamed_outside_HEAD;
1649                output(o, 3, _("Skipped %s (merged same as existing)"), path);
1650                /*
1651                 * The content merge resulted in the same file contents we
1652                 * already had.  We can return early if those file contents
1653                 * are recorded at the correct path (which may not be true
1654                 * if the merge involves a rename).
1655                 */
1656                path_renamed_outside_HEAD = !path2 || !strcmp(path, path2);
1657                if (!path_renamed_outside_HEAD) {
1658                        add_cacheinfo(mfi.mode, &mfi.oid, path,
1659                                      0, (!o->call_depth), 0);
1660                        return mfi.clean;
1661                }
1662        } else
1663                output(o, 2, _("Auto-merging %s"), path);
1664
1665        if (!mfi.clean) {
1666                if (S_ISGITLINK(mfi.mode))
1667                        reason = _("submodule");
1668                output(o, 1, _("CONFLICT (%s): Merge conflict in %s"),
1669                                reason, path);
1670                if (rename_conflict_info && !df_conflict_remains)
1671                        update_stages(path, &one, &a, &b);
1672        }
1673
1674        if (df_conflict_remains) {
1675                char *new_path;
1676                if (o->call_depth) {
1677                        remove_file_from_cache(path);
1678                } else {
1679                        if (!mfi.clean)
1680                                update_stages(path, &one, &a, &b);
1681                        else {
1682                                int file_from_stage2 = was_tracked(path);
1683                                struct diff_filespec merged;
1684                                oidcpy(&merged.oid, &mfi.oid);
1685                                merged.mode = mfi.mode;
1686
1687                                update_stages(path, NULL,
1688                                              file_from_stage2 ? &merged : NULL,
1689                                              file_from_stage2 ? NULL : &merged);
1690                        }
1691
1692                }
1693                new_path = unique_path(o, path, rename_conflict_info->branch1);
1694                output(o, 1, _("Adding as %s instead"), new_path);
1695                update_file(o, 0, &mfi.oid, mfi.mode, new_path);
1696                free(new_path);
1697                mfi.clean = 0;
1698        } else {
1699                update_file(o, mfi.clean, &mfi.oid, mfi.mode, path);
1700        }
1701        return mfi.clean;
1702
1703}
1704
1705/* Per entry merge function */
1706static int process_entry(struct merge_options *o,
1707                         const char *path, struct stage_data *entry)
1708{
1709        int clean_merge = 1;
1710        int normalize = o->renormalize;
1711        unsigned o_mode = entry->stages[1].mode;
1712        unsigned a_mode = entry->stages[2].mode;
1713        unsigned b_mode = entry->stages[3].mode;
1714        struct object_id *o_oid = stage_oid(&entry->stages[1].oid, o_mode);
1715        struct object_id *a_oid = stage_oid(&entry->stages[2].oid, a_mode);
1716        struct object_id *b_oid = stage_oid(&entry->stages[3].oid, b_mode);
1717
1718        entry->processed = 1;
1719        if (entry->rename_conflict_info) {
1720                struct rename_conflict_info *conflict_info = entry->rename_conflict_info;
1721                switch (conflict_info->rename_type) {
1722                case RENAME_NORMAL:
1723                case RENAME_ONE_FILE_TO_ONE:
1724                        clean_merge = merge_content(o, path,
1725                                                    o_oid, o_mode, a_oid, a_mode, b_oid, b_mode,
1726                                                    conflict_info);
1727                        break;
1728                case RENAME_DELETE:
1729                        clean_merge = 0;
1730                        conflict_rename_delete(o, conflict_info->pair1,
1731                                               conflict_info->branch1,
1732                                               conflict_info->branch2);
1733                        break;
1734                case RENAME_ONE_FILE_TO_TWO:
1735                        clean_merge = 0;
1736                        conflict_rename_rename_1to2(o, conflict_info);
1737                        break;
1738                case RENAME_TWO_FILES_TO_ONE:
1739                        clean_merge = 0;
1740                        conflict_rename_rename_2to1(o, conflict_info);
1741                        break;
1742                default:
1743                        entry->processed = 0;
1744                        break;
1745                }
1746        } else if (o_oid && (!a_oid || !b_oid)) {
1747                /* Case A: Deleted in one */
1748                if ((!a_oid && !b_oid) ||
1749                    (!b_oid && blob_unchanged(o_oid, o_mode, a_oid, a_mode, normalize, path)) ||
1750                    (!a_oid && blob_unchanged(o_oid, o_mode, b_oid, b_mode, normalize, path))) {
1751                        /* Deleted in both or deleted in one and
1752                         * unchanged in the other */
1753                        if (a_oid)
1754                                output(o, 2, _("Removing %s"), path);
1755                        /* do not touch working file if it did not exist */
1756                        remove_file(o, 1, path, !a_oid);
1757                } else {
1758                        /* Modify/delete; deleted side may have put a directory in the way */
1759                        clean_merge = 0;
1760                        handle_modify_delete(o, path, o_oid, o_mode,
1761                                             a_oid, a_mode, b_oid, b_mode);
1762                }
1763        } else if ((!o_oid && a_oid && !b_oid) ||
1764                   (!o_oid && !a_oid && b_oid)) {
1765                /* Case B: Added in one. */
1766                /* [nothing|directory] -> ([nothing|directory], file) */
1767
1768                const char *add_branch;
1769                const char *other_branch;
1770                unsigned mode;
1771                const struct object_id *oid;
1772                const char *conf;
1773
1774                if (a_oid) {
1775                        add_branch = o->branch1;
1776                        other_branch = o->branch2;
1777                        mode = a_mode;
1778                        oid = a_oid;
1779                        conf = _("file/directory");
1780                } else {
1781                        add_branch = o->branch2;
1782                        other_branch = o->branch1;
1783                        mode = b_mode;
1784                        oid = b_oid;
1785                        conf = _("directory/file");
1786                }
1787                if (dir_in_way(path, !o->call_depth)) {
1788                        char *new_path = unique_path(o, path, add_branch);
1789                        clean_merge = 0;
1790                        output(o, 1, _("CONFLICT (%s): There is a directory with name %s in %s. "
1791                               "Adding %s as %s"),
1792                               conf, path, other_branch, path, new_path);
1793                        update_file(o, 0, oid, mode, new_path);
1794                        if (o->call_depth)
1795                                remove_file_from_cache(path);
1796                        free(new_path);
1797                } else {
1798                        output(o, 2, _("Adding %s"), path);
1799                        /* do not overwrite file if already present */
1800                        update_file_flags(o, oid, mode, path, 1, !a_oid);
1801                }
1802        } else if (a_oid && b_oid) {
1803                /* Case C: Added in both (check for same permissions) and */
1804                /* case D: Modified in both, but differently. */
1805                clean_merge = merge_content(o, path,
1806                                            o_oid, o_mode, a_oid, a_mode, b_oid, b_mode,
1807                                            NULL);
1808        } else if (!o_oid && !a_oid && !b_oid) {
1809                /*
1810                 * this entry was deleted altogether. a_mode == 0 means
1811                 * we had that path and want to actively remove it.
1812                 */
1813                remove_file(o, 1, path, !a_mode);
1814        } else
1815                die(_("Fatal merge failure, shouldn't happen."));
1816
1817        return clean_merge;
1818}
1819
1820int merge_trees(struct merge_options *o,
1821                struct tree *head,
1822                struct tree *merge,
1823                struct tree *common,
1824                struct tree **result)
1825{
1826        int code, clean;
1827
1828        if (o->subtree_shift) {
1829                merge = shift_tree_object(head, merge, o->subtree_shift);
1830                common = shift_tree_object(head, common, o->subtree_shift);
1831        }
1832
1833        if (oid_eq(&common->object.oid, &merge->object.oid)) {
1834                output(o, 0, _("Already up-to-date!"));
1835                *result = head;
1836                return 1;
1837        }
1838
1839        code = git_merge_trees(o->call_depth, common, head, merge);
1840
1841        if (code != 0) {
1842                if (show(o, 4) || o->call_depth)
1843                        die(_("merging of trees %s and %s failed"),
1844                            oid_to_hex(&head->object.oid),
1845                            oid_to_hex(&merge->object.oid));
1846                else
1847                        exit(128);
1848        }
1849
1850        if (unmerged_cache()) {
1851                struct string_list *entries, *re_head, *re_merge;
1852                int i;
1853                string_list_clear(&o->current_file_set, 1);
1854                string_list_clear(&o->current_directory_set, 1);
1855                get_files_dirs(o, head);
1856                get_files_dirs(o, merge);
1857
1858                entries = get_unmerged();
1859                record_df_conflict_files(o, entries);
1860                re_head  = get_renames(o, head, common, head, merge, entries);
1861                re_merge = get_renames(o, merge, common, head, merge, entries);
1862                clean = process_renames(o, re_head, re_merge);
1863                for (i = entries->nr-1; 0 <= i; i--) {
1864                        const char *path = entries->items[i].string;
1865                        struct stage_data *e = entries->items[i].util;
1866                        if (!e->processed
1867                                && !process_entry(o, path, e))
1868                                clean = 0;
1869                }
1870                for (i = 0; i < entries->nr; i++) {
1871                        struct stage_data *e = entries->items[i].util;
1872                        if (!e->processed)
1873                                die(_("Unprocessed path??? %s"),
1874                                    entries->items[i].string);
1875                }
1876
1877                string_list_clear(re_merge, 0);
1878                string_list_clear(re_head, 0);
1879                string_list_clear(entries, 1);
1880
1881                free(re_merge);
1882                free(re_head);
1883                free(entries);
1884        }
1885        else
1886                clean = 1;
1887
1888        if (o->call_depth)
1889                *result = write_tree_from_memory(o);
1890
1891        return clean;
1892}
1893
1894static struct commit_list *reverse_commit_list(struct commit_list *list)
1895{
1896        struct commit_list *next = NULL, *current, *backup;
1897        for (current = list; current; current = backup) {
1898                backup = current->next;
1899                current->next = next;
1900                next = current;
1901        }
1902        return next;
1903}
1904
1905/*
1906 * Merge the commits h1 and h2, return the resulting virtual
1907 * commit object and a flag indicating the cleanness of the merge.
1908 */
1909int merge_recursive(struct merge_options *o,
1910                    struct commit *h1,
1911                    struct commit *h2,
1912                    struct commit_list *ca,
1913                    struct commit **result)
1914{
1915        struct commit_list *iter;
1916        struct commit *merged_common_ancestors;
1917        struct tree *mrtree = mrtree;
1918        int clean;
1919
1920        if (show(o, 4)) {
1921                output(o, 4, _("Merging:"));
1922                output_commit_title(o, h1);
1923                output_commit_title(o, h2);
1924        }
1925
1926        if (!ca) {
1927                ca = get_merge_bases(h1, h2);
1928                ca = reverse_commit_list(ca);
1929        }
1930
1931        if (show(o, 5)) {
1932                unsigned cnt = commit_list_count(ca);
1933
1934                output(o, 5, Q_("found %u common ancestor:",
1935                                "found %u common ancestors:", cnt), cnt);
1936                for (iter = ca; iter; iter = iter->next)
1937                        output_commit_title(o, iter->item);
1938        }
1939
1940        merged_common_ancestors = pop_commit(&ca);
1941        if (merged_common_ancestors == NULL) {
1942                /* if there is no common ancestor, use an empty tree */
1943                struct tree *tree;
1944
1945                tree = lookup_tree(EMPTY_TREE_SHA1_BIN);
1946                merged_common_ancestors = make_virtual_commit(tree, "ancestor");
1947        }
1948
1949        for (iter = ca; iter; iter = iter->next) {
1950                const char *saved_b1, *saved_b2;
1951                o->call_depth++;
1952                /*
1953                 * When the merge fails, the result contains files
1954                 * with conflict markers. The cleanness flag is
1955                 * ignored, it was never actually used, as result of
1956                 * merge_trees has always overwritten it: the committed
1957                 * "conflicts" were already resolved.
1958                 */
1959                discard_cache();
1960                saved_b1 = o->branch1;
1961                saved_b2 = o->branch2;
1962                o->branch1 = "Temporary merge branch 1";
1963                o->branch2 = "Temporary merge branch 2";
1964                merge_recursive(o, merged_common_ancestors, iter->item,
1965                                NULL, &merged_common_ancestors);
1966                o->branch1 = saved_b1;
1967                o->branch2 = saved_b2;
1968                o->call_depth--;
1969
1970                if (!merged_common_ancestors)
1971                        die(_("merge returned no commit"));
1972        }
1973
1974        discard_cache();
1975        if (!o->call_depth)
1976                read_cache();
1977
1978        o->ancestor = "merged common ancestors";
1979        clean = merge_trees(o, h1->tree, h2->tree, merged_common_ancestors->tree,
1980                            &mrtree);
1981
1982        if (o->call_depth) {
1983                *result = make_virtual_commit(mrtree, "merged tree");
1984                commit_list_insert(h1, &(*result)->parents);
1985                commit_list_insert(h2, &(*result)->parents->next);
1986        }
1987        flush_output(o);
1988        if (show(o, 2))
1989                diff_warn_rename_limit("merge.renamelimit",
1990                                       o->needed_rename_limit, 0);
1991        return clean;
1992}
1993
1994static struct commit *get_ref(const struct object_id *oid, const char *name)
1995{
1996        struct object *object;
1997
1998        object = deref_tag(parse_object(oid->hash), name, strlen(name));
1999        if (!object)
2000                return NULL;
2001        if (object->type == OBJ_TREE)
2002                return make_virtual_commit((struct tree*)object, name);
2003        if (object->type != OBJ_COMMIT)
2004                return NULL;
2005        if (parse_commit((struct commit *)object))
2006                return NULL;
2007        return (struct commit *)object;
2008}
2009
2010int merge_recursive_generic(struct merge_options *o,
2011                            const struct object_id *head,
2012                            const struct object_id *merge,
2013                            int num_base_list,
2014                            const struct object_id **base_list,
2015                            struct commit **result)
2016{
2017        int clean;
2018        struct lock_file *lock = xcalloc(1, sizeof(struct lock_file));
2019        struct commit *head_commit = get_ref(head, o->branch1);
2020        struct commit *next_commit = get_ref(merge, o->branch2);
2021        struct commit_list *ca = NULL;
2022
2023        if (base_list) {
2024                int i;
2025                for (i = 0; i < num_base_list; ++i) {
2026                        struct commit *base;
2027                        if (!(base = get_ref(base_list[i], oid_to_hex(base_list[i]))))
2028                                return error(_("Could not parse object '%s'"),
2029                                        oid_to_hex(base_list[i]));
2030                        commit_list_insert(base, &ca);
2031                }
2032        }
2033
2034        hold_locked_index(lock, 1);
2035        clean = merge_recursive(o, head_commit, next_commit, ca,
2036                        result);
2037        if (active_cache_changed &&
2038            write_locked_index(&the_index, lock, COMMIT_LOCK))
2039                return error(_("Unable to write index."));
2040
2041        return clean ? 0 : 1;
2042}
2043
2044static void merge_recursive_config(struct merge_options *o)
2045{
2046        git_config_get_int("merge.verbosity", &o->verbosity);
2047        git_config_get_int("diff.renamelimit", &o->diff_rename_limit);
2048        git_config_get_int("merge.renamelimit", &o->merge_rename_limit);
2049        git_config(git_xmerge_config, NULL);
2050}
2051
2052void init_merge_options(struct merge_options *o)
2053{
2054        memset(o, 0, sizeof(struct merge_options));
2055        o->verbosity = 2;
2056        o->buffer_output = 1;
2057        o->diff_rename_limit = -1;
2058        o->merge_rename_limit = -1;
2059        o->renormalize = 0;
2060        o->detect_rename = 1;
2061        merge_recursive_config(o);
2062        if (getenv("GIT_MERGE_VERBOSITY"))
2063                o->verbosity =
2064                        strtol(getenv("GIT_MERGE_VERBOSITY"), NULL, 10);
2065        if (o->verbosity >= 5)
2066                o->buffer_output = 0;
2067        strbuf_init(&o->obuf, 0);
2068        string_list_init(&o->current_file_set, 1);
2069        string_list_init(&o->current_directory_set, 1);
2070        string_list_init(&o->df_conflict_file_set, 1);
2071}
2072
2073int parse_merge_opt(struct merge_options *o, const char *s)
2074{
2075        const char *arg;
2076
2077        if (!s || !*s)
2078                return -1;
2079        if (!strcmp(s, "ours"))
2080                o->recursive_variant = MERGE_RECURSIVE_OURS;
2081        else if (!strcmp(s, "theirs"))
2082                o->recursive_variant = MERGE_RECURSIVE_THEIRS;
2083        else if (!strcmp(s, "subtree"))
2084                o->subtree_shift = "";
2085        else if (skip_prefix(s, "subtree=", &arg))
2086                o->subtree_shift = arg;
2087        else if (!strcmp(s, "patience"))
2088                o->xdl_opts = DIFF_WITH_ALG(o, PATIENCE_DIFF);
2089        else if (!strcmp(s, "histogram"))
2090                o->xdl_opts = DIFF_WITH_ALG(o, HISTOGRAM_DIFF);
2091        else if (skip_prefix(s, "diff-algorithm=", &arg)) {
2092                long value = parse_algorithm_value(arg);
2093                if (value < 0)
2094                        return -1;
2095                /* clear out previous settings */
2096                DIFF_XDL_CLR(o, NEED_MINIMAL);
2097                o->xdl_opts &= ~XDF_DIFF_ALGORITHM_MASK;
2098                o->xdl_opts |= value;
2099        }
2100        else if (!strcmp(s, "ignore-space-change"))
2101                o->xdl_opts |= XDF_IGNORE_WHITESPACE_CHANGE;
2102        else if (!strcmp(s, "ignore-all-space"))
2103                o->xdl_opts |= XDF_IGNORE_WHITESPACE;
2104        else if (!strcmp(s, "ignore-space-at-eol"))
2105                o->xdl_opts |= XDF_IGNORE_WHITESPACE_AT_EOL;
2106        else if (!strcmp(s, "renormalize"))
2107                o->renormalize = 1;
2108        else if (!strcmp(s, "no-renormalize"))
2109                o->renormalize = 0;
2110        else if (!strcmp(s, "no-renames"))
2111                o->detect_rename = 0;
2112        else if (!strcmp(s, "find-renames")) {
2113                o->detect_rename = 1;
2114                o->rename_score = 0;
2115        }
2116        else if (skip_prefix(s, "find-renames=", &arg) ||
2117                 skip_prefix(s, "rename-threshold=", &arg)) {
2118                if ((o->rename_score = parse_rename_score(&arg)) == -1 || *arg != 0)
2119                        return -1;
2120                o->detect_rename = 1;
2121        }
2122        else
2123                return -1;
2124        return 0;
2125}