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