git.oblomov.eu Git - git/blob - builtin-merge-recursive.c

   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 "cache-tree.h"
   8 #include "commit.h"
   9 #include "blob.h"
  10 #include "builtin.h"
  11 #include "tree-walk.h"
  12 #include "diff.h"
  13 #include "diffcore.h"
  14 #include "tag.h"
  15 #include "unpack-trees.h"
  16 #include "string-list.h"
  17 #include "xdiff-interface.h"
  18 #include "ll-merge.h"
  19 #include "interpolate.h"
  20 #include "attr.h"
  21 #include "dir.h"
  22 #include "merge-recursive.h"
  23
  24 static int subtree_merge;
  25
  26 static struct tree *shift_tree_object(struct tree *one, struct tree *two)
  27 {
  28         unsigned char shifted[20];
  29
  30         /*
  31          * NEEDSWORK: this limits the recursion depth to hardcoded
  32          * value '2' to avoid excessive overhead.
  33          */
  34         shift_tree(one->object.sha1, two->object.sha1, shifted, 2);
  35         if (!hashcmp(two->object.sha1, shifted))
  36                 return two;
  37         return lookup_tree(shifted);
  38 }
  39
  40 /*
  41  * A virtual commit has
  42  * - (const char *)commit->util set to the name, and
  43  * - *(int *)commit->object.sha1 set to the virtual id.
  44  */
  45
  46 static struct commit *make_virtual_commit(struct tree *tree, const char *comment)
  47 {
  48         struct commit *commit = xcalloc(1, sizeof(struct commit));
  49         static unsigned virtual_id = 1;
  50         commit->tree = tree;
  51         commit->util = (void*)comment;
  52         *(int*)commit->object.sha1 = virtual_id++;
  53         /* avoid warnings */
  54         commit->object.parsed = 1;
  55         return commit;
  56 }
  57
  58 /*
  59  * Since we use get_tree_entry(), which does not put the read object into
  60  * the object pool, we cannot rely on a == b.
  61  */
  62 static int sha_eq(const unsigned char *a, const unsigned char *b)
  63 {
  64         if (!a && !b)
  65                 return 2;
  66         return a && b && hashcmp(a, b) == 0;
  67 }
  68
  69 /*
  70  * Since we want to write the index eventually, we cannot reuse the index
  71  * for these (temporary) data.
  72  */
  73 struct stage_data
  74 {
  75         struct
  76         {
  77                 unsigned mode;
  78                 unsigned char sha[20];
  79         } stages[4];
  80         unsigned processed:1;
  81 };
  82
  83 static struct string_list current_file_set = {NULL, 0, 0, 1};
  84 static struct string_list current_directory_set = {NULL, 0, 0, 1};
  85
  86 static int call_depth = 0;
  87 static int verbosity = 2;
  88 static int diff_rename_limit = -1;
  89 static int merge_rename_limit = -1;
  90 static int buffer_output = 1;
  91 static struct strbuf obuf = STRBUF_INIT;
  92
  93 static int show(int v)
  94 {
  95         return (!call_depth && verbosity >= v) || verbosity >= 5;
  96 }
  97
  98 static void flush_output(void)
  99 {
 100         if (obuf.len) {
 101                 fputs(obuf.buf, stdout);
 102                 strbuf_reset(&obuf);
 103         }
 104 }
 105
 106 static void output(int v, const char *fmt, ...)
 107 {
 108         int len;
 109         va_list ap;
 110
 111         if (!show(v))
 112                 return;
 113
 114         strbuf_grow(&obuf, call_depth * 2 + 2);
 115         memset(obuf.buf + obuf.len, ' ', call_depth * 2);
 116         strbuf_setlen(&obuf, obuf.len + call_depth * 2);
 117
 118         va_start(ap, fmt);
 119         len = vsnprintf(obuf.buf + obuf.len, strbuf_avail(&obuf), fmt, ap);
 120         va_end(ap);
 121
 122         if (len < 0)
 123                 len = 0;
 124         if (len >= strbuf_avail(&obuf)) {
 125                 strbuf_grow(&obuf, len + 2);
 126                 va_start(ap, fmt);
 127                 len = vsnprintf(obuf.buf + obuf.len, strbuf_avail(&obuf), fmt, ap);
 128                 va_end(ap);
 129                 if (len >= strbuf_avail(&obuf)) {
 130                         die("this should not happen, your snprintf is broken");
 131                 }
 132         }
 133         strbuf_setlen(&obuf, obuf.len + len);
 134         strbuf_add(&obuf, "\n", 1);
 135         if (!buffer_output)
 136                 flush_output();
 137 }
 138
 139 static void output_commit_title(struct commit *commit)
 140 {
 141         int i;
 142         flush_output();
 143         for (i = call_depth; i--;)
 144                 fputs("  ", stdout);
 145         if (commit->util)
 146                 printf("virtual %s\n", (char *)commit->util);
 147         else {
 148                 printf("%s ", find_unique_abbrev(commit->object.sha1, DEFAULT_ABBREV));
 149                 if (parse_commit(commit) != 0)
 150                         printf("(bad commit)\n");
 151                 else {
 152                         const char *s;
 153                         int len;
 154                         for (s = commit->buffer; *s; s++)
 155                                 if (*s == '\n' && s[1] == '\n') {
 156                                         s += 2;
 157                                         break;
 158                                 }
 159                         for (len = 0; s[len] && '\n' != s[len]; len++)
 160                                 ; /* do nothing */
 161                         printf("%.*s\n", len, s);
 162                 }
 163         }
 164 }
 165
 166 static int add_cacheinfo(unsigned int mode, const unsigned char *sha1,
 167                 const char *path, int stage, int refresh, int options)
 168 {
 169         struct cache_entry *ce;
 170         ce = make_cache_entry(mode, sha1 ? sha1 : null_sha1, path, stage, refresh);
 171         if (!ce)
 172                 return error("addinfo_cache failed for path '%s'", path);
 173         return add_cache_entry(ce, options);
 174 }
 175
 176 /*
 177  * This is a global variable which is used in a number of places but
 178  * only written to in the 'merge' function.
 179  *
 180  * index_only == 1    => Don't leave any non-stage 0 entries in the cache and
 181  *                       don't update the working directory.
 182  *               0    => Leave unmerged entries in the cache and update
 183  *                       the working directory.
 184  */
 185 static int index_only = 0;
 186
 187 static void init_tree_desc_from_tree(struct tree_desc *desc, struct tree *tree)
 188 {
 189         parse_tree(tree);
 190         init_tree_desc(desc, tree->buffer, tree->size);
 191 }
 192
 193 static int git_merge_trees(int index_only,
 194                            struct tree *common,
 195                            struct tree *head,
 196                            struct tree *merge)
 197 {
 198         int rc;
 199         struct tree_desc t[3];
 200         struct unpack_trees_options opts;
 201
 202         memset(&opts, 0, sizeof(opts));
 203         if (index_only)
 204                 opts.index_only = 1;
 205         else
 206                 opts.update = 1;
 207         opts.merge = 1;
 208         opts.head_idx = 2;
 209         opts.fn = threeway_merge;
 210         opts.src_index = &the_index;
 211         opts.dst_index = &the_index;
 212
 213         init_tree_desc_from_tree(t+0, common);
 214         init_tree_desc_from_tree(t+1, head);
 215         init_tree_desc_from_tree(t+2, merge);
 216
 217         rc = unpack_trees(3, t, &opts);
 218         cache_tree_free(&active_cache_tree);
 219         return rc;
 220 }
 221
 222 struct tree *write_tree_from_memory(void)
 223 {
 224         struct tree *result = NULL;
 225
 226         if (unmerged_cache()) {
 227                 int i;
 228                 output(0, "There are unmerged index entries:");
 229                 for (i = 0; i < active_nr; i++) {
 230                         struct cache_entry *ce = active_cache[i];
 231                         if (ce_stage(ce))
 232                                 output(0, "%d %.*s", ce_stage(ce), ce_namelen(ce), ce->name);
 233                 }
 234                 return NULL;
 235         }
 236
 237         if (!active_cache_tree)
 238                 active_cache_tree = cache_tree();
 239
 240         if (!cache_tree_fully_valid(active_cache_tree) &&
 241             cache_tree_update(active_cache_tree,
 242                               active_cache, active_nr, 0, 0) < 0)
 243                 die("error building trees");
 244
 245         result = lookup_tree(active_cache_tree->sha1);
 246
 247         return result;
 248 }
 249
 250 static int save_files_dirs(const unsigned char *sha1,
 251                 const char *base, int baselen, const char *path,
 252                 unsigned int mode, int stage, void *context)
 253 {
 254         int len = strlen(path);
 255         char *newpath = xmalloc(baselen + len + 1);
 256         memcpy(newpath, base, baselen);
 257         memcpy(newpath + baselen, path, len);
 258         newpath[baselen + len] = '\0';
 259
 260         if (S_ISDIR(mode))
 261                 string_list_insert(newpath, &current_directory_set);
 262         else
 263                 string_list_insert(newpath, &current_file_set);
 264         free(newpath);
 265
 266         return READ_TREE_RECURSIVE;
 267 }
 268
 269 static int get_files_dirs(struct tree *tree)
 270 {
 271         int n;
 272         if (read_tree_recursive(tree, "", 0, 0, NULL, save_files_dirs, NULL))
 273                 return 0;
 274         n = current_file_set.nr + current_directory_set.nr;
 275         return n;
 276 }
 277
 278 /*
 279  * Returns an index_entry instance which doesn't have to correspond to
 280  * a real cache entry in Git's index.
 281  */
 282 static struct stage_data *insert_stage_data(const char *path,
 283                 struct tree *o, struct tree *a, struct tree *b,
 284                 struct string_list *entries)
 285 {
 286         struct string_list_item *item;
 287         struct stage_data *e = xcalloc(1, sizeof(struct stage_data));
 288         get_tree_entry(o->object.sha1, path,
 289                         e->stages[1].sha, &e->stages[1].mode);
 290         get_tree_entry(a->object.sha1, path,
 291                         e->stages[2].sha, &e->stages[2].mode);
 292         get_tree_entry(b->object.sha1, path,
 293                         e->stages[3].sha, &e->stages[3].mode);
 294         item = string_list_insert(path, entries);
 295         item->util = e;
 296         return e;
 297 }
 298
 299 /*
 300  * Create a dictionary mapping file names to stage_data objects. The
 301  * dictionary contains one entry for every path with a non-zero stage entry.
 302  */
 303 static struct string_list *get_unmerged(void)
 304 {
 305         struct string_list *unmerged = xcalloc(1, sizeof(struct string_list));
 306         int i;
 307
 308         unmerged->strdup_strings = 1;
 309
 310         for (i = 0; i < active_nr; i++) {
 311                 struct string_list_item *item;
 312                 struct stage_data *e;
 313                 struct cache_entry *ce = active_cache[i];
 314                 if (!ce_stage(ce))
 315                         continue;
 316
 317                 item = string_list_lookup(ce->name, unmerged);
 318                 if (!item) {
 319                         item = string_list_insert(ce->name, unmerged);
 320                         item->util = xcalloc(1, sizeof(struct stage_data));
 321                 }
 322                 e = item->util;
 323                 e->stages[ce_stage(ce)].mode = ce->ce_mode;
 324                 hashcpy(e->stages[ce_stage(ce)].sha, ce->sha1);
 325         }
 326
 327         return unmerged;
 328 }
 329
 330 struct rename
 331 {
 332         struct diff_filepair *pair;
 333         struct stage_data *src_entry;
 334         struct stage_data *dst_entry;
 335         unsigned processed:1;
 336 };
 337
 338 /*
 339  * Get information of all renames which occurred between 'o_tree' and
 340  * 'tree'. We need the three trees in the merge ('o_tree', 'a_tree' and
 341  * 'b_tree') to be able to associate the correct cache entries with
 342  * the rename information. 'tree' is always equal to either a_tree or b_tree.
 343  */
 344 static struct string_list *get_renames(struct tree *tree,
 345                                         struct tree *o_tree,
 346                                         struct tree *a_tree,
 347                                         struct tree *b_tree,
 348                                         struct string_list *entries)
 349 {
 350         int i;
 351         struct string_list *renames;
 352         struct diff_options opts;
 353
 354         renames = xcalloc(1, sizeof(struct string_list));
 355         diff_setup(&opts);
 356         DIFF_OPT_SET(&opts, RECURSIVE);
 357         opts.detect_rename = DIFF_DETECT_RENAME;
 358         opts.rename_limit = merge_rename_limit >= 0 ? merge_rename_limit :
 359                             diff_rename_limit >= 0 ? diff_rename_limit :
 360                             500;
 361         opts.warn_on_too_large_rename = 1;
 362         opts.output_format = DIFF_FORMAT_NO_OUTPUT;
 363         if (diff_setup_done(&opts) < 0)
 364                 die("diff setup failed");
 365         diff_tree_sha1(o_tree->object.sha1, tree->object.sha1, "", &opts);
 366         diffcore_std(&opts);
 367         for (i = 0; i < diff_queued_diff.nr; ++i) {
 368                 struct string_list_item *item;
 369                 struct rename *re;
 370                 struct diff_filepair *pair = diff_queued_diff.queue[i];
 371                 if (pair->status != 'R') {
 372                         diff_free_filepair(pair);
 373                         continue;
 374                 }
 375                 re = xmalloc(sizeof(*re));
 376                 re->processed = 0;
 377                 re->pair = pair;
 378                 item = string_list_lookup(re->pair->one->path, entries);
 379                 if (!item)
 380                         re->src_entry = insert_stage_data(re->pair->one->path,
 381                                         o_tree, a_tree, b_tree, entries);
 382                 else
 383                         re->src_entry = item->util;
 384
 385                 item = string_list_lookup(re->pair->two->path, entries);
 386                 if (!item)
 387                         re->dst_entry = insert_stage_data(re->pair->two->path,
 388                                         o_tree, a_tree, b_tree, entries);
 389                 else
 390                         re->dst_entry = item->util;
 391                 item = string_list_insert(pair->one->path, renames);
 392                 item->util = re;
 393         }
 394         opts.output_format = DIFF_FORMAT_NO_OUTPUT;
 395         diff_queued_diff.nr = 0;
 396         diff_flush(&opts);
 397         return renames;
 398 }
 399
 400 static int update_stages(const char *path, struct diff_filespec *o,
 401                          struct diff_filespec *a, struct diff_filespec *b,
 402                          int clear)
 403 {
 404         int options = ADD_CACHE_OK_TO_ADD | ADD_CACHE_OK_TO_REPLACE;
 405         if (clear)
 406                 if (remove_file_from_cache(path))
 407                         return -1;
 408         if (o)
 409                 if (add_cacheinfo(o->mode, o->sha1, path, 1, 0, options))
 410                         return -1;
 411         if (a)
 412                 if (add_cacheinfo(a->mode, a->sha1, path, 2, 0, options))
 413                         return -1;
 414         if (b)
 415                 if (add_cacheinfo(b->mode, b->sha1, path, 3, 0, options))
 416                         return -1;
 417         return 0;
 418 }
 419
 420 static int remove_file(int clean, const char *path, int no_wd)
 421 {
 422         int update_cache = index_only || clean;
 423         int update_working_directory = !index_only && !no_wd;
 424
 425         if (update_cache) {
 426                 if (remove_file_from_cache(path))
 427                         return -1;
 428         }
 429         if (update_working_directory) {
 430                 if (remove_path(path))
 431                         return -1;
 432         }
 433         return 0;
 434 }
 435
 436 static char *unique_path(const char *path, const char *branch)
 437 {
 438         char *newpath = xmalloc(strlen(path) + 1 + strlen(branch) + 8 + 1);
 439         int suffix = 0;
 440         struct stat st;
 441         char *p = newpath + strlen(path);
 442         strcpy(newpath, path);
 443         *(p++) = '~';
 444         strcpy(p, branch);
 445         for (; *p; ++p)
 446                 if ('/' == *p)
 447                         *p = '_';
 448         while (string_list_has_string(&current_file_set, newpath) ||
 449                string_list_has_string(&current_directory_set, newpath) ||
 450                lstat(newpath, &st) == 0)
 451                 sprintf(p, "_%d", suffix++);
 452
 453         string_list_insert(newpath, &current_file_set);
 454         return newpath;
 455 }
 456
 457 static void flush_buffer(int fd, const char *buf, unsigned long size)
 458 {
 459         while (size > 0) {
 460                 long ret = write_in_full(fd, buf, size);
 461                 if (ret < 0) {
 462                         /* Ignore epipe */
 463                         if (errno == EPIPE)
 464                                 break;
 465                         die("merge-recursive: %s", strerror(errno));
 466                 } else if (!ret) {
 467                         die("merge-recursive: disk full?");
 468                 }
 469                 size -= ret;
 470                 buf += ret;
 471         }
 472 }
 473
 474 static int make_room_for_path(const char *path)
 475 {
 476         int status;
 477         const char *msg = "failed to create path '%s'%s";
 478
 479         status = safe_create_leading_directories_const(path);
 480         if (status) {
 481                 if (status == -3) {
 482                         /* something else exists */
 483                         error(msg, path, ": perhaps a D/F conflict?");
 484                         return -1;
 485                 }
 486                 die(msg, path, "");
 487         }
 488
 489         /* Successful unlink is good.. */
 490         if (!unlink(path))
 491                 return 0;
 492         /* .. and so is no existing file */
 493         if (errno == ENOENT)
 494                 return 0;
 495         /* .. but not some other error (who really cares what?) */
 496         return error(msg, path, ": perhaps a D/F conflict?");
 497 }
 498
 499 static void update_file_flags(const unsigned char *sha,
 500                               unsigned mode,
 501                               const char *path,
 502                               int update_cache,
 503                               int update_wd)
 504 {
 505         if (index_only)
 506                 update_wd = 0;
 507
 508         if (update_wd) {
 509                 enum object_type type;
 510                 void *buf;
 511                 unsigned long size;
 512
 513                 if (S_ISGITLINK(mode))
 514                         die("cannot read object %s '%s': It is a submodule!",
 515                             sha1_to_hex(sha), path);
 516
 517                 buf = read_sha1_file(sha, &type, &size);
 518                 if (!buf)
 519                         die("cannot read object %s '%s'", sha1_to_hex(sha), path);
 520                 if (type != OBJ_BLOB)
 521                         die("blob expected for %s '%s'", sha1_to_hex(sha), path);
 522                 if (S_ISREG(mode)) {
 523                         struct strbuf strbuf;
 524                         strbuf_init(&strbuf, 0);
 525                         if (convert_to_working_tree(path, buf, size, &strbuf)) {
 526                                 free(buf);
 527                                 size = strbuf.len;
 528                                 buf = strbuf_detach(&strbuf, NULL);
 529                         }
 530                 }
 531
 532                 if (make_room_for_path(path) < 0) {
 533                         update_wd = 0;
 534                         free(buf);
 535                         goto update_index;
 536                 }
 537                 if (S_ISREG(mode) || (!has_symlinks && S_ISLNK(mode))) {
 538                         int fd;
 539                         if (mode & 0100)
 540                                 mode = 0777;
 541                         else
 542                                 mode = 0666;
 543                         fd = open(path, O_WRONLY | O_TRUNC | O_CREAT, mode);
 544                         if (fd < 0)
 545                                 die("failed to open %s: %s", path, strerror(errno));
 546                         flush_buffer(fd, buf, size);
 547                         close(fd);
 548                 } else if (S_ISLNK(mode)) {
 549                         char *lnk = xmemdupz(buf, size);
 550                         safe_create_leading_directories_const(path);
 551                         unlink(path);
 552                         symlink(lnk, path);
 553                         free(lnk);
 554                 } else
 555                         die("do not know what to do with %06o %s '%s'",
 556                             mode, sha1_to_hex(sha), path);
 557                 free(buf);
 558         }
 559  update_index:
 560         if (update_cache)
 561                 add_cacheinfo(mode, sha, path, 0, update_wd, ADD_CACHE_OK_TO_ADD);
 562 }
 563
 564 static void update_file(int clean,
 565                         const unsigned char *sha,
 566                         unsigned mode,
 567                         const char *path)
 568 {
 569         update_file_flags(sha, mode, path, index_only || clean, !index_only);
 570 }
 571
 572 /* Low level file merging, update and removal */
 573
 574 struct merge_file_info
 575 {
 576         unsigned char sha[20];
 577         unsigned mode;
 578         unsigned clean:1,
 579                  merge:1;
 580 };
 581
 582 static void fill_mm(const unsigned char *sha1, mmfile_t *mm)
 583 {
 584         unsigned long size;
 585         enum object_type type;
 586
 587         if (!hashcmp(sha1, null_sha1)) {
 588                 mm->ptr = xstrdup("");
 589                 mm->size = 0;
 590                 return;
 591         }
 592
 593         mm->ptr = read_sha1_file(sha1, &type, &size);
 594         if (!mm->ptr || type != OBJ_BLOB)
 595                 die("unable to read blob object %s", sha1_to_hex(sha1));
 596         mm->size = size;
 597 }
 598
 599 static int merge_3way(mmbuffer_t *result_buf,
 600                       struct diff_filespec *o,
 601                       struct diff_filespec *a,
 602                       struct diff_filespec *b,
 603                       const char *branch1,
 604                       const char *branch2)
 605 {
 606         mmfile_t orig, src1, src2;
 607         char *name1, *name2;
 608         int merge_status;
 609
 610         name1 = xstrdup(mkpath("%s:%s", branch1, a->path));
 611         name2 = xstrdup(mkpath("%s:%s", branch2, b->path));
 612
 613         fill_mm(o->sha1, &orig);
 614         fill_mm(a->sha1, &src1);
 615         fill_mm(b->sha1, &src2);
 616
 617         merge_status = ll_merge(result_buf, a->path, &orig,
 618                                 &src1, name1, &src2, name2,
 619                                 index_only);
 620
 621         free(name1);
 622         free(name2);
 623         free(orig.ptr);
 624         free(src1.ptr);
 625         free(src2.ptr);
 626         return merge_status;
 627 }
 628
 629 static struct merge_file_info merge_file(struct diff_filespec *o,
 630                 struct diff_filespec *a, struct diff_filespec *b,
 631                 const char *branch1, const char *branch2)
 632 {
 633         struct merge_file_info result;
 634         result.merge = 0;
 635         result.clean = 1;
 636
 637         if ((S_IFMT & a->mode) != (S_IFMT & b->mode)) {
 638                 result.clean = 0;
 639                 if (S_ISREG(a->mode)) {
 640                         result.mode = a->mode;
 641                         hashcpy(result.sha, a->sha1);
 642                 } else {
 643                         result.mode = b->mode;
 644                         hashcpy(result.sha, b->sha1);
 645                 }
 646         } else {
 647                 if (!sha_eq(a->sha1, o->sha1) && !sha_eq(b->sha1, o->sha1))
 648                         result.merge = 1;
 649
 650                 /*
 651                  * Merge modes
 652                  */
 653                 if (a->mode == b->mode || a->mode == o->mode)
 654                         result.mode = b->mode;
 655                 else {
 656                         result.mode = a->mode;
 657                         if (b->mode != o->mode) {
 658                                 result.clean = 0;
 659                                 result.merge = 1;
 660                         }
 661                 }
 662
 663                 if (sha_eq(a->sha1, b->sha1) || sha_eq(a->sha1, o->sha1))
 664                         hashcpy(result.sha, b->sha1);
 665                 else if (sha_eq(b->sha1, o->sha1))
 666                         hashcpy(result.sha, a->sha1);
 667                 else if (S_ISREG(a->mode)) {
 668                         mmbuffer_t result_buf;
 669                         int merge_status;
 670
 671                         merge_status = merge_3way(&result_buf, o, a, b,
 672                                                   branch1, branch2);
 673
 674                         if ((merge_status < 0) || !result_buf.ptr)
 675                                 die("Failed to execute internal merge");
 676
 677                         if (write_sha1_file(result_buf.ptr, result_buf.size,
 678                                             blob_type, result.sha))
 679                                 die("Unable to add %s to database",
 680                                     a->path);
 681
 682                         free(result_buf.ptr);
 683                         result.clean = (merge_status == 0);
 684                 } else if (S_ISGITLINK(a->mode)) {
 685                         result.clean = 0;
 686                         hashcpy(result.sha, a->sha1);
 687                 } else if (S_ISLNK(a->mode)) {
 688                         hashcpy(result.sha, a->sha1);
 689
 690                         if (!sha_eq(a->sha1, b->sha1))
 691                                 result.clean = 0;
 692                 } else {
 693                         die("unsupported object type in the tree");
 694                 }
 695         }
 696
 697         return result;
 698 }
 699
 700 static void conflict_rename_rename(struct rename *ren1,
 701                                    const char *branch1,
 702                                    struct rename *ren2,
 703                                    const char *branch2)
 704 {
 705         char *del[2];
 706         int delp = 0;
 707         const char *ren1_dst = ren1->pair->two->path;
 708         const char *ren2_dst = ren2->pair->two->path;
 709         const char *dst_name1 = ren1_dst;
 710         const char *dst_name2 = ren2_dst;
 711         if (string_list_has_string(&current_directory_set, ren1_dst)) {
 712                 dst_name1 = del[delp++] = unique_path(ren1_dst, branch1);
 713                 output(1, "%s is a directory in %s added as %s instead",
 714                        ren1_dst, branch2, dst_name1);
 715                 remove_file(0, ren1_dst, 0);
 716         }
 717         if (string_list_has_string(&current_directory_set, ren2_dst)) {
 718                 dst_name2 = del[delp++] = unique_path(ren2_dst, branch2);
 719                 output(1, "%s is a directory in %s added as %s instead",
 720                        ren2_dst, branch1, dst_name2);
 721                 remove_file(0, ren2_dst, 0);
 722         }
 723         if (index_only) {
 724                 remove_file_from_cache(dst_name1);
 725                 remove_file_from_cache(dst_name2);
 726                 /*
 727                  * Uncomment to leave the conflicting names in the resulting tree
 728                  *
 729                  * update_file(0, ren1->pair->two->sha1, ren1->pair->two->mode, dst_name1);
 730                  * update_file(0, ren2->pair->two->sha1, ren2->pair->two->mode, dst_name2);
 731                  */
 732         } else {
 733                 update_stages(dst_name1, NULL, ren1->pair->two, NULL, 1);
 734                 update_stages(dst_name2, NULL, NULL, ren2->pair->two, 1);
 735         }
 736         while (delp--)
 737                 free(del[delp]);
 738 }
 739
 740 static void conflict_rename_dir(struct rename *ren1,
 741                                 const char *branch1)
 742 {
 743         char *new_path = unique_path(ren1->pair->two->path, branch1);
 744         output(1, "Renamed %s to %s instead", ren1->pair->one->path, new_path);
 745         remove_file(0, ren1->pair->two->path, 0);
 746         update_file(0, ren1->pair->two->sha1, ren1->pair->two->mode, new_path);
 747         free(new_path);
 748 }
 749
 750 static void conflict_rename_rename_2(struct rename *ren1,
 751                                      const char *branch1,
 752                                      struct rename *ren2,
 753                                      const char *branch2)
 754 {
 755         char *new_path1 = unique_path(ren1->pair->two->path, branch1);
 756         char *new_path2 = unique_path(ren2->pair->two->path, branch2);
 757         output(1, "Renamed %s to %s and %s to %s instead",
 758                ren1->pair->one->path, new_path1,
 759                ren2->pair->one->path, new_path2);
 760         remove_file(0, ren1->pair->two->path, 0);
 761         update_file(0, ren1->pair->two->sha1, ren1->pair->two->mode, new_path1);
 762         update_file(0, ren2->pair->two->sha1, ren2->pair->two->mode, new_path2);
 763         free(new_path2);
 764         free(new_path1);
 765 }
 766
 767 static int process_renames(struct string_list *a_renames,
 768                            struct string_list *b_renames,
 769                            const char *a_branch,
 770                            const char *b_branch)
 771 {
 772         int clean_merge = 1, i, j;
 773         struct string_list a_by_dst = {NULL, 0, 0, 0}, b_by_dst = {NULL, 0, 0, 0};
 774         const struct rename *sre;
 775
 776         for (i = 0; i < a_renames->nr; i++) {
 777                 sre = a_renames->items[i].util;
 778                 string_list_insert(sre->pair->two->path, &a_by_dst)->util
 779                         = sre->dst_entry;
 780         }
 781         for (i = 0; i < b_renames->nr; i++) {
 782                 sre = b_renames->items[i].util;
 783                 string_list_insert(sre->pair->two->path, &b_by_dst)->util
 784                         = sre->dst_entry;
 785         }
 786
 787         for (i = 0, j = 0; i < a_renames->nr || j < b_renames->nr;) {
 788                 int compare;
 789                 char *src;
 790                 struct string_list *renames1, *renames2, *renames2Dst;
 791                 struct rename *ren1 = NULL, *ren2 = NULL;
 792                 const char *branch1, *branch2;
 793                 const char *ren1_src, *ren1_dst;
 794
 795                 if (i >= a_renames->nr) {
 796                         compare = 1;
 797                         ren2 = b_renames->items[j++].util;
 798                 } else if (j >= b_renames->nr) {
 799                         compare = -1;
 800                         ren1 = a_renames->items[i++].util;
 801                 } else {
 802                         compare = strcmp(a_renames->items[i].string,
 803                                         b_renames->items[j].string);
 804                         if (compare <= 0)
 805                                 ren1 = a_renames->items[i++].util;
 806                         if (compare >= 0)
 807                                 ren2 = b_renames->items[j++].util;
 808                 }
 809
 810                 /* TODO: refactor, so that 1/2 are not needed */
 811                 if (ren1) {
 812                         renames1 = a_renames;
 813                         renames2 = b_renames;
 814                         renames2Dst = &b_by_dst;
 815                         branch1 = a_branch;
 816                         branch2 = b_branch;
 817                 } else {
 818                         struct rename *tmp;
 819                         renames1 = b_renames;
 820                         renames2 = a_renames;
 821                         renames2Dst = &a_by_dst;
 822                         branch1 = b_branch;
 823                         branch2 = a_branch;
 824                         tmp = ren2;
 825                         ren2 = ren1;
 826                         ren1 = tmp;
 827                 }
 828                 src = ren1->pair->one->path;
 829
 830                 ren1->dst_entry->processed = 1;
 831                 ren1->src_entry->processed = 1;
 832
 833                 if (ren1->processed)
 834                         continue;
 835                 ren1->processed = 1;
 836
 837                 ren1_src = ren1->pair->one->path;
 838                 ren1_dst = ren1->pair->two->path;
 839
 840                 if (ren2) {
 841                         const char *ren2_src = ren2->pair->one->path;
 842                         const char *ren2_dst = ren2->pair->two->path;
 843                         /* Renamed in 1 and renamed in 2 */
 844                         if (strcmp(ren1_src, ren2_src) != 0)
 845                                 die("ren1.src != ren2.src");
 846                         ren2->dst_entry->processed = 1;
 847                         ren2->processed = 1;
 848                         if (strcmp(ren1_dst, ren2_dst) != 0) {
 849                                 clean_merge = 0;
 850                                 output(1, "CONFLICT (rename/rename): "
 851                                        "Rename \"%s\"->\"%s\" in branch \"%s\" "
 852                                        "rename \"%s\"->\"%s\" in \"%s\"%s",
 853                                        src, ren1_dst, branch1,
 854                                        src, ren2_dst, branch2,
 855                                        index_only ? " (left unresolved)": "");
 856                                 if (index_only) {
 857                                         remove_file_from_cache(src);
 858                                         update_file(0, ren1->pair->one->sha1,
 859                                                     ren1->pair->one->mode, src);
 860                                 }
 861                                 conflict_rename_rename(ren1, branch1, ren2, branch2);
 862                         } else {
 863                                 struct merge_file_info mfi;
 864                                 remove_file(1, ren1_src, 1);
 865                                 mfi = merge_file(ren1->pair->one,
 866                                                  ren1->pair->two,
 867                                                  ren2->pair->two,
 868                                                  branch1,
 869                                                  branch2);
 870                                 if (mfi.merge || !mfi.clean)
 871                                         output(1, "Renamed %s->%s", src, ren1_dst);
 872
 873                                 if (mfi.merge)
 874                                         output(2, "Auto-merged %s", ren1_dst);
 875
 876                                 if (!mfi.clean) {
 877                                         output(1, "CONFLICT (content): merge conflict in %s",
 878                                                ren1_dst);
 879                                         clean_merge = 0;
 880
 881                                         if (!index_only)
 882                                                 update_stages(ren1_dst,
 883                                                               ren1->pair->one,
 884                                                               ren1->pair->two,
 885                                                               ren2->pair->two,
 886                                                               1 /* clear */);
 887                                 }
 888                                 update_file(mfi.clean, mfi.sha, mfi.mode, ren1_dst);
 889                         }
 890                 } else {
 891                         /* Renamed in 1, maybe changed in 2 */
 892                         struct string_list_item *item;
 893                         /* we only use sha1 and mode of these */
 894                         struct diff_filespec src_other, dst_other;
 895                         int try_merge, stage = a_renames == renames1 ? 3: 2;
 896
 897                         remove_file(1, ren1_src, index_only || stage == 3);
 898
 899                         hashcpy(src_other.sha1, ren1->src_entry->stages[stage].sha);
 900                         src_other.mode = ren1->src_entry->stages[stage].mode;
 901                         hashcpy(dst_other.sha1, ren1->dst_entry->stages[stage].sha);
 902                         dst_other.mode = ren1->dst_entry->stages[stage].mode;
 903
 904                         try_merge = 0;
 905
 906                         if (string_list_has_string(&current_directory_set, ren1_dst)) {
 907                                 clean_merge = 0;
 908                                 output(1, "CONFLICT (rename/directory): Renamed %s->%s in %s "
 909                                        " directory %s added in %s",
 910                                        ren1_src, ren1_dst, branch1,
 911                                        ren1_dst, branch2);
 912                                 conflict_rename_dir(ren1, branch1);
 913                         } else if (sha_eq(src_other.sha1, null_sha1)) {
 914                                 clean_merge = 0;
 915                                 output(1, "CONFLICT (rename/delete): Renamed %s->%s in %s "
 916                                        "and deleted in %s",
 917                                        ren1_src, ren1_dst, branch1,
 918                                        branch2);
 919                                 update_file(0, ren1->pair->two->sha1, ren1->pair->two->mode, ren1_dst);
 920                         } else if (!sha_eq(dst_other.sha1, null_sha1)) {
 921                                 const char *new_path;
 922                                 clean_merge = 0;
 923                                 try_merge = 1;
 924                                 output(1, "CONFLICT (rename/add): Renamed %s->%s in %s. "
 925                                        "%s added in %s",
 926                                        ren1_src, ren1_dst, branch1,
 927                                        ren1_dst, branch2);
 928                                 new_path = unique_path(ren1_dst, branch2);
 929                                 output(1, "Added as %s instead", new_path);
 930                                 update_file(0, dst_other.sha1, dst_other.mode, new_path);
 931                         } else if ((item = string_list_lookup(ren1_dst, renames2Dst))) {
 932                                 ren2 = item->util;
 933                                 clean_merge = 0;
 934                                 ren2->processed = 1;
 935                                 output(1, "CONFLICT (rename/rename): Renamed %s->%s in %s. "
 936                                        "Renamed %s->%s in %s",
 937                                        ren1_src, ren1_dst, branch1,
 938                                        ren2->pair->one->path, ren2->pair->two->path, branch2);
 939                                 conflict_rename_rename_2(ren1, branch1, ren2, branch2);
 940                         } else
 941                                 try_merge = 1;
 942
 943                         if (try_merge) {
 944                                 struct diff_filespec *o, *a, *b;
 945                                 struct merge_file_info mfi;
 946                                 src_other.path = (char *)ren1_src;
 947
 948                                 o = ren1->pair->one;
 949                                 if (a_renames == renames1) {
 950                                         a = ren1->pair->two;
 951                                         b = &src_other;
 952                                 } else {
 953                                         b = ren1->pair->two;
 954                                         a = &src_other;
 955                                 }
 956                                 mfi = merge_file(o, a, b,
 957                                                 a_branch, b_branch);
 958
 959                                 if (mfi.clean &&
 960                                     sha_eq(mfi.sha, ren1->pair->two->sha1) &&
 961                                     mfi.mode == ren1->pair->two->mode)
 962                                         /*
 963                                          * This messaged is part of
 964                                          * t6022 test. If you change
 965                                          * it update the test too.
 966                                          */
 967                                         output(3, "Skipped %s (merged same as existing)", ren1_dst);
 968                                 else {
 969                                         if (mfi.merge || !mfi.clean)
 970                                                 output(1, "Renamed %s => %s", ren1_src, ren1_dst);
 971                                         if (mfi.merge)
 972                                                 output(2, "Auto-merged %s", ren1_dst);
 973                                         if (!mfi.clean) {
 974                                                 output(1, "CONFLICT (rename/modify): Merge conflict in %s",
 975                                                        ren1_dst);
 976                                                 clean_merge = 0;
 977
 978                                                 if (!index_only)
 979                                                         update_stages(ren1_dst,
 980                                                                       o, a, b, 1);
 981                                         }
 982                                         update_file(mfi.clean, mfi.sha, mfi.mode, ren1_dst);
 983                                 }
 984                         }
 985                 }
 986         }
 987         string_list_clear(&a_by_dst, 0);
 988         string_list_clear(&b_by_dst, 0);
 989
 990         return clean_merge;
 991 }
 992
 993 static unsigned char *stage_sha(const unsigned char *sha, unsigned mode)
 994 {
 995         return (is_null_sha1(sha) || mode == 0) ? NULL: (unsigned char *)sha;
 996 }
 997
 998 /* Per entry merge function */
 999 static int process_entry(const char *path, struct stage_data *entry,
1000                          const char *branch1,
1001                          const char *branch2)
1002 {
1003         /*
1004         printf("processing entry, clean cache: %s\n", index_only ? "yes": "no");
1005         print_index_entry("\tpath: ", entry);
1006         */
1007         int clean_merge = 1;
1008         unsigned o_mode = entry->stages[1].mode;
1009         unsigned a_mode = entry->stages[2].mode;
1010         unsigned b_mode = entry->stages[3].mode;
1011         unsigned char *o_sha = stage_sha(entry->stages[1].sha, o_mode);
1012         unsigned char *a_sha = stage_sha(entry->stages[2].sha, a_mode);
1013         unsigned char *b_sha = stage_sha(entry->stages[3].sha, b_mode);
1014
1015         if (o_sha && (!a_sha || !b_sha)) {
1016                 /* Case A: Deleted in one */
1017                 if ((!a_sha && !b_sha) ||
1018                     (sha_eq(a_sha, o_sha) && !b_sha) ||
1019                     (!a_sha && sha_eq(b_sha, o_sha))) {
1020                         /* Deleted in both or deleted in one and
1021                          * unchanged in the other */
1022                         if (a_sha)
1023                                 output(2, "Removed %s", path);
1024                         /* do not touch working file if it did not exist */
1025                         remove_file(1, path, !a_sha);
1026                 } else {
1027                         /* Deleted in one and changed in the other */
1028                         clean_merge = 0;
1029                         if (!a_sha) {
1030                                 output(1, "CONFLICT (delete/modify): %s deleted in %s "
1031                                        "and modified in %s. Version %s of %s left in tree.",
1032                                        path, branch1,
1033                                        branch2, branch2, path);
1034                                 update_file(0, b_sha, b_mode, path);
1035                         } else {
1036                                 output(1, "CONFLICT (delete/modify): %s deleted in %s "
1037                                        "and modified in %s. Version %s of %s left in tree.",
1038                                        path, branch2,
1039                                        branch1, branch1, path);
1040                                 update_file(0, a_sha, a_mode, path);
1041                         }
1042                 }
1043
1044         } else if ((!o_sha && a_sha && !b_sha) ||
1045                    (!o_sha && !a_sha && b_sha)) {
1046                 /* Case B: Added in one. */
1047                 const char *add_branch;
1048                 const char *other_branch;
1049                 unsigned mode;
1050                 const unsigned char *sha;
1051                 const char *conf;
1052
1053                 if (a_sha) {
1054                         add_branch = branch1;
1055                         other_branch = branch2;
1056                         mode = a_mode;
1057                         sha = a_sha;
1058                         conf = "file/directory";
1059                 } else {
1060                         add_branch = branch2;
1061                         other_branch = branch1;
1062                         mode = b_mode;
1063                         sha = b_sha;
1064                         conf = "directory/file";
1065                 }
1066                 if (string_list_has_string(&current_directory_set, path)) {
1067                         const char *new_path = unique_path(path, add_branch);
1068                         clean_merge = 0;
1069                         output(1, "CONFLICT (%s): There is a directory with name %s in %s. "
1070                                "Added %s as %s",
1071                                conf, path, other_branch, path, new_path);
1072                         remove_file(0, path, 0);
1073                         update_file(0, sha, mode, new_path);
1074                 } else {
1075                         output(2, "Added %s", path);
1076                         update_file(1, sha, mode, path);
1077                 }
1078         } else if (a_sha && b_sha) {
1079                 /* Case C: Added in both (check for same permissions) and */
1080                 /* case D: Modified in both, but differently. */
1081                 const char *reason = "content";
1082                 struct merge_file_info mfi;
1083                 struct diff_filespec o, a, b;
1084
1085                 if (!o_sha) {
1086                         reason = "add/add";
1087                         o_sha = (unsigned char *)null_sha1;
1088                 }
1089                 output(2, "Auto-merged %s", path);
1090                 o.path = a.path = b.path = (char *)path;
1091                 hashcpy(o.sha1, o_sha);
1092                 o.mode = o_mode;
1093                 hashcpy(a.sha1, a_sha);
1094                 a.mode = a_mode;
1095                 hashcpy(b.sha1, b_sha);
1096                 b.mode = b_mode;
1097
1098                 mfi = merge_file(&o, &a, &b,
1099                                  branch1, branch2);
1100
1101                 clean_merge = mfi.clean;
1102                 if (mfi.clean)
1103                         update_file(1, mfi.sha, mfi.mode, path);
1104                 else if (S_ISGITLINK(mfi.mode))
1105                         output(1, "CONFLICT (submodule): Merge conflict in %s "
1106                                "- needs %s", path, sha1_to_hex(b.sha1));
1107                 else {
1108                         output(1, "CONFLICT (%s): Merge conflict in %s",
1109                                         reason, path);
1110
1111                         if (index_only)
1112                                 update_file(0, mfi.sha, mfi.mode, path);
1113                         else
1114                                 update_file_flags(mfi.sha, mfi.mode, path,
1115                                               0 /* update_cache */, 1 /* update_working_directory */);
1116                 }
1117         } else if (!o_sha && !a_sha && !b_sha) {
1118                 /*
1119                  * this entry was deleted altogether. a_mode == 0 means
1120                  * we had that path and want to actively remove it.
1121                  */
1122                 remove_file(1, path, !a_mode);
1123         } else
1124                 die("Fatal merge failure, shouldn't happen.");
1125
1126         return clean_merge;
1127 }
1128
1129 int merge_trees(struct tree *head,
1130                 struct tree *merge,
1131                 struct tree *common,
1132                 const char *branch1,
1133                 const char *branch2,
1134                 struct tree **result)
1135 {
1136         int code, clean;
1137
1138         if (subtree_merge) {
1139                 merge = shift_tree_object(head, merge);
1140                 common = shift_tree_object(head, common);
1141         }
1142
1143         if (sha_eq(common->object.sha1, merge->object.sha1)) {
1144                 output(0, "Already uptodate!");
1145                 *result = head;
1146                 return 1;
1147         }
1148
1149         code = git_merge_trees(index_only, common, head, merge);
1150
1151         if (code != 0)
1152                 die("merging of trees %s and %s failed",
1153                     sha1_to_hex(head->object.sha1),
1154                     sha1_to_hex(merge->object.sha1));
1155
1156         if (unmerged_cache()) {
1157                 struct string_list *entries, *re_head, *re_merge;
1158                 int i;
1159                 string_list_clear(&current_file_set, 1);
1160                 string_list_clear(&current_directory_set, 1);
1161                 get_files_dirs(head);
1162                 get_files_dirs(merge);
1163
1164                 entries = get_unmerged();
1165                 re_head  = get_renames(head, common, head, merge, entries);
1166                 re_merge = get_renames(merge, common, head, merge, entries);
1167                 clean = process_renames(re_head, re_merge,
1168                                 branch1, branch2);
1169                 for (i = 0; i < entries->nr; i++) {
1170                         const char *path = entries->items[i].string;
1171                         struct stage_data *e = entries->items[i].util;
1172                         if (!e->processed
1173                                 && !process_entry(path, e, branch1, branch2))
1174                                 clean = 0;
1175                 }
1176
1177                 string_list_clear(re_merge, 0);
1178                 string_list_clear(re_head, 0);
1179                 string_list_clear(entries, 1);
1180
1181         }
1182         else
1183                 clean = 1;
1184
1185         if (index_only)
1186                 *result = write_tree_from_memory();
1187
1188         return clean;
1189 }
1190
1191 static struct commit_list *reverse_commit_list(struct commit_list *list)
1192 {
1193         struct commit_list *next = NULL, *current, *backup;
1194         for (current = list; current; current = backup) {
1195                 backup = current->next;
1196                 current->next = next;
1197                 next = current;
1198         }
1199         return next;
1200 }
1201
1202 /*
1203  * Merge the commits h1 and h2, return the resulting virtual
1204  * commit object and a flag indicating the cleanness of the merge.
1205  */
1206 int merge_recursive(struct commit *h1,
1207                     struct commit *h2,
1208                     const char *branch1,
1209                     const char *branch2,
1210                     struct commit_list *ca,
1211                     struct commit **result)
1212 {
1213         struct commit_list *iter;
1214         struct commit *merged_common_ancestors;
1215         struct tree *mrtree = mrtree;
1216         int clean;
1217
1218         if (show(4)) {
1219                 output(4, "Merging:");
1220                 output_commit_title(h1);
1221                 output_commit_title(h2);
1222         }
1223
1224         if (!ca) {
1225                 ca = get_merge_bases(h1, h2, 1);
1226                 ca = reverse_commit_list(ca);
1227         }
1228
1229         if (show(5)) {
1230                 output(5, "found %u common ancestor(s):", commit_list_count(ca));
1231                 for (iter = ca; iter; iter = iter->next)
1232                         output_commit_title(iter->item);
1233         }
1234
1235         merged_common_ancestors = pop_commit(&ca);
1236         if (merged_common_ancestors == NULL) {
1237                 /* if there is no common ancestor, make an empty tree */
1238                 struct tree *tree = xcalloc(1, sizeof(struct tree));
1239
1240                 tree->object.parsed = 1;
1241                 tree->object.type = OBJ_TREE;
1242                 pretend_sha1_file(NULL, 0, OBJ_TREE, tree->object.sha1);
1243                 merged_common_ancestors = make_virtual_commit(tree, "ancestor");
1244         }
1245
1246         for (iter = ca; iter; iter = iter->next) {
1247                 call_depth++;
1248                 /*
1249                  * When the merge fails, the result contains files
1250                  * with conflict markers. The cleanness flag is
1251                  * ignored, it was never actually used, as result of
1252                  * merge_trees has always overwritten it: the committed
1253                  * "conflicts" were already resolved.
1254                  */
1255                 discard_cache();
1256                 merge_recursive(merged_common_ancestors, iter->item,
1257                                 "Temporary merge branch 1",
1258                                 "Temporary merge branch 2",
1259                                 NULL,
1260                                 &merged_common_ancestors);
1261                 call_depth--;
1262
1263                 if (!merged_common_ancestors)
1264                         die("merge returned no commit");
1265         }
1266
1267         discard_cache();
1268         if (!call_depth) {
1269                 read_cache();
1270                 index_only = 0;
1271         } else
1272                 index_only = 1;
1273
1274         clean = merge_trees(h1->tree, h2->tree, merged_common_ancestors->tree,
1275                             branch1, branch2, &mrtree);
1276
1277         if (index_only) {
1278                 *result = make_virtual_commit(mrtree, "merged tree");
1279                 commit_list_insert(h1, &(*result)->parents);
1280                 commit_list_insert(h2, &(*result)->parents->next);
1281         }
1282         flush_output();
1283         return clean;
1284 }
1285
1286 static const char *better_branch_name(const char *branch)
1287 {
1288         static char githead_env[8 + 40 + 1];
1289         char *name;
1290
1291         if (strlen(branch) != 40)
1292                 return branch;
1293         sprintf(githead_env, "GITHEAD_%s", branch);
1294         name = getenv(githead_env);
1295         return name ? name : branch;
1296 }
1297
1298 static struct commit *get_ref(const char *ref)
1299 {
1300         unsigned char sha1[20];
1301         struct object *object;
1302
1303         if (get_sha1(ref, sha1))
1304                 die("Could not resolve ref '%s'", ref);
1305         object = deref_tag(parse_object(sha1), ref, strlen(ref));
1306         if (!object)
1307                 return NULL;
1308         if (object->type == OBJ_TREE)
1309                 return make_virtual_commit((struct tree*)object,
1310                         better_branch_name(ref));
1311         if (object->type != OBJ_COMMIT)
1312                 return NULL;
1313         if (parse_commit((struct commit *)object))
1314                 die("Could not parse commit '%s'", sha1_to_hex(object->sha1));
1315         return (struct commit *)object;
1316 }
1317
1318 static int merge_config(const char *var, const char *value, void *cb)
1319 {
1320         if (!strcasecmp(var, "merge.verbosity")) {
1321                 verbosity = git_config_int(var, value);
1322                 return 0;
1323         }
1324         if (!strcasecmp(var, "diff.renamelimit")) {
1325                 diff_rename_limit = git_config_int(var, value);
1326                 return 0;
1327         }
1328         if (!strcasecmp(var, "merge.renamelimit")) {
1329                 merge_rename_limit = git_config_int(var, value);
1330                 return 0;
1331         }
1332         return git_default_config(var, value, cb);
1333 }
1334
1335 int cmd_merge_recursive(int argc, const char **argv, const char *prefix)
1336 {
1337         static const char *bases[20];
1338         static unsigned bases_count = 0;
1339         int i, clean;
1340         const char *branch1, *branch2;
1341         struct commit *result, *h1, *h2;
1342         struct commit_list *ca = NULL;
1343         struct lock_file *lock = xcalloc(1, sizeof(struct lock_file));
1344         int index_fd;
1345
1346         if (argv[0]) {
1347                 int namelen = strlen(argv[0]);
1348                 if (8 < namelen &&
1349                     !strcmp(argv[0] + namelen - 8, "-subtree"))
1350                         subtree_merge = 1;
1351         }
1352
1353         git_config(merge_config, NULL);
1354         if (getenv("GIT_MERGE_VERBOSITY"))
1355                 verbosity = strtol(getenv("GIT_MERGE_VERBOSITY"), NULL, 10);
1356
1357         if (argc < 4)
1358                 die("Usage: %s <base>... -- <head> <remote> ...\n", argv[0]);
1359
1360         for (i = 1; i < argc; ++i) {
1361                 if (!strcmp(argv[i], "--"))
1362                         break;
1363                 if (bases_count < sizeof(bases)/sizeof(*bases))
1364                         bases[bases_count++] = argv[i];
1365         }
1366         if (argc - i != 3) /* "--" "<head>" "<remote>" */
1367                 die("Not handling anything other than two heads merge.");
1368         if (verbosity >= 5)
1369                 buffer_output = 0;
1370
1371         branch1 = argv[++i];
1372         branch2 = argv[++i];
1373
1374         h1 = get_ref(branch1);
1375         h2 = get_ref(branch2);
1376
1377         branch1 = better_branch_name(branch1);
1378         branch2 = better_branch_name(branch2);
1379
1380         if (show(3))
1381                 printf("Merging %s with %s\n", branch1, branch2);
1382
1383         index_fd = hold_locked_index(lock, 1);
1384
1385         for (i = 0; i < bases_count; i++) {
1386                 struct commit *ancestor = get_ref(bases[i]);
1387                 ca = commit_list_insert(ancestor, &ca);
1388         }
1389         clean = merge_recursive(h1, h2, branch1, branch2, ca, &result);
1390
1391         if (active_cache_changed &&
1392             (write_cache(index_fd, active_cache, active_nr) ||
1393              commit_locked_index(lock)))
1394                         die ("unable to write %s", get_index_file());
1395
1396         return clean ? 0: 1;
1397 }