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